diff --git a/.github/workflows/ci-validate.yml b/.github/workflows/ci-validate.yml
index 443990a2..b255f165 100644
--- a/.github/workflows/ci-validate.yml
+++ b/.github/workflows/ci-validate.yml
@@ -268,13 +268,53 @@ jobs:
           fi
 
           base_ref="origin/${GITHUB_BASE_REF:-main}"
-          output=$(git log "$base_ref"..HEAD --name-status --pretty=format: -- CHANGELOG.md | sed '/^$/d')
 
-          if [ -n "$output" ]; then
+          # Repairing notes the release workflow itself lost is the one
+          # legitimate reason for a PR to touch CHANGELOG.md — see
+          # "Changelog ownership" in CONTRIBUTING.md. Exempt commits whose
+          # subject is exactly the reserved backfill subject, and only when
+          # they change nothing outside CHANGELOG.md and only add lines.
+          exempt_subject="chore(release): backfill changelog notes"
+
+          # Capture into a variable rather than feeding `git log` straight into
+          # a here-string: a here-string swallows the command substitution's
+          # exit status, so an unresolvable "$base_ref" would read as an empty
+          # commit list and the guard would silently pass.
+          candidates=$(git log "$base_ref"..HEAD --format=%H -- CHANGELOG.md)
+
+          offenders=""
+          while read -r sha; do
+            [ -n "$sha" ] || continue
+            subject=$(git log -1 --format=%s "$sha")
+            if [ "$subject" = "$exempt_subject" ]; then
+              violation=""
+
+              extra=$(git show --name-only --pretty=format: "$sha" | sed '/^$/d' | grep -v '^CHANGELOG.md$' || true)
+              if [ -n "$extra" ]; then
+                echo "::error::$exempt_subject commit $sha also touches files other than CHANGELOG.md"
+                echo "$extra"
+                violation="yes"
+              fi
+
+              deletions=$(git show --numstat --pretty=format: "$sha" -- CHANGELOG.md | awk 'NF { total += $2 } END { print total + 0 }')
+              if [ "$deletions" -ne 0 ]; then
+                echo "::error::$exempt_subject commit $sha removes $deletions CHANGELOG.md line(s); a backfill may only add notes"
+                violation="yes"
+              fi
+
+              if [ -z "$violation" ]; then
+                continue
+              fi
+            fi
+            offenders="$offenders$sha $subject"$'\n'
+          done <<< "$candidates"
+
+          if [ -n "$offenders" ]; then
             echo "::error::CHANGELOG.md is release-workflow-owned and must not appear in PR branch history"
             echo "Drop or amend commits that touch CHANGELOG.md, then push with --force-with-lease"
+            echo "The only exception is an additions-only, CHANGELOG.md-only commit whose subject is exactly: $exempt_subject"
             echo
-            echo "$output"
+            echo "$offenders"
             exit 1
           fi
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 34e61f3b..22a11fb6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,17 +1,147 @@
+## [2026.8.0-next.2](https://github.com/linearis-oss/linearis/compare/v2026.8.0-next.1...v2026.8.0-next.2) (2026-08-10)
+
+### ⚠ BREAKING CHANGES
+
+* **milestones:** a milestone name that the scoped project does not carry
+now fails instead of resolving to a same-named milestone in another
+project.
+* **projects:** `linearis projects archive <project>` is removed. Use
+`linearis projects delete <project>` to trash a project and
+`linearis projects unarchive <project>` to restore it. Linear treats
+archived and trashed projects as one state, so the replacement is
+behaviourally identical.
+
+### Features
+
+* **labels:** full CRUD and retire/restore for project labels ([4bf8dcc](https://github.com/linearis-oss/linearis/commit/4bf8dcc50e69b764f87bc8c1712c2a72f3dcdd76))
+* **labels:** make the group and parent flags reversible ([59d5890](https://github.com/linearis-oss/linearis/commit/59d58900933f939aba1af08439d006f6bde51533))
+* **projects:** administer the workspace project status flow ([a6e1a16](https://github.com/linearis-oss/linearis/commit/a6e1a1613b0beb76a94c807b7dfb7caa7ee19403))
+* **projects:** chronological project activity timeline ([4e81324](https://github.com/linearis-oss/linearis/commit/4e813240026de27618e388c9322c919151e24f02))
+* **projects:** drop archive in favour of delete ([47b509e](https://github.com/linearis-oss/linearis/commit/47b509e79339d5882cfddfd32fca920217f02ce9))
+* **projects:** full-text search and external sync disable ([de351cf](https://github.com/linearis-oss/linearis/commit/de351cfda0b093261f1d3d4c6ae1e0830061bceb))
+* **projects:** manage project dependency relations ([bdd3de0](https://github.com/linearis-oss/linearis/commit/bdd3de0726ca334dc0de4220a120b139c71e1205))
+* **projects:** post and manage project status updates ([c66da2b](https://github.com/linearis-oss/linearis/commit/c66da2b7860438683fd90a39d3e8f91a9ce34709))
+* **projects:** read one dependency and page them workspace-wide ([2e9440c](https://github.com/linearis-oss/linearis/commit/2e9440c3b21b376b37eecaf7115203cd04341853))
+
+### Bug Fixes
+
+* **labels:** reject an empty --parent on update ([fd13029](https://github.com/linearis-oss/linearis/commit/fd13029a135cc2208640d31533425074971ef87c))
+* **labels:** scope --parent to the same team as the label ([d99ee89](https://github.com/linearis-oss/linearis/commit/d99ee89f6302f4e45a276acb73cbb65a4a9e0a99))
+* **milestones:** keep a milestone lookup inside its project ([b143d2b](https://github.com/linearis-oss/linearis/commit/b143d2bf1bd801e757fc913fda2f5157ada7c470))
+* **projects:** anchor relation updates to the right end ([9f5e87a](https://github.com/linearis-oss/linearis/commit/9f5e87ab3a05564297f9dc7e5bdafee01f8afbeb))
+* **projects:** bound and page the project status flow ([9ebdef7](https://github.com/linearis-oss/linearis/commit/9ebdef7301346bcd9ea222b5a1ba989698aa74e3))
+* **projects:** count archived statuses when appending ([1e3b428](https://github.com/linearis-oss/linearis/commit/1e3b4283e7cb375732fa1f1c54475a5f104dcf81))
+* **projects:** refuse a lone relation match past the page bound ([d5eb26d](https://github.com/linearis-oss/linearis/commit/d5eb26d58302b05756837b0c70827df46de2e526))
+* **projects:** refuse to guess between same-named project statuses ([1be4ab1](https://github.com/linearis-oss/linearis/commit/1be4ab102f03ce6582f02100090e46c4f268fac2))
+* **projects:** refuse to guess which relation a project pair means ([fe3508c](https://github.com/linearis-oss/linearis/commit/fe3508c6ec2d8c5e817c4f7b584a4ae97bd68aa5))
+* **projects:** reject a malformed status position ([e01ca0e](https://github.com/linearis-oss/linearis/commit/e01ca0e900d3c731784d2d75aa84a88ae4d81c20))
+* **projects:** reject an empty relation update before resolving it ([d94e51e](https://github.com/linearis-oss/linearis/commit/d94e51eab34fdc55825f448b6b59b95ba47478e6))
+* **projects:** reject pagination flags on per-project relations ([ed7cc89](https://github.com/linearis-oss/linearis/commit/ed7cc89e22368bea83373a8a7b989bc9b81c535b))
+* **projects:** report the relation page bound instead of a miss ([b3886e4](https://github.com/linearis-oss/linearis/commit/b3886e4bc55774d441d021f272664495893487f9))
+* **projects:** say where the projects went when archiving fails ([30664cd](https://github.com/linearis-oss/linearis/commit/30664cd7583443140eebf76a64287d0888bd09aa))
+* **projects:** scope relation milestones on the UUID path ([5824b02](https://github.com/linearis-oss/linearis/commit/5824b02c2a3d3cc51cf36af67f81efa009b3f8ec))
+
+## [2026.8.0-next.1](https://github.com/linearis-oss/linearis/compare/v2026.7.0...v2026.8.0-next.1) (2026-08-10)
+
+### Features
+
+* **attachments:** add disable-sync ([9e7cf04](https://github.com/linearis-oss/linearis/commit/9e7cf044fe240dc665f31a51f5f2b8b820bd6f3c))
+* **issues:** accept subscribers and delegate in batch create ([67ea490](https://github.com/linearis-oss/linearis/commit/67ea490da975d9cc5ded0d2ba2b82ed302710347))
+* **issues:** add batch create and batch update ([fb68bcf](https://github.com/linearis-oss/linearis/commit/fb68bcfd2cc2a47bc9dde0018d88bc2d2374a8f4))
+* **issues:** add from-branch to find an issue by its git branch ([1c0ee8c](https://github.com/linearis-oss/linearis/commit/1c0ee8c97864dea24a4ba2b895f18a4c07639f32))
+* **issues:** add order-by, unassigned, state-type and subscriber filters ([2e01ad3](https://github.com/linearis-oss/linearis/commit/2e01ad344b9dbd3f815b7c15a957283687b4faf2))
+* **issues:** add restore and snooze ([00bf191](https://github.com/linearis-oss/linearis/commit/00bf1919625da595cd51b7f51b7185b24cbd655b))
+* **issues:** add subscribe, share and remind commands ([1530903](https://github.com/linearis-oss/linearis/commit/1530903ddf5962faf53365f17c9600f540b553d7))
+* **issues:** let batch update clear a cycle or milestone ([70aafb9](https://github.com/linearis-oss/linearis/commit/70aafb94c28741056ea49eebf8d5184f96d05f69))
+* **issues:** publish a JSON Schema for batch create documents ([13ed81a](https://github.com/linearis-oss/linearis/commit/13ed81a20e27d97d079b49ab9770564a70095781))
+* **issues:** return url, creator, delegate and lifecycle timestamps ([2d4885e](https://github.com/linearis-oss/linearis/commit/2d4885e9c737bcd1c3e8d7657969c91eb3046ba8))
+* **issues:** support team moves, subscribers and delegates ([8c96db1](https://github.com/linearis-oss/linearis/commit/8c96db11c2f3d61c8cb37174c6e92d633a51f936))
+* **issues:** take batch update from a JSON document too ([60b9491](https://github.com/linearis-oss/linearis/commit/60b94914b724155e4ee9993558e6fc7f13225fd6))
+
+### Bug Fixes
+
+* **issues:** await user lookups so failures stay JSON ([cd42347](https://github.com/linearis-oss/linearis/commit/cd42347d321d51d609ddda92a3434baeebd40a45))
+* **issues:** guard batch update labels across teams too ([c716701](https://github.com/linearis-oss/linearis/commit/c7167010810526ca8d0c790ead1cc0788fb0bd22))
+* **issues:** let a UUID pass the mixed-team batch guard ([5a248a8](https://github.com/linearis-oss/linearis/commit/5a248a8c102af4c3be7a6e4f7f9adcc21464bf22))
+* **issues:** locate the entry when a batch list is malformed ([b83ea52](https://github.com/linearis-oss/linearis/commit/b83ea52695a356ba9650cc68b506010a3ed7bd66))
+* **issues:** make --include-archived surface archived issues ([cb14ec7](https://github.com/linearis-oss/linearis/commit/cb14ec7469a8d421c4ccbd7c7e3112fe95a566d3))
+* **issues:** make archived issues reachable by identifier ([6ac9829](https://github.com/linearis-oss/linearis/commit/6ac98297ed9d4c675d0e77ec59e395313efa4f84))
+* **issues:** name the flag when a relative offset overflows ([634f846](https://github.com/linearis-oss/linearis/commit/634f846900a27993c5ccff402db90e7bc6aa7560))
+* **issues:** resolve a `me` assignee against the viewer ([d5f8198](https://github.com/linearis-oss/linearis/commit/d5f81985ab9632db78b968a043398260c97a336b))
+* **issues:** validate a moved issue's estimate against its new team ([c8d94f1](https://github.com/linearis-oss/linearis/commit/c8d94f1518f0066d5b7153c4a5d0c26f75a430b8))
+* **issues:** validate batch update estimates against the team scale ([31634dc](https://github.com/linearis-oss/linearis/commit/31634dce7b6ebf384475f0188adeb4941b77f6f3))
+* **release:** pin conventionalcommits preset to the writer-v8-compatible line ([fc0276d](https://github.com/linearis-oss/linearis/commit/fc0276d163cf7edce50c41c0533afd902a18a534))
+
+### Performance Improvements
+
+* **issues:** bound the fan-out of batch create ID resolution ([f623be9](https://github.com/linearis-oss/linearis/commit/f623be9c49de173d872c66774a0e0e90dcd61ace))
+
 ## [2026.7.0](https://github.com/linearis-oss/linearis/compare/v2026.6.0...v2026.7.0) (2026-08-07)
 
+### Features
+
+* **initiatives:** add --clear-owner to initiatives update ([fb401ea](https://github.com/linearis-oss/linearis/commit/fb401ea029bd559140567ea61c6ff1493609b3ea)), closes [#282](https://github.com/linearis-oss/linearis/issues/282)
+* **issues:** add --clear-assignee and --clear-project to issues update ([9a5ca75](https://github.com/linearis-oss/linearis/commit/9a5ca7529efdec30d95c77838f947f6e7255b225)), closes [#282](https://github.com/linearis-oss/linearis/issues/282) [#282](https://github.com/linearis-oss/linearis/issues/282)
+
+### Bug Fixes
+
+* **cli:** classify the two option-shaped parse failures ([19ec395](https://github.com/linearis-oss/linearis/commit/19ec3955285f7fcad3d74e21b294604f59d54ccb)), closes [#281](https://github.com/linearis-oss/linearis/issues/281)
+* **cli:** disable Commander's implicit help subcommand ([de405af](https://github.com/linearis-oss/linearis/commit/de405afd709abe27cac3fedf0e06165e7b0becc5)), closes [#281](https://github.com/linearis-oss/linearis/issues/281)
+* **cli:** emit JSON envelope for argument-parse errors ([3bd0e38](https://github.com/linearis-oss/linearis/commit/3bd0e3899d64bfa5195009d686cf2cbdddc4ed06)), closes [#281](https://github.com/linearis-oss/linearis/issues/281)
+* **cli:** give every bare command group the same MISSING_SUBCOMMAND envelope ([b4c3a8b](https://github.com/linearis-oss/linearis/commit/b4c3a8b58690da398c702147b1c1446f00ab34ca))
+* **cli:** keep the usage-error message on a single line ([a447807](https://github.com/linearis-oss/linearis/commit/a4478075c73af9e0c0d3af699c68402559c05343))
+* **common:** point auth recovery at 'auth login', not the bare group ([cca71ec](https://github.com/linearis-oss/linearis/commit/cca71ec64c86148dbaa27987933d6fae05541082)), closes [#281](https://github.com/linearis-oss/linearis/issues/281)
+* **deps:** update dependency commander to v15 ([290424a](https://github.com/linearis-oss/linearis/commit/290424ae2a7f53d3b014de822187429d4fc350b6))
+* **deps:** update dependency graphql to v16.14.2 ([ca72bf7](https://github.com/linearis-oss/linearis/commit/ca72bf7ac32f40643f8b34b7bcafe15675f07226))
+* **deps:** update dependency graphql to v17 ([05bb7af](https://github.com/linearis-oss/linearis/commit/05bb7af33f14b5ab91e6c9797d613ac192c58c80))
+* **projects:** bound project query connections to avoid complexity limit ([dfe97b8](https://github.com/linearis-oss/linearis/commit/dfe97b8f0c3cf15c5fc40a7861f2cd422fdc30b9)), closes [#276](https://github.com/linearis-oss/linearis/issues/276) [#283](https://github.com/linearis-oss/linearis/issues/283)
+* **projects:** surface truncation on bounded connections, lock bounds in tests ([a3145c1](https://github.com/linearis-oss/linearis/commit/a3145c1b99273c11b1e7f077cf2799f63ae4c141)), closes [#276](https://github.com/linearis-oss/linearis/issues/276) [#284](https://github.com/linearis-oss/linearis/issues/284)
+* **usage:** list nested group subcommands in domain usage ([2bff44f](https://github.com/linearis-oss/linearis/commit/2bff44ff745df8e186d4a46f92feaac65ac4740c)), closes [#281](https://github.com/linearis-oss/linearis/issues/281)
+
 ## [2026.7.0-next.6](https://github.com/linearis-oss/linearis/compare/v2026.7.0-next.5...v2026.7.0-next.6) (2026-08-07)
 
+### Bug Fixes
+
+* **projects:** bound project query connections to avoid complexity limit ([dfe97b8](https://github.com/linearis-oss/linearis/commit/dfe97b8f0c3cf15c5fc40a7861f2cd422fdc30b9)), closes [#276](https://github.com/linearis-oss/linearis/issues/276) [#283](https://github.com/linearis-oss/linearis/issues/283)
+* **projects:** surface truncation on bounded connections, lock bounds in tests ([a3145c1](https://github.com/linearis-oss/linearis/commit/a3145c1b99273c11b1e7f077cf2799f63ae4c141)), closes [#276](https://github.com/linearis-oss/linearis/issues/276) [#284](https://github.com/linearis-oss/linearis/issues/284)
+
 ## [2026.7.0-next.5](https://github.com/linearis-oss/linearis/compare/v2026.7.0-next.4...v2026.7.0-next.5) (2026-08-06)
 
+### Bug Fixes
+
+* **deps:** update dependency graphql to v17 ([05bb7af](https://github.com/linearis-oss/linearis/commit/05bb7af33f14b5ab91e6c9797d613ac192c58c80))
+
 ## [2026.7.0-next.4](https://github.com/linearis-oss/linearis/compare/v2026.7.0-next.3...v2026.7.0-next.4) (2026-08-06)
 
+### Bug Fixes
+
+* **cli:** classify the two option-shaped parse failures ([19ec395](https://github.com/linearis-oss/linearis/commit/19ec3955285f7fcad3d74e21b294604f59d54ccb)), closes [#281](https://github.com/linearis-oss/linearis/issues/281)
+* **cli:** disable Commander's implicit help subcommand ([de405af](https://github.com/linearis-oss/linearis/commit/de405afd709abe27cac3fedf0e06165e7b0becc5)), closes [#281](https://github.com/linearis-oss/linearis/issues/281)
+* **cli:** emit JSON envelope for argument-parse errors ([3bd0e38](https://github.com/linearis-oss/linearis/commit/3bd0e3899d64bfa5195009d686cf2cbdddc4ed06)), closes [#281](https://github.com/linearis-oss/linearis/issues/281)
+* **cli:** give every bare command group the same MISSING_SUBCOMMAND envelope ([b4c3a8b](https://github.com/linearis-oss/linearis/commit/b4c3a8b58690da398c702147b1c1446f00ab34ca))
+* **cli:** keep the usage-error message on a single line ([a447807](https://github.com/linearis-oss/linearis/commit/a4478075c73af9e0c0d3af699c68402559c05343))
+* **common:** point auth recovery at 'auth login', not the bare group ([cca71ec](https://github.com/linearis-oss/linearis/commit/cca71ec64c86148dbaa27987933d6fae05541082)), closes [#281](https://github.com/linearis-oss/linearis/issues/281)
+* **usage:** list nested group subcommands in domain usage ([2bff44f](https://github.com/linearis-oss/linearis/commit/2bff44ff745df8e186d4a46f92feaac65ac4740c)), closes [#281](https://github.com/linearis-oss/linearis/issues/281)
+
 ## [2026.7.0-next.3](https://github.com/linearis-oss/linearis/compare/v2026.7.0-next.2...v2026.7.0-next.3) (2026-08-06)
 
+### Features
+
+* **initiatives:** add --clear-owner to initiatives update ([fb401ea](https://github.com/linearis-oss/linearis/commit/fb401ea029bd559140567ea61c6ff1493609b3ea)), closes [#282](https://github.com/linearis-oss/linearis/issues/282)
+* **issues:** add --clear-assignee and --clear-project to issues update ([9a5ca75](https://github.com/linearis-oss/linearis/commit/9a5ca7529efdec30d95c77838f947f6e7255b225)), closes [#282](https://github.com/linearis-oss/linearis/issues/282) [#282](https://github.com/linearis-oss/linearis/issues/282)
+
 ## [2026.7.0-next.2](https://github.com/linearis-oss/linearis/compare/v2026.7.0-next.1...v2026.7.0-next.2) (2026-07-06)
 
+### Bug Fixes
+
+* **deps:** update dependency commander to v15 ([290424a](https://github.com/linearis-oss/linearis/commit/290424ae2a7f53d3b014de822187429d4fc350b6))
+
 ## [2026.7.0-next.1](https://github.com/linearis-oss/linearis/compare/v2026.6.0...v2026.7.0-next.1) (2026-07-06)
 
+### Bug Fixes
+
+* **deps:** update dependency graphql to v16.14.2 ([ca72bf7](https://github.com/linearis-oss/linearis/commit/ca72bf7ac32f40643f8b34b7bcafe15675f07226))
+
 ## [2026.6.0](https://github.com/linearis-oss/linearis/compare/v2026.5.0...v2026.6.0) (2026-07-04)
 
 ### Features
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 01464a42..13386049 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -58,6 +58,28 @@ For the authoritative workflow trigger matrix, required check names, and verific
 `CHANGELOG.md` is release-workflow-owned. Do not edit it in feature/fix PRs.
 If CI reports changelog history violations, rebase on `main` and drop/amend commits that touched `CHANGELOG.md`.
 
+There is one exception, for repairing releases whose notes semantic-release
+failed to render — as happened for `2026.7.0-next.1` … `2026.7.0`, when the
+`conventionalcommits` preset resolved to a version incompatible with the notes
+generator's writer. `guard-changelog-history` in `ci-validate.yml` lets through
+a commit whose subject is exactly:
+
+```
+chore(release): backfill changelog notes
+```
+
+and only when that commit changes nothing but `CHANGELOG.md` and only adds
+lines to it — a backfill that removes or rewrites an existing line fails the
+guard. Every other `CHANGELOG.md` edit stays blocked.
+
+Such a repair must be generated rather than hand-written: re-render the notes
+for each empty section using the commit range from the compare link already in
+its heading, and splice in only the body so the heading's original version,
+date and compare link survive untouched — which is also what keeps the diff
+additions-only, as the guard requires.
+GitHub Release bodies are damaged the same way and cannot be fixed by a
+committed file; a maintainer patches those separately with `gh api`.
+
 ## Pull Requests
 
 1. Fork the repo and create your branch from `main`
diff --git a/README.md b/README.md
index d664ffee..ef89277d 100644
--- a/README.md
+++ b/README.md
@@ -108,9 +108,46 @@ linearis issues replies <root-thread-id>
 linearis issues reply <root-thread-id> --body "I found the root cause"
 ```
 
+### Batch operations
+
+Both batch commands take a JSON document instead of flags, and apply it in a single transaction — either every issue changes or none does. Unknown keys are rejected rather than ignored, so a typo fails the command instead of quietly dropping a field.
+
+`issues batch create` takes an array with one object per issue, keys named after the `issues create` flags:
+
+```json
+[
+  { "title": "Fix login redirect loop", "team": "ENG", "labels": ["bug"] },
+  { "title": "Document the SSO flow", "team": "ENG", "project": "Q3 Auth" }
+]
+```
+
+`issues batch update` takes the targets plus the one patch they share, keys named after the `issues update` flags, where `null` clears a field:
+
+```json
+{
+  "issues": ["ENG-42", "ENG-43"],
+  "patch": { "status": "In Progress", "assignee": "alice", "cycle": null }
+}
+```
+
+```bash
+linearis issues batch create --file issues.json
+linearis issues batch update --file patch.json
+
+# - reads stdin, and --json takes the document inline for one-offs
+generate-issues | linearis issues batch create --file -
+linearis issues batch update --json '{"issues":["ENG-42"],"patch":{"status":"Done"}}'
+```
+
+Both formats are published as JSON Schema (draft 2020-12) in [`schemas/`](schemas/), shipped in the npm package and served raw from the default branch — point a validator or an editor at them to check a document before spending an API call on it.
+
+A schema is the input contract only: it cannot know your team's workflow states, label names, or estimation scale, so a document that validates can still be rejected when a name does not resolve.
+
 ## Coverage
 
-Linear's GraphQL API exposes **537 root operations** (164 queries, 373 mutations). Linearis wires about **75 of them** directly, plus a number of nested reads — chosen to cover planning and issue work end to end rather than the whole API.
+Linear's GraphQL API exposes **520 root operations** (159 queries, 361 mutations). Linearis wires **114 of them** directly, plus a number of nested reads — chosen to cover planning and issue work end to end rather than the whole API.
+
+Both figures are checkable rather than asserted: `npm run count:root-fields -- --verify` parses `graphql/**/*.graphql` and cross-checks the result against a live introspection of the schema.
 
 The table below is the honest picture of the whole surface — what works today, and what you'll need the [Linear MCP](#linearis-vs-linear-mcp) or a raw API call for.
 
@@ -119,26 +156,26 @@ The table below is the honest picture of the whole surface — what works today,
 | Area | Extent | What you can do | Not covered |
 |---|---|---|---|
 | `auth` | ✅ | Interactive login, token status, logout | — |
-| Discussions | ✅ | Root threads and replies on issues, projects, and initiatives; edit, delete, resolve/unresolve; emoji reactions on any of them | Custom workspace emoji management |
-| `issues` | 🟡 | List, filter, full-text search, read, create, update, archive/unarchive, delete; assign labels/assignee/state/priority/project/cycle; relations (list/add/remove); activity history | Batch create/update, subscribe/unsubscribe, share links, reminders, external sync toggles |
+| Discussions | ✅ | Root threads and replies on issues, projects, and initiatives; edit, delete, resolve/unresolve; emoji reactions on any of them | Custom workspace emoji management, and comment threads on a status update — `CommentCreateInput.projectUpdateId` makes an update its own discussion surface, which neither `projects updates` nor `initiatives updates` exposes |
+| `issues` | ✅ | List, filter, full-text search, read, create, update, batch create/update, archive/unarchive, delete/restore, snooze; assign labels/assignee/delegate/state/priority/project/cycle/team (including moves between teams); subscribe/unsubscribe, share/unshare, reminders; find the issue for a git branch (`from-branch`); relations (list/add/remove); activity history | Deliberately excluded: the AI-assist and integration-suggestion queries (Figma file lookup, filter/repository suggestions, title-from-customer-request) — see the Integrations row — and `issuePriorityValues`, a static list already in the help text |
 | `initiatives` | 🟡 | List, read, create, update, archive/unarchive, delete; attach/detach projects; initiative-to-initiative relations; initiative updates (list, read, create, update, archive/unarchive); discussions | Initiative labels, lead-team reassignment, relation reordering |
-| `projects` | 🟡 | List, read, create, update, archive/unarchive, delete; assign project labels by name (`--labels`, `--label-mode`, `--clear-labels`); discussions | Project updates (status posts), project-label CRUD, project relations, project status administration, Slack channel creation |
+| `projects` | ✅ | List, full-text search, read, create, update, delete (trash) and unarchive (restore), disable external sync; assign project labels by name (`--labels`, `--label-mode`, `--clear-labels`); status updates (list, read, create, edit, archive/unarchive, remind); dependency relations (list, read, add, update, remove); administer the workspace project status flow (`projects statuses`); discussions; activity timeline | Deliberately excluded: Slack-channel creation and the AI filter suggestion, which are `[Internal]` integration plumbing — see the Integrations row. Project labels live under `labels --type project`; milestone delete/move under `milestones` |
 | `documents` | 🟡 | List, read, create, update, delete | Content history, document full-text search, unarchive |
 | `milestones` | 🟡 | List, read, create, update (per project) | Delete, reordering/move between projects |
-| `attachments` | 🟡 | List on an issue, create from a URL, delete | Update, and the provider-specific link mutations (GitHub PR/issue, GitLab MR, Slack, Jira, Zendesk, Intercom, Front, Salesforce, Discord) |
+| `attachments` | 🟡 | List on an issue, create from a URL, delete, disable external sync | Update, and the provider-specific link mutations (GitHub PR/issue, GitLab MR, Slack, Jira, Zendesk, Intercom, Front, Salesforce, Discord) |
 | `files` | 🟡 | Upload a file, download via signed URL | Delete uploads, image-from-URL, CSV export reports |
 | `teams` | 🟡 | List, read, create, update; list/add/remove members | Delete, workflow-state administration, triage responsibility, git automation, SLA configuration |
-| `labels` | 🟠 | Issue labels: list, read, create, update, delete; project labels: list (`--type project`) | Project-label create/update/delete, initiative labels, retire/restore |
+| `labels` | 🟡 | Issue and project labels alike (`--type issue\|project`): list, read, create, update, delete, retire/restore; label groups (`--group`, `--parent`) | Initiative labels |
 | `cycles` | 🟠 | List cycles, read a cycle with its issues | Create, update, archive, shift all, start upcoming cycle |
 | `users` | 🟠 | List workspace members | Read a single user, update, role changes, suspend/unsuspend, user settings, session management |
-| Integrations | 🔴 | — | All 73 integration root fields (65 mutations, 8 queries): Slack, GitHub, GitLab, Jira, Figma, Sentry, PagerDuty, Intercom, Salesforce, and more |
+| Integrations | 🔴 | — | All 70 integration root fields (62 mutations, 8 queries): Slack, GitHub, GitLab, Jira, Figma, Sentry, PagerDuty, Intercom, Salesforce, and more. Also the `[Internal]` per-entity integration plumbing excluded from the `issues` and `projects` rows: Slack channel creation and dismissal on a project, Slack/Teams/Jira project posts, and the AI-assist suggestion queries (issue and project filter suggestions, Figma file lookup, title-from-customer-request) |
 | Organization & admin | 🔴 | — | Org settings, invites, domains, webhooks, OAuth apps, audit log, SSO |
 | Releases | 🔴 | — | Releases, release pipelines, stages, release notes |
 | Customers (CRM) | 🔴 | — | Customers, needs, tiers, customer statuses |
 | Views & templates | 🔴 | — | Custom views, favorites, templates, view preferences |
 | Notifications | 🔴 | — | Inbox, subscriptions, snooze, mark read, push subscriptions |
 | Agent sessions | 🔴 | — | Agent sessions, activities, skills, semantic search |
-| Roadmaps | 🔴 | — | Roadmaps and roadmap-to-project links |
+| Roadmaps | 🔴 | — | Roadmaps and roadmap-to-project links. `roadmapToProject*` is deprecated in favour of `initiativeToProject*`, which `initiatives` already wires |
 | Imports & exports | 🔴 | — | Jira/Asana/Clubhouse/GitHub/CSV import jobs |
 | Schedules | 🔴 | — | Time schedules and on-call rotations |
 
@@ -231,6 +268,7 @@ npx skills add linearis-oss/linearis
 
 - [MIGRATION_2026.4.9.md](MIGRATION_2026.4.9.md) — migrating from the deprecated `comments` domain to discussions (v2026.4.9).
 - [`docs/`](docs/) — architecture, development, testing, and build-system references.
+- [`schemas/`](schemas/) — JSON Schemas for the commands that take a JSON document ([batch operations](#batch-operations)).
 - [`docs/ci-run-model.md`](docs/ci-run-model.md) — the authoritative CI/release trigger matrix.
 - [CONTRIBUTING.md](CONTRIBUTING.md) — contributor guidelines.
 - [SECURITY.md](SECURITY.md) — how to report security issues.
diff --git a/docs/architecture.md b/docs/architecture.md
index d8c9477e..277a028b 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -127,7 +127,7 @@ Shared utilities used across layers.
 - **src/commands/cycles.ts** - Cycle listing and reading
 - **src/commands/teams.ts** - Team listing
 - **src/commands/users.ts** - User listing
-- **src/commands/projects.ts** - Project listing
+- **src/commands/projects/** - Project commands (`index.ts` registers the domain, `entity.ts` holds CRUD and discussions)
 - **src/commands/labels.ts** - Label listing
 - **src/commands/comments.ts** - Comment creation
 - **src/commands/embeds.ts** - File operations
diff --git a/docs/files.md b/docs/files.md
index 788e6edf..f39b7c9e 100644
--- a/docs/files.md
+++ b/docs/files.md
@@ -22,7 +22,9 @@ Each resolver converts a human-friendly identifier (name, key, or slug) into a U
 - **cycle-resolver.ts** -- `resolveCycleId(client, nameOrId, teamFilter?)`
 - **status-resolver.ts** -- `resolveStatusId(client, nameOrId, teamId?)`
 - **issue-resolver.ts** -- `resolveIssueId(client, issueIdOrIdentifier)`
-- **milestone-resolver.ts** -- `resolveMilestoneId(gqlClient, sdkClient, nameOrId, projectNameOrId?)`
+- **milestone-resolver.ts** -- `resolveMilestoneId(gqlClient, nameOrId, projectNameOrId?)` — a project scope is authoritative, never widened to the workspace
+- **project-status-resolver.ts** -- `resolveProjectStatusId(client, nameOrId, { includeArchived? })`
+- **project-relation-resolver.ts** -- `resolveProjectRelation(client, relationOrProjectId, relatedProjectId?)` — returns `{ id, inverted }`; `inverted` tells callers writing per-end fields to swap the two ends
 
 ## Service Layer (`src/services/`)
 
@@ -35,8 +37,12 @@ Business logic and CRUD operations. Services use `GraphQLClient` exclusively and
 - **cycle-service.ts** -- `listCycles`, `getCycle`
 - **team-service.ts** -- `listTeams`
 - **user-service.ts** -- `listUsers`
-- **project-service.ts** -- `listProjects`
-- **label-service.ts** -- `listLabels`
+- **project-service.ts** -- `listProjects`, `searchProjects`, `getProject`, `createProject`, `updateProject`, `applyProjectLabels`, `disableProjectExternalSync`, `unarchiveProject`, `deleteProject`
+- **project-update-service.ts** -- Project status posts: `listProjectUpdates`, `getProjectUpdate`, `createProjectUpdate`, `editProjectUpdate`, archive/unarchive, `remindProjectUpdate`
+- **project-status-service.ts** -- The workspace project status flow: list/get/create/update, `reassignProjectStatus`, archive/unarchive
+- **project-relation-service.ts** -- Project dependencies: list (per project and workspace-wide), get, create, update, delete
+- **project-activity-service.ts** -- Merges project discussions, history and status updates into one chronological timeline
+- **label-service.ts** -- `listLabels`, `listProjectLabels`, and get/create/update/delete/retire/restore dispatching on `LabelType`
 - **comment-service.ts** -- `createComment`
 - **file-service.ts** -- File upload and download operations for Linear uploads
 
@@ -46,13 +52,14 @@ CLI orchestration. Each file registers a command group via a `setup*Commands(pro
 
 - **auth.ts** -- `auth login`, `auth status`, `auth logout` — interactive authentication (for humans)
 - **issues.ts** -- `issue list`, `issue search`, `issue read`, `issue create`, `issue update`
+- **issues-batch.ts** -- `issues batch create`, `issues batch update` — the bulk subgroup, split out because it takes a JSON document rather than flags
 - **documents.ts** -- Document commands with attachment support
 - **project-milestones.ts** -- Milestone CRUD commands
 - **cycles.ts** -- Cycle listing and detail reading
 - **teams.ts** -- Team listing
 - **users.ts** -- User listing
-- **projects.ts** -- Project listing
-- **labels.ts** -- Label listing
+- **projects/** -- Project commands. `index.ts` owns `PROJECTS_META` and registers the domain; `entity.ts` holds CRUD, search, sync and discussions; `updates.ts`, `statuses.ts` and `relations.ts` hold the subgroups
+- **labels.ts** -- Label commands for both issue and project labels (`--type`)
 - **comments.ts** -- Comment creation
 - **embeds.ts** -- File download from Linear upload URLs
 
@@ -66,7 +73,9 @@ Shared utilities used across all layers.
 - **encryption.ts** -- AES-256-CBC encryption for token storage.
 - **output.ts** -- `outputSuccess()`, `outputError()`, and `handleCommand()` wrapper for consistent JSON output and error handling.
 - **errors.ts** -- `notFoundError()`, `multipleMatchesError()`, `invalidParameterError()`, `requiresParameterError()`.
-- **identifier.ts** -- `isUuid()`, `parseIssueIdentifier()`, `tryParseIssueIdentifier()`.
+- **identifier.ts** -- `isUuid()`, `parseIssueIdentifier()`, `tryParseIssueIdentifier()`, `parseDueDate()` (Linear's timeless `TimelessDate`).
+- **datetime.ts** -- `parseDateTimeOption(flag, value, now?)` for the `DateTime` flags (`remind --at`, `snooze --until`): ISO-8601 or a `+2h`/`+3d` offset, normalized to UTC.
+- **git.ts** -- `getCurrentBranch()` for `issues from-branch`; shells out via `execFileSync`, never a shell.
 - **types.ts** -- Type aliases derived from codegen output (e.g., `Issue`, `IssueDetail`, `Document`).
 - **embed-parser.ts** -- `extractEmbeds()`, `isLinearUploadUrl()`, `extractFilenameFromUrl()` for parsing embedded files in markdown content.
 - **usage.ts** -- Token-optimized two-tier usage system with `DomainMeta` interface, `formatOverview()` for tier 1 (all domains), and `formatDomainUsage()` for tier 2 (domain detail). Generates USAGE.md via build pipeline.
@@ -100,6 +109,15 @@ Source `.graphql` files that feed into code generation.
 - `mutations/files.graphql`
 - `mutations/project-milestones.graphql`
 
+## Input Schemas (`schemas/`)
+
+Hand-written JSON Schemas for the commands that take a JSON document instead of flags. Nothing reads them at runtime — they exist for callers (editors, validators, agents) and are shipped in the npm package via `files` in `package.json`.
+
+- **issues-batch-create.schema.json** -- the `issues batch create` document (an array of issues to create).
+- **issues-batch-update.schema.json** -- the `issues batch update` document (`issues` plus the one `patch` they share, where `null` clears a field).
+
+Both are kept in step with their parsers in `src/commands/issues-batch.ts` (`parseBatchCreateEntries`, `parseBatchUpdateDocument`) by `tests/unit/commands/issues-batch-schema.test.ts`; extend both when adding a field.
+
 ## Tests (`tests/`)
 
 Unit tests mirror the source structure. Resolver and service tests both mock the `GraphQLClient` (`request`); common tests require no mocks.
diff --git a/graphql/mutations/attachments.graphql b/graphql/mutations/attachments.graphql
index 7e12274a..2ab7980b 100644
--- a/graphql/mutations/attachments.graphql
+++ b/graphql/mutations/attachments.graphql
@@ -22,6 +22,20 @@ mutation AttachmentCreate($input: AttachmentCreateInput!) {
   }
 }
 
+# Stop syncing an issue with the external resource behind an attachment
+#
+# Despite the `issue*` prefix the mutation is keyed by attachment, not issue:
+# a single issue can carry several synced attachments and they are disabled
+# one at a time. It returns the affected issue.
+mutation AttachmentExternalSyncDisable($attachmentId: String!) {
+  issueExternalSyncDisable(attachmentId: $attachmentId) {
+    success
+    issue {
+      ...CompleteIssueFields
+    }
+  }
+}
+
 # Delete an attachment
 #
 # Deletes an attachment and returns success status.
diff --git a/graphql/mutations/issues.graphql b/graphql/mutations/issues.graphql
index 7943ff29..5b367dca 100644
--- a/graphql/mutations/issues.graphql
+++ b/graphql/mutations/issues.graphql
@@ -51,6 +51,84 @@ mutation UnarchiveIssue($id: String!) {
   }
 }
 
+# Create many issues in one transaction
+#
+# The batch payload returns the created issues without the per-issue comment
+# thread: a freshly created issue has no comments, and CompleteIssueFields
+# keeps the response proportional to the batch size.
+mutation BatchCreateIssues($input: IssueBatchCreateInput!) {
+  issueBatchCreate(input: $input) {
+    success
+    issues {
+      ...CompleteIssueFields
+    }
+  }
+}
+
+# Apply one patch to an explicit list of issues
+mutation BatchUpdateIssues($ids: [UUID!]!, $input: IssueUpdateInput!) {
+  issueBatchUpdate(ids: $ids, input: $input) {
+    success
+    issues {
+      ...CompleteIssueFields
+    }
+  }
+}
+
+# Subscribe a user to an issue's notifications
+#
+# The API accepts either userId or userEmail; the CLI always resolves to a
+# UUID first (resolvers own ID resolution), so only userId is threaded through.
+mutation SubscribeToIssue($id: String!, $userId: String!) {
+  issueSubscribe(id: $id, userId: $userId) {
+    success
+    issue {
+      ...CompleteIssueWithDefaultCommentsFields
+    }
+  }
+}
+
+mutation UnsubscribeFromIssue($id: String!, $userId: String!) {
+  issueUnsubscribe(id: $id, userId: $userId) {
+    success
+    issue {
+      ...CompleteIssueWithDefaultCommentsFields
+    }
+  }
+}
+
+# Grant a user access to an issue they could not otherwise see
+#
+# Despite the name this does not mint a shareable link — the issue's own
+# permalink is the `url` field on the read payload.
+mutation ShareIssue($id: String!, $userId: String!) {
+  issueShare(id: $id, userId: $userId) {
+    success
+    issue {
+      ...CompleteIssueWithDefaultCommentsFields
+    }
+  }
+}
+
+mutation UnshareIssue($id: String!, $userId: String!) {
+  issueUnshare(id: $id, userId: $userId) {
+    success
+    issue {
+      ...CompleteIssueWithDefaultCommentsFields
+    }
+  }
+}
+
+# Schedule a reminder for the viewer on an issue
+mutation RemindOnIssue($id: String!, $reminderAt: DateTime!) {
+  issueReminder(id: $id, reminderAt: $reminderAt) {
+    success
+    issue {
+      ...CompleteIssueWithDefaultCommentsFields
+    }
+  }
+}
+
 mutation DeleteIssue($id: String!) {
   issueDelete(id: $id) {
     success
diff --git a/graphql/mutations/labels.graphql b/graphql/mutations/labels.graphql
index 460afeed..44f7ee9b 100644
--- a/graphql/mutations/labels.graphql
+++ b/graphql/mutations/labels.graphql
@@ -1,5 +1,8 @@
 # ------------------------------------------------------------
-# GraphQL mutations for Linear issue labels
+# GraphQL mutations for Linear issue and project labels
+#
+# The two label kinds are separate types with parallel mutations;
+# `labels --type issue|project` picks between them.
 # ------------------------------------------------------------
 
 mutation CreateIssueLabel($input: IssueLabelCreateInput!) {
@@ -26,3 +29,68 @@ mutation DeleteIssueLabel($id: String!) {
     entityId
   }
 }
+
+# Retire an issue label
+#
+# Retired labels stay on the issues that already carry them but cannot be
+# applied to new ones — a softer alternative to delete.
+mutation RetireIssueLabel($id: String!) {
+  issueLabelRetire(id: $id) {
+    success
+    issueLabel {
+      ...LabelFields
+    }
+  }
+}
+
+mutation RestoreIssueLabel($id: String!) {
+  issueLabelRestore(id: $id) {
+    success
+    issueLabel {
+      ...LabelFields
+    }
+  }
+}
+
+mutation CreateProjectLabel($input: ProjectLabelCreateInput!) {
+  projectLabelCreate(input: $input) {
+    success
+    projectLabel {
+      ...ProjectLabelFields
+    }
+  }
+}
+
+mutation UpdateProjectLabel($id: String!, $input: ProjectLabelUpdateInput!) {
+  projectLabelUpdate(id: $id, input: $input) {
+    success
+    projectLabel {
+      ...ProjectLabelFields
+    }
+  }
+}
+
+mutation DeleteProjectLabel($id: String!) {
+  projectLabelDelete(id: $id) {
+    success
+    entityId
+  }
+}
+
+mutation RetireProjectLabel($id: String!) {
+  projectLabelRetire(id: $id) {
+    success
+    projectLabel {
+      ...ProjectLabelFields
+    }
+  }
+}
+
+mutation RestoreProjectLabel($id: String!) {
+  projectLabelRestore(id: $id) {
+    success
+    projectLabel {
+      ...ProjectLabelFields
+    }
+  }
+}
diff --git a/graphql/mutations/project-relations.graphql b/graphql/mutations/project-relations.graphql
new file mode 100644
index 00000000..57aafca2
--- /dev/null
+++ b/graphql/mutations/project-relations.graphql
@@ -0,0 +1,31 @@
+# ------------------------------------------------------------
+# GraphQL mutations for Linear project dependency relations
+# ------------------------------------------------------------
+
+mutation CreateProjectRelation($input: ProjectRelationCreateInput!) {
+  projectRelationCreate(input: $input) {
+    success
+    projectRelation {
+      ...ProjectRelationCoreFields
+    }
+  }
+}
+
+mutation UpdateProjectRelation(
+  $id: String!
+  $input: ProjectRelationUpdateInput!
+) {
+  projectRelationUpdate(id: $id, input: $input) {
+    success
+    projectRelation {
+      ...ProjectRelationCoreFields
+    }
+  }
+}
+
+mutation DeleteProjectRelation($id: String!) {
+  projectRelationDelete(id: $id) {
+    success
+    entityId
+  }
+}
diff --git a/graphql/mutations/project-statuses.graphql b/graphql/mutations/project-statuses.graphql
new file mode 100644
index 00000000..70aa2a33
--- /dev/null
+++ b/graphql/mutations/project-statuses.graphql
@@ -0,0 +1,58 @@
+# ------------------------------------------------------------
+# GraphQL mutations for the workspace project status flow
+# ------------------------------------------------------------
+
+mutation CreateProjectStatus($input: ProjectStatusCreateInput!) {
+  projectStatusCreate(input: $input) {
+    success
+    status {
+      ...ProjectStatusCoreFields
+    }
+  }
+}
+
+mutation UpdateProjectStatus($id: String!, $input: ProjectStatusUpdateInput!) {
+  projectStatusUpdate(id: $id, input: $input) {
+    success
+    status {
+      ...ProjectStatusCoreFields
+    }
+  }
+}
+
+# Archive a status
+#
+# Linear refuses this while projects are still assigned to the status, or
+# when it is the last status of its type.
+mutation ArchiveProjectStatus($id: String!) {
+  projectStatusArchive(id: $id) {
+    success
+    entity {
+      ...ProjectStatusCoreFields
+    }
+  }
+}
+
+mutation UnarchiveProjectStatus($id: String!) {
+  projectStatusUnarchive(id: $id) {
+    success
+    entity {
+      ...ProjectStatusCoreFields
+    }
+  }
+}
+
+# Move every project off one status and onto another
+#
+# The payload carries no entity — only whether the reassignment ran.
+mutation ReassignProjectStatus(
+  $originalProjectStatusId: String!
+  $newProjectStatusId: String!
+) {
+  projectReassignStatus(
+    originalProjectStatusId: $originalProjectStatusId
+    newProjectStatusId: $newProjectStatusId
+  ) {
+    success
+  }
+}
diff --git a/graphql/mutations/project-updates.graphql b/graphql/mutations/project-updates.graphql
new file mode 100644
index 00000000..c0be183f
--- /dev/null
+++ b/graphql/mutations/project-updates.graphql
@@ -0,0 +1,52 @@
+# ------------------------------------------------------------
+# GraphQL mutations for Linear project status updates
+#
+# `projectUpdateDelete` is deliberately not wired: Linear deprecates it
+# in favour of `projectUpdateArchive`, which is reversible.
+# ------------------------------------------------------------
+
+mutation CreateProjectUpdate($input: ProjectUpdateCreateInput!) {
+  projectUpdateCreate(input: $input) {
+    success
+    projectUpdate {
+      ...ProjectUpdateCoreFields
+    }
+  }
+}
+
+mutation EditProjectUpdate($id: String!, $input: ProjectUpdateUpdateInput!) {
+  projectUpdateUpdate(id: $id, input: $input) {
+    success
+    projectUpdate {
+      ...ProjectUpdateCoreFields
+    }
+  }
+}
+
+mutation ArchiveProjectUpdate($id: String!) {
+  projectUpdateArchive(id: $id) {
+    success
+    entity {
+      ...ProjectUpdateCoreFields
+    }
+  }
+}
+
+mutation UnarchiveProjectUpdate($id: String!) {
+  projectUpdateUnarchive(id: $id) {
+    success
+    entity {
+      ...ProjectUpdateCoreFields
+    }
+  }
+}
+
+# Nudge someone to post the next update
+#
+# The payload carries no entity — there is nothing to return but whether
+# the notification was created.
+mutation CreateProjectUpdateReminder($projectId: String!, $userId: String) {
+  createProjectUpdateReminder(projectId: $projectId, userId: $userId) {
+    success
+  }
+}
diff --git a/graphql/mutations/projects.graphql b/graphql/mutations/projects.graphql
index b0ce91c0..e505b746 100644
--- a/graphql/mutations/projects.graphql
+++ b/graphql/mutations/projects.graphql
@@ -30,8 +30,12 @@ mutation UpdateProject($id: String!, $input: ProjectUpdateInput!) {
   }
 }
 
-mutation ArchiveProject($id: String!) {
-  projectArchive(id: $id) {
+# Restore a trashed project
+#
+# Linear collapses "archived" and "trashed" into a single state, so this
+# restores whatever projectDelete put away.
+mutation UnarchiveProject($id: String!) {
+  projectUnarchive(id: $id) {
     success
     entity {
       ...ProjectDetailWithDefaultConnectionsFields
@@ -39,8 +43,11 @@ mutation ArchiveProject($id: String!) {
   }
 }
 
-mutation UnarchiveProject($id: String!) {
-  projectUnarchive(id: $id) {
+# Trash a project
+#
+# Reversible: UnarchiveProject restores it.
+mutation DeleteProject($id: String!) {
+  projectDelete(id: $id) {
     success
     entity {
       ...ProjectDetailWithDefaultConnectionsFields
@@ -48,10 +55,39 @@ mutation UnarchiveProject($id: String!) {
   }
 }
 
-mutation DeleteProject($id: String!) {
-  projectDelete(id: $id) {
+# Stop syncing a project with an external tracker
+#
+# Mirrors `attachments disable-sync`: the link stays, the updates stop.
+mutation DisableProjectExternalSync(
+  $projectId: String!
+  $syncSource: ExternalSyncService!
+) {
+  projectExternalSyncDisable(projectId: $projectId, syncSource: $syncSource) {
     success
-    entity {
+    project {
+      ...ProjectDetailWithDefaultConnectionsFields
+    }
+  }
+}
+
+# Add one label to a project
+#
+# Incremental, unlike `ProjectUpdateInput.labelIds`, which replaces the
+# whole set — so `--label-mode add` needs no read of the current labels
+# and cannot drop the ones it did not see.
+mutation AddProjectLabel($id: String!, $labelId: String!) {
+  projectAddLabel(id: $id, labelId: $labelId) {
+    success
+    project {
+      ...ProjectDetailWithDefaultConnectionsFields
+    }
+  }
+}
+
+mutation RemoveProjectLabel($id: String!, $labelId: String!) {
+  projectRemoveLabel(id: $id, labelId: $labelId) {
+    success
+    project {
       ...ProjectDetailWithDefaultConnectionsFields
     }
   }
diff --git a/graphql/queries/issues.graphql b/graphql/queries/issues.graphql
index 32d936d2..50b03a4b 100644
--- a/graphql/queries/issues.graphql
+++ b/graphql/queries/issues.graphql
@@ -17,20 +17,35 @@ fragment CompleteIssueFields on Issue {
   identifier
   title
   description
+  url
   branchName
   priority
   estimate
   dueDate
   createdAt
   updatedAt
+  startedAt
+  completedAt
+  canceledAt
+  archivedAt
+  snoozedUntilAt
+  trashed
   state {
     id
     name
   }
+  creator {
+    id
+    name
+  }
   assignee {
     id
     name
   }
+  delegate {
+    id
+    name
+  }
   team {
     id
     key
@@ -90,6 +105,26 @@ fragment CompleteIssueFields on Issue {
   }
 }
 
+# Per-issue detail that is deliberately absent from CompleteIssueFields
+#
+# A subscriber roster and a sharing summary are worth one round-trip when the
+# caller asked for one issue, but they would multiply across every row of a
+# 50-issue list for no benefit — so they hang off the single-read fragments
+# only, not off the shared list fragment.
+fragment IssueDetailOnlyFields on Issue {
+  subscribers {
+    nodes {
+      id
+      name
+    }
+  }
+  sharedAccess {
+    isShared
+    sharedWithCount
+    viewerHasOnlySharedAccess
+  }
+}
+
 # Minimal comment fields preserved for default issue reads
 fragment IssueReadDefaultCommentFields on Comment {
   id
@@ -115,6 +150,7 @@ fragment IssueReadCommentFields on Comment {
 # discussion metadata behind explicit flags.
 fragment CompleteIssueWithDefaultCommentsFields on Issue {
   ...CompleteIssueFields
+  ...IssueDetailOnlyFields
   comments {
     nodes {
       ...IssueReadDefaultCommentFields
@@ -129,6 +165,7 @@ fragment CompleteIssueWithDefaultCommentsFields on Issue {
 # relationships (state, assignee, team, project, labels, comments).
 fragment CompleteIssueWithCommentsFields on Issue {
   ...CompleteIssueFields
+  ...IssueDetailOnlyFields
   comments {
     nodes {
       ...IssueReadCommentFields
@@ -154,20 +191,35 @@ fragment CompleteIssueSearchFields on IssueSearchResult {
   identifier
   title
   description
+  url
   branchName
   priority
   estimate
   dueDate
   createdAt
   updatedAt
+  startedAt
+  completedAt
+  canceledAt
+  archivedAt
+  snoozedUntilAt
+  trashed
   state {
     id
     name
   }
+  creator {
+    id
+    name
+  }
   assignee {
     id
     name
   }
+  delegate {
+    id
+    name
+  }
   team {
     id
     key
@@ -227,28 +279,6 @@ fragment CompleteIssueSearchFields on IssueSearchResult {
   }
 }
 
-# Get issues list with all relationships in single query
-#
-# Fetches paginated issues excluding completed ones,
-# ordered by most recently updated. Includes all relationships
-# for comprehensive issue data.
-query GetIssues($first: Int!, $after: String, $orderBy: PaginationOrderBy) {
-  issues(
-    first: $first
-    after: $after
-    orderBy: $orderBy
-    filter: { state: { type: { neq: "completed" } } }
-  ) {
-    nodes {
-      ...CompleteIssueFields
-    }
-    pageInfo {
-      hasNextPage
-      endCursor
-    }
-  }
-}
-
 # Get single issue by UUID with lean fields
 #
 # Fetches issue data by direct UUID lookup with the backward-compatible
@@ -263,10 +293,14 @@ query GetIssueById($id: String!) {
 #
 # Fetches issue using TEAM-123 format with the backward-compatible
 # default comment payload.
+#
+# includeArchived matches the UUID path (`issue(id:)` returns archived issues):
+# reading an issue by its identifier must not silently 404 once it is archived.
 query GetIssueByIdentifier($teamKey: String!, $number: Float!) {
   issues(
     filter: { team: { key: { eq: $teamKey } }, number: { eq: $number } }
     first: 1
+    includeArchived: true
   ) {
     nodes {
       ...CompleteIssueWithDefaultCommentsFields
@@ -286,6 +320,7 @@ query GetIssueByIdentifierWithComments($teamKey: String!, $number: Float!) {
   issues(
     filter: { team: { key: { eq: $teamKey } }, number: { eq: $number } }
     first: 1
+    includeArchived: true
   ) {
     nodes {
       ...CompleteIssueWithCommentsFields
@@ -305,6 +340,7 @@ query GetIssueByIdentifierWithReactions($teamKey: String!, $number: Float!) {
   issues(
     filter: { team: { key: { eq: $teamKey } }, number: { eq: $number } }
     first: 1
+    includeArchived: true
   ) {
     nodes {
       ...CompleteIssueWithReactionsFields
@@ -332,13 +368,14 @@ query SearchIssues(
   $first: Int!
   $after: String
   $filter: IssueFilter
+  $includeArchived: Boolean = false
 ) {
   searchIssues(
     term: $term
     first: $first
     after: $after
     filter: $filter
-    includeArchived: false
+    includeArchived: $includeArchived
   ) {
     nodes {
       ...CompleteIssueSearchFields
@@ -352,20 +389,22 @@ query SearchIssues(
 
 # Search issues with advanced filters and all relationships in single query
 #
-# Supports filtering by team, assignee, project, and states.
-# Used by the advanced search functionality with multiple criteria.
+# Supports filtering by team, assignee, project, and states, and also backs the
+# unfiltered `issues list` — the implicit "hide completed" narrowing is built in
+# the service (buildListIssuesFilter) so that `--include-archived` can drop it.
 query FilteredSearchIssues(
   $first: Int!
   $after: String
   $filter: IssueFilter
   $orderBy: PaginationOrderBy
+  $includeArchived: Boolean = false
 ) {
   issues(
     first: $first
     after: $after
     filter: $filter
     orderBy: $orderBy
-    includeArchived: false
+    includeArchived: $includeArchived
   ) {
     nodes {
       ...CompleteIssueFields
@@ -858,10 +897,16 @@ query FindWorkflowStates($filter: WorkflowStateFilter, $first: Int = 1) {
 # ({ number: { eq }, team: { key: { eq } } }). team { id key } is selected so
 # the estimate-context resolver can derive the owning team without a second
 # round-trip.
+#
+# includeArchived is fixed to true: this query exists purely to turn a human
+# identifier into a UUID, and an archived issue still has one. Without it
+# `issues unarchive ENG-42` could never work, because the identifier could not
+# be resolved in the first place.
 query FindIssues($filter: IssueFilter, $first: Int = 1) {
-  issues(filter: $filter, first: $first) {
+  issues(filter: $filter, first: $first, includeArchived: true) {
     nodes {
       id
+      number
       team {
         id
         key
@@ -870,6 +915,16 @@ query FindIssues($filter: IssueFilter, $first: Int = 1) {
   }
 }
 
+# Find the issue a VCS branch belongs to
+#
+# Linear derives a branch name per issue (the `branchName` field), and this is
+# the reverse lookup. Returns null when the branch is not one of Linear's.
+query IssueVcsBranchSearch($branchName: String!) {
+  issueVcsBranchSearch(branchName: $branchName) {
+    ...CompleteIssueWithDefaultCommentsFields
+  }
+}
+
 # Complete issue fragment with attachments
 fragment CompleteIssueWithAttachmentsFields on Issue {
   ...CompleteIssueWithDefaultCommentsFields
@@ -892,6 +947,7 @@ query GetIssueByIdentifierWithAttachments($teamKey: String!, $number: Float!) {
   issues(
     filter: { team: { key: { eq: $teamKey } }, number: { eq: $number } }
     first: 1
+    includeArchived: true
   ) {
     nodes {
       ...CompleteIssueWithAttachmentsFields
diff --git a/graphql/queries/labels.graphql b/graphql/queries/labels.graphql
index 6c66ceca..843b614e 100644
--- a/graphql/queries/labels.graphql
+++ b/graphql/queries/labels.graphql
@@ -20,6 +20,14 @@ fragment LabelFields on IssueLabel {
   name
   color
   description
+  isGroup
+  # Retired labels stay on the entities that already carry them but cannot
+  # be applied to new ones, so a null here is what "usable" means.
+  retiredAt
+  parent {
+    id
+    name
+  }
 }
 
 fragment ProjectLabelFields on ProjectLabel {
@@ -27,6 +35,12 @@ fragment ProjectLabelFields on ProjectLabel {
   name
   color
   description
+  isGroup
+  retiredAt
+  parent {
+    id
+    name
+  }
 }
 
 query GetIssueLabel($id: String!) {
@@ -67,6 +81,12 @@ query GetLabels(
   }
 }
 
+query GetProjectLabel($id: String!) {
+  projectLabel(id: $id) {
+    ...ProjectLabelFields
+  }
+}
+
 query GetProjectLabels($first: Int = 50, $after: String) {
   projectLabels(first: $first, after: $after) {
     nodes {
diff --git a/graphql/queries/project-activity.graphql b/graphql/queries/project-activity.graphql
new file mode 100644
index 00000000..83751779
--- /dev/null
+++ b/graphql/queries/project-activity.graphql
@@ -0,0 +1,54 @@
+# ------------------------------------------------------------
+# GraphQL queries backing `projects activity`
+#
+# The project timeline merges three independent connections: project
+# history, discussion threads, and status updates. Linear exposes no
+# unified activity connection, so each is exhausted separately and the
+# service interleaves them.
+# ------------------------------------------------------------
+
+query GetProjectActivityRef($id: String!) {
+  project(id: $id) {
+    id
+    name
+  }
+}
+
+# A project's history events
+#
+# Unlike `IssueHistory`, which has ~40 typed from*/to* fields, every
+# `ProjectHistory` event body lives in one opaque `entries` JSONObject.
+# There is nothing to normalize into a typed change list, and no actor
+# field either — the shape a caller gets here is whatever Linear put in
+# `entries`.
+query ListProjectActivityHistory($id: String!, $first: Int, $after: String) {
+  project(id: $id) {
+    history(first: $first, after: $after) {
+      nodes {
+        id
+        createdAt
+        entries
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+}
+
+query ListProjectActivityUpdates($projectId: ID!, $first: Int, $after: String) {
+  projectUpdates(
+    first: $first
+    after: $after
+    filter: { project: { id: { eq: $projectId } } }
+  ) {
+    nodes {
+      ...ProjectUpdateCoreFields
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}
diff --git a/graphql/queries/project-milestones.graphql b/graphql/queries/project-milestones.graphql
index 24ed9a55..b144a0c5 100644
--- a/graphql/queries/project-milestones.graphql
+++ b/graphql/queries/project-milestones.graphql
@@ -74,7 +74,7 @@ query FindProjectMilestoneScoped($name: String!, $projectId: String!) {
   }
 }
 
-# Find project milestone by name globally (fallback)
+# Find project milestone by name globally
 #
 # Searches for a project milestone by name across all projects.
 query FindProjectMilestoneGlobal($name: String!) {
diff --git a/graphql/queries/project-relations.graphql b/graphql/queries/project-relations.graphql
new file mode 100644
index 00000000..9b66a924
--- /dev/null
+++ b/graphql/queries/project-relations.graphql
@@ -0,0 +1,89 @@
+# ------------------------------------------------------------
+# GraphQL queries for Linear project dependency relations
+#
+# A project relation links a point on one project to a point on
+# another: "this must finish before that starts". Both `type` and the
+# two anchor fields are plain `String!` in the schema with no enum, so
+# the accepted literals were read off a live workspace rather than
+# derived from the schema. See `src/services/project-relation-service.ts`.
+# ------------------------------------------------------------
+
+fragment ProjectRelationCoreFields on ProjectRelation {
+  id
+  type
+  anchorType
+  relatedAnchorType
+  createdAt
+  updatedAt
+  project {
+    id
+    name
+  }
+  projectMilestone {
+    id
+    name
+  }
+  relatedProject {
+    id
+    name
+  }
+  relatedProjectMilestone {
+    id
+    name
+  }
+}
+
+query GetProjectRelation($id: String!) {
+  projectRelation(id: $id) {
+    ...ProjectRelationCoreFields
+  }
+}
+
+# Every dependency in the workspace
+#
+# The root connection takes no filter argument, so it cannot be narrowed
+# to one project — that is what GetProjectRelations is for. This is the
+# whole-workspace view, and the only way to page dependencies without
+# already knowing which project to ask about.
+query ListAllProjectRelations($first: Int = 50, $after: String) {
+  projectRelations(first: $first, after: $after) {
+    nodes {
+      ...ProjectRelationCoreFields
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}
+
+# Both directions of a project's dependencies
+#
+# `relations` are the ones this project declares; `inverseRelations` are
+# the ones pointing at it. A caller asking "what does this depend on"
+# needs both, so they are fetched together and merged by the service.
+#
+# `$first` bounds each direction separately. Callers pass their own page size
+# so the number is stated once, next to the code that reports the truncation.
+query GetProjectRelations($projectId: String!, $first: Int = 100) {
+  project(id: $projectId) {
+    id
+    name
+    relations(first: $first) {
+      nodes {
+        ...ProjectRelationCoreFields
+      }
+      pageInfo {
+        hasNextPage
+      }
+    }
+    inverseRelations(first: $first) {
+      nodes {
+        ...ProjectRelationCoreFields
+      }
+      pageInfo {
+        hasNextPage
+      }
+    }
+  }
+}
diff --git a/graphql/queries/project-statuses.graphql b/graphql/queries/project-statuses.graphql
new file mode 100644
index 00000000..a7981d8d
--- /dev/null
+++ b/graphql/queries/project-statuses.graphql
@@ -0,0 +1,61 @@
+# ------------------------------------------------------------
+# GraphQL queries for the workspace project status flow
+#
+# Project statuses are workspace-scoped, not per-team: every project in
+# the workspace draws its status from this one ordered list.
+# ------------------------------------------------------------
+
+fragment ProjectStatusCoreFields on ProjectStatus {
+  id
+  name
+  description
+  color
+  type
+  position
+  indefinite
+  createdAt
+  updatedAt
+  archivedAt
+}
+
+# List the workspace's project statuses
+#
+# The connection takes no name filter, which is why
+# `resolveProjectStatusId()` matches names client-side.
+#
+# `first` overrides the API's default page of 50: archived statuses keep
+# accumulating, so `--include-archived` can pass 50 in a long-lived
+# workspace. pageInfo is selected so a caller that hits even the raised
+# bound learns the list is partial instead of reading it as complete.
+query ListProjectStatuses(
+  $includeArchived: Boolean = false
+  $first: Int = 250
+) {
+  projectStatuses(includeArchived: $includeArchived, first: $first) {
+    nodes {
+      ...ProjectStatusCoreFields
+    }
+    pageInfo {
+      hasNextPage
+    }
+  }
+}
+
+query GetProjectStatus($id: String!) {
+  projectStatus(id: $id) {
+    ...ProjectStatusCoreFields
+  }
+}
+
+# How many projects currently sit in a status
+#
+# Folded into `projects statuses read` rather than exposed as its own
+# verb: the count only means anything next to the status it describes,
+# and it is what tells you whether an archive will be refused.
+query GetProjectStatusProjectCount($id: String!) {
+  projectStatusProjectCount(id: $id) {
+    count
+    privateCount
+    archivedTeamCount
+  }
+}
diff --git a/graphql/queries/project-updates.graphql b/graphql/queries/project-updates.graphql
new file mode 100644
index 00000000..178e4ff7
--- /dev/null
+++ b/graphql/queries/project-updates.graphql
@@ -0,0 +1,60 @@
+# ------------------------------------------------------------
+# GraphQL queries for Linear project status updates
+#
+# A project update is a dated status post on a project: a markdown
+# body plus a health signal. It is a different entity from the
+# `projectUpdate` mutation, which edits the project itself.
+# ------------------------------------------------------------
+
+fragment ProjectUpdateCoreFields on ProjectUpdate {
+  id
+  body
+  health
+  isDiffHidden
+  isStale
+  url
+  createdAt
+  updatedAt
+  editedAt
+  archivedAt
+  project {
+    id
+    name
+  }
+  user {
+    id
+    name
+  }
+}
+
+# List the status updates posted on one project
+#
+# `projectUpdates` is workspace-wide, so the project is applied as a
+# filter rather than traversed from the project itself.
+query ListProjectUpdates(
+  $projectId: ID!
+  $first: Int = 50
+  $after: String
+  $includeArchived: Boolean = false
+) {
+  projectUpdates(
+    first: $first
+    after: $after
+    includeArchived: $includeArchived
+    filter: { project: { id: { eq: $projectId } } }
+  ) {
+    nodes {
+      ...ProjectUpdateCoreFields
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}
+
+query GetProjectUpdate($id: String!) {
+  projectUpdate(id: $id) {
+    ...ProjectUpdateCoreFields
+  }
+}
diff --git a/graphql/queries/projects.graphql b/graphql/queries/projects.graphql
index b8d9c310..14d8237f 100644
--- a/graphql/queries/projects.graphql
+++ b/graphql/queries/projects.graphql
@@ -110,6 +110,15 @@ fragment ProjectDetailFields on Project {
       hasNextPage
     }
   }
+  # The project's `health` is derived from its latest status update, so the
+  # read that reports the health also reports where it came from.
+  healthUpdatedAt
+  lastUpdate {
+    id
+    health
+    body
+    createdAt
+  }
 }
 
 fragment ProjectDetailWithDefaultConnectionsFields on Project {
@@ -214,41 +223,101 @@ query GetProjectWithReactions($id: String!, $first: Int, $after: String) {
   }
 }
 
-# List all project statuses in the workspace
+# The search fields, mirroring ProjectListFields
 #
-# Fetches project statuses for name-to-UUID resolution.
-# The API does not support filter args on this connection,
-# so all statuses are fetched and filtered client-side.
-query GetProjectStatuses {
-  projectStatuses {
+# `searchProjects` returns `ProjectSearchResult`, a sibling type of
+# `Project` rather than the thing itself, so the list fragment cannot be
+# reused. Two differences are real: `state` (deprecated on `Project`) does
+# not exist here, and `metadata` carries the search-ranking detail.
+fragment ProjectSearchFields on ProjectSearchResult {
+  id
+  name
+  description
+  status {
+    id
+    name
+    type
+  }
+  slugId
+  priority
+  priorityLabel
+  health
+  progress
+  startDate
+  targetDate
+  url
+  metadata
+  lead {
+    id
+    name
+  }
+  teams(first: 25) {
+    nodes {
+      id
+      key
+      name
+    }
+  }
+  labels(first: 25) {
     nodes {
       id
       name
+      color
     }
   }
 }
 
-# Get only a project's label IDs
+# Full-text search across projects
 #
-# Lean lookup used by `projects update --label-mode add|remove`, which
-# previously fetched the full project detail (milestones + issues) just
-# to read the current label set — an over-budget query on real
-# workspaces (#283).
+# Ranked by relevance rather than by `updatedAt`, so there is no orderBy
+# knob here — asking for one would silently discard the ranking that
+# makes the search worth running.
 #
-# 250 is Linear's per-connection maximum, so this read cannot be raised
-# further; hasNextPage lets the service refuse a truncated label set
-# instead of writing it back as if it were complete (labelIds is a
-# full-replacement input).
-query GetProjectLabelIds($id: String!) {
-  project(id: $id) {
-    id
-    labels(first: 250) {
-      nodes {
-        id
-      }
-      pageInfo {
-        hasNextPage
-      }
+# `searchProjects` is rate-limited more tightly than the plain
+# `projects` connection; use `projects list` when a filter would do.
+query SearchProjects(
+  $term: String!
+  $first: Int = 25
+  $after: String
+  $includeArchived: Boolean = false
+  $teamId: String
+) {
+  searchProjects(
+    term: $term
+    first: $first
+    after: $after
+    includeArchived: $includeArchived
+    teamId: $teamId
+  ) {
+    nodes {
+      ...ProjectSearchFields
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}
+
+# List all project statuses in the workspace
+#
+# Fetches project statuses for name-to-UUID resolution.
+# The API does not support filter args on this connection,
+# so all statuses are fetched and filtered client-side.
+# archivedAt is selected so that an ambiguity between an archived status
+# and a live one of the same name can be spelled out to the caller.
+# `first` raises the API's default page of 50, which archived statuses can
+# outgrow; pageInfo lets the resolver refuse rather than report a name it
+# simply did not fetch as missing.
+query GetProjectStatuses($includeArchived: Boolean = false, $first: Int = 250) {
+  projectStatuses(includeArchived: $includeArchived, first: $first) {
+    nodes {
+      id
+      name
+      archivedAt
+    }
+    pageInfo {
+      hasNextPage
     }
   }
 }
diff --git a/knip.json b/knip.json
index 39a1645f..1a4ae2e8 100644
--- a/knip.json
+++ b/knip.json
@@ -5,6 +5,6 @@
   "ignoreDependencies": [
     "@semantic-release/github",
     "@semantic-release/npm",
-    "@semantic-release/release-notes-generator"
+    "conventional-changelog-conventionalcommits"
   ]
 }
diff --git a/package-lock.json b/package-lock.json
index 0f0f3188..698c66db 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "linearis",
-  "version": "2026.7.0",
+  "version": "2026.8.0-next.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "linearis",
-      "version": "2026.7.0",
+      "version": "2026.8.0-next.2",
       "license": "MIT",
       "dependencies": {
         "commander": "15.0.0",
@@ -24,10 +24,10 @@
         "@graphql-codegen/cli": "^7.0.0",
         "@graphql-codegen/client-preset": "^6.0.0",
         "@graphql-typed-document-node/core": "3.2.0",
-        "@semantic-release/changelog": "^6.0.3",
+        "@semantic-release/changelog": "^7.0.0",
         "@semantic-release/commit-analyzer": "^13.0.1",
         "@semantic-release/exec": "^7.1.0",
-        "@semantic-release/git": "^10.0.1",
+        "@semantic-release/git": "^11.0.0",
         "@semantic-release/github": "^12.0.0",
         "@semantic-release/npm": "^13.0.0",
         "@semantic-release/release-notes-generator": "^14.1.0",
@@ -35,6 +35,7 @@
         "@vitest/coverage-v8": "^4.0.0",
         "@vitest/ui": "^4.0.0",
         "clean-publish": "^7.0.0",
+        "conventional-changelog-conventionalcommits": "9.3.1",
         "knip": "^6.24.0",
         "lefthook": "^2.1.0",
         "semantic-release": "^25.0.1",
@@ -424,9 +425,9 @@
       }
     },
     "node_modules/@biomejs/biome": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@biomejs/biome/-/biome-2.5.6.tgz",
-      "integrity": "sha512-lxVNjv7UF6KfhMJfL9gaUHbWdJdHbsAj6OSmwSYNdhRuG67NxNQ4Xdvh3TUxsSK9sBzJBQhEJj3AopmmNJ5pSA==",
+      "version": "2.5.7",
+      "resolved": "https://registry.npmjs.org/@biomejs/biome/-/biome-2.5.7.tgz",
+      "integrity": "sha512-zr8K/DcY5tYsQOQwqMJ0AWElo6QgmgNI7idXgXLhevVszlt8RGVpesEJPqx3ThazLaOwjJ5Y8fz3BtH5fGZNsw==",
       "dev": true,
       "license": "MIT OR Apache-2.0",
       "bin": {
@@ -440,20 +441,20 @@
         "url": "https://opencollective.com/biome"
       },
       "optionalDependencies": {
-        "@biomejs/cli-darwin-arm64": "2.5.6",
-        "@biomejs/cli-darwin-x64": "2.5.6",
-        "@biomejs/cli-linux-arm64": "2.5.6",
-        "@biomejs/cli-linux-arm64-musl": "2.5.6",
-        "@biomejs/cli-linux-x64": "2.5.6",
-        "@biomejs/cli-linux-x64-musl": "2.5.6",
-        "@biomejs/cli-win32-arm64": "2.5.6",
-        "@biomejs/cli-win32-x64": "2.5.6"
+        "@biomejs/cli-darwin-arm64": "2.5.7",
+        "@biomejs/cli-darwin-x64": "2.5.7",
+        "@biomejs/cli-linux-arm64": "2.5.7",
+        "@biomejs/cli-linux-arm64-musl": "2.5.7",
+        "@biomejs/cli-linux-x64": "2.5.7",
+        "@biomejs/cli-linux-x64-musl": "2.5.7",
+        "@biomejs/cli-win32-arm64": "2.5.7",
+        "@biomejs/cli-win32-x64": "2.5.7"
       }
     },
     "node_modules/@biomejs/cli-darwin-arm64": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@biomejs/cli-darwin-arm64/-/cli-darwin-arm64-2.5.6.tgz",
-      "integrity": "sha512-zMOLZP4oMrjh6m1zcSj1ud2awUPgTuMVbmQhYYWL7J8HwCnbHHBvTm7VBTRuY7epT5bez76IpKYQ11ZAqHFlnw==",
+      "version": "2.5.7",
+      "resolved": "https://registry.npmjs.org/@biomejs/cli-darwin-arm64/-/cli-darwin-arm64-2.5.7.tgz",
+      "integrity": "sha512-vxo/Ls3/PYdQWyLhYYcgMOCzQypAjcY+iihS8M0wW03l16TCLW4zqZzGo75gm1VdCMj38hTVZ31KBWrZ4G9dJw==",
       "cpu": [
         "arm64"
       ],
@@ -468,9 +469,9 @@
       }
     },
     "node_modules/@biomejs/cli-darwin-x64": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@biomejs/cli-darwin-x64/-/cli-darwin-x64-2.5.6.tgz",
-      "integrity": "sha512-JAC1VqzvO7Th5ZplU0G2uGfkZbxEe9uDDektPAhF0JLusoz1w+T4okp2bkykI0bbaO2vslKiRfj4gU43JaGreA==",
+      "version": "2.5.7",
+      "resolved": "https://registry.npmjs.org/@biomejs/cli-darwin-x64/-/cli-darwin-x64-2.5.7.tgz",
+      "integrity": "sha512-Cd3Ga61amT/Yl/0x8elP5hhGYaFy4bw6WuysTgf7oo8TA5tJ5A1k+DkVoJ2BHbTVil51gTX9VPzArnrlLJ3Kyg==",
       "cpu": [
         "x64"
       ],
@@ -485,9 +486,9 @@
       }
     },
     "node_modules/@biomejs/cli-linux-arm64": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@biomejs/cli-linux-arm64/-/cli-linux-arm64-2.5.6.tgz",
-      "integrity": "sha512-6XsYwCFkp5sMxl85ffhgeGpGgs6A7dRYFnkceZ7WVxvycuTnGdD5xa534Z3xfrBQ0JCMK/mujT6ZNPJoghedwg==",
+      "version": "2.5.7",
+      "resolved": "https://registry.npmjs.org/@biomejs/cli-linux-arm64/-/cli-linux-arm64-2.5.7.tgz",
+      "integrity": "sha512-rR2QE0yF2GYSuYuKIa7pKvODGJqnOH+2eDREAM8wV+mWKSkMQKdAp4zXEZfTaxY8PMoNONnpgSWcBCyLDPDOKg==",
       "cpu": [
         "arm64"
       ],
@@ -505,9 +506,9 @@
       }
     },
     "node_modules/@biomejs/cli-linux-arm64-musl": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@biomejs/cli-linux-arm64-musl/-/cli-linux-arm64-musl-2.5.6.tgz",
-      "integrity": "sha512-eUa3jeeYvfMt19LBeh6E5PUZpxnTC4JqNWo+EDjTtQjAr2xLGnWaxACtVU1DQqmHYbvThlJzLX+ZsYgrqh2qVw==",
+      "version": "2.5.7",
+      "resolved": "https://registry.npmjs.org/@biomejs/cli-linux-arm64-musl/-/cli-linux-arm64-musl-2.5.7.tgz",
+      "integrity": "sha512-xPI5yB6XlpDbNkS+bm1t42olw5c4l3UrlOmLg7KtLJvjvkNF/1V4tnUgfkylGIeb3u/T+BzMGYqgQhzjAoJzuQ==",
       "cpu": [
         "arm64"
       ],
@@ -525,9 +526,9 @@
       }
     },
     "node_modules/@biomejs/cli-linux-x64": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@biomejs/cli-linux-x64/-/cli-linux-x64-2.5.6.tgz",
-      "integrity": "sha512-Pop9VXCFUhFTMfFefZ39S+u2rOPyNp5iHlxbZRwXGACHLy2r0jjiRgJHmaEKJzL3SyxlVeGShXhvvElvWowonA==",
+      "version": "2.5.7",
+      "resolved": "https://registry.npmjs.org/@biomejs/cli-linux-x64/-/cli-linux-x64-2.5.7.tgz",
+      "integrity": "sha512-FQgqJhscrqJUFptGaRSUJWlXAExwWcDwLuK49dvKfkQ1bB5SEEyFssnsxQY83Xm6jR0EbbX3+8+D5bfvYqUG2Q==",
       "cpu": [
         "x64"
       ],
@@ -545,9 +546,9 @@
       }
     },
     "node_modules/@biomejs/cli-linux-x64-musl": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@biomejs/cli-linux-x64-musl/-/cli-linux-x64-musl-2.5.6.tgz",
-      "integrity": "sha512-2Vp13QdKysH3HIWLaYLhUUwbK+jbZonJD1K+Lr0d0RO4wH7mkYd43vJixEDm8cUWrowoRz4UUHF1nm9Ae7ym8A==",
+      "version": "2.5.7",
+      "resolved": "https://registry.npmjs.org/@biomejs/cli-linux-x64-musl/-/cli-linux-x64-musl-2.5.7.tgz",
+      "integrity": "sha512-rE5VZi+qtmPgQH+l7jVxYoZ18b/TiHEhulhMpjmCZH1PltSbjRcxNWywC3HZ9tYottG7ORkeTtoscBilKSBm0g==",
       "cpu": [
         "x64"
       ],
@@ -565,9 +566,9 @@
       }
     },
     "node_modules/@biomejs/cli-win32-arm64": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@biomejs/cli-win32-arm64/-/cli-win32-arm64-2.5.6.tgz",
-      "integrity": "sha512-tDGshcm6BdkZOCGnTDX0Y8/U4IfBSlnUU7T56nNDuPEfed+aHg+u8G36NB43fJVl0Os6+QURXIE1yuD7AaEofA==",
+      "version": "2.5.7",
+      "resolved": "https://registry.npmjs.org/@biomejs/cli-win32-arm64/-/cli-win32-arm64-2.5.7.tgz",
+      "integrity": "sha512-Oq4x0CCwP4jirrcTywXs5kOGZ4v5vuEP+gWrbtjApOA2CL9F3F9GlIdQIci8AKSCa/zURanMRpX/4wQ7Am6hHg==",
       "cpu": [
         "arm64"
       ],
@@ -582,9 +583,9 @@
       }
     },
     "node_modules/@biomejs/cli-win32-x64": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@biomejs/cli-win32-x64/-/cli-win32-x64-2.5.6.tgz",
-      "integrity": "sha512-WN05KwXnTO/2J45RQPvzZMXf7tZUIofHoR35xIPfCo7pQ2RFidxI8sfb5mGsaTxdMmEOzHzOPRCdA5/fCpc7xQ==",
+      "version": "2.5.7",
+      "resolved": "https://registry.npmjs.org/@biomejs/cli-win32-x64/-/cli-win32-x64-2.5.7.tgz",
+      "integrity": "sha512-V+0wu/nrj2S+MhP4EQ0uHNolP0IALEsz45pg0WoKkHfDeh0+ItHwP/p7bX5RPoMOl9NkpHYWdYPhIcy2mACHvQ==",
       "cpu": [
         "x64"
       ],
@@ -646,6 +647,19 @@
         "node": ">=22.12.0"
       }
     },
+    "node_modules/@commitlint/config-conventional/node_modules/conventional-changelog-conventionalcommits": {
+      "version": "10.2.1",
+      "resolved": "https://registry.npmjs.org/conventional-changelog-conventionalcommits/-/conventional-changelog-conventionalcommits-10.2.1.tgz",
+      "integrity": "sha512-n4Kr1HFMTf3iMbES0TMxKIcYtUUv4rKqyQQp2JwfOEfFCOfGT3Tq4mCyJ8S9/YPyWhydjfKrrvnyl+gCjA+mJQ==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "@conventional-changelog/template": "^1.2.1"
+      },
+      "engines": {
+        "node": ">=22"
+      }
+    },
     "node_modules/@commitlint/config-validator": {
       "version": "21.2.0",
       "resolved": "https://registry.npmjs.org/@commitlint/config-validator/-/config-validator-21.2.0.tgz",
@@ -1000,9 +1014,9 @@
       }
     },
     "node_modules/@conventional-changelog/template": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/@conventional-changelog/template/-/template-1.2.0.tgz",
-      "integrity": "sha512-12qHxvlKjHmP0PQ+17EREgC7lWyLwbph1RKcZQZ7k7ZWGmrxfxC9gadHGfvzr0g0u8BhiBGg3tks93txodlyRQ==",
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@conventional-changelog/template/-/template-1.2.1.tgz",
+      "integrity": "sha512-TzlTVpKPjaqW6qOYjQcYUDuGsLCNsvFHVBXkYGTAnf5V37jCWrE5haKNXzz0WZUtVHjrpV76L1buANjwXMfT8w==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -1630,9 +1644,9 @@
       }
     },
     "node_modules/@graphql-codegen/client-preset": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/@graphql-codegen/client-preset/-/client-preset-6.1.0.tgz",
-      "integrity": "sha512-mGmBuwrOU5oRoaWFodx8g9xu1jecYIiydqvk88QsAIsyMcZwuoybs1lyne85TovpBHjH5CC2wnZGsbDQfcgOCQ==",
+      "version": "6.1.1",
+      "resolved": "https://registry.npmjs.org/@graphql-codegen/client-preset/-/client-preset-6.1.1.tgz",
+      "integrity": "sha512-OpVkYpz6f7jAiVaOZZ3Mt5XTCRCdXgNSiMIfZfUCv8fUknqnd2IsD3VFCyjrkNi71J1PAwmwdJbkxDhdL23fjQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -1643,8 +1657,8 @@
         "@graphql-codegen/plugin-helpers": "^7.1.0",
         "@graphql-codegen/typed-document-node": "^7.1.0",
         "@graphql-codegen/typescript": "^6.1.0",
-        "@graphql-codegen/typescript-operations": "^6.1.0",
-        "@graphql-codegen/visitor-plugin-common": "^7.2.0",
+        "@graphql-codegen/typescript-operations": "^6.1.3",
+        "@graphql-codegen/visitor-plugin-common": "^7.2.3",
         "@graphql-tools/documents": "^1.0.0",
         "@graphql-tools/utils": "^11.2.0",
         "@graphql-typed-document-node/core": "3.2.0",
@@ -1781,15 +1795,15 @@
       }
     },
     "node_modules/@graphql-codegen/typescript-operations": {
-      "version": "6.1.2",
-      "resolved": "https://registry.npmjs.org/@graphql-codegen/typescript-operations/-/typescript-operations-6.1.2.tgz",
-      "integrity": "sha512-EP9xry09q4cOVaf/aC4NO3/SwvXRNzlJIe4dhfA0xyy45Taix5yDL3jeJpmJIv03sa7nK5udVs5vZqdHFU8Xmw==",
+      "version": "6.1.5",
+      "resolved": "https://registry.npmjs.org/@graphql-codegen/typescript-operations/-/typescript-operations-6.1.5.tgz",
+      "integrity": "sha512-ZiQ2CB6jiYYxFetdrutSsbNsiukh47UbVY9y3NjwWI8IUlslD+rDYN7MLDJrPFA5YXpv38ZBxh6q8PywRf1KfA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@graphql-codegen/plugin-helpers": "^7.1.0",
         "@graphql-codegen/schema-ast": "^6.1.0",
-        "@graphql-codegen/visitor-plugin-common": "^7.2.2",
+        "@graphql-codegen/visitor-plugin-common": "^7.2.3",
         "auto-bind": "^5.0.0",
         "tslib": "^2.8.0"
       },
@@ -1807,9 +1821,9 @@
       }
     },
     "node_modules/@graphql-codegen/visitor-plugin-common": {
-      "version": "7.2.2",
-      "resolved": "https://registry.npmjs.org/@graphql-codegen/visitor-plugin-common/-/visitor-plugin-common-7.2.2.tgz",
-      "integrity": "sha512-nOkAVd8J8r2YdHm9Z4YrBiy+3IQgE8Ndn/EiRWTvWuemMEhioBWyvdlnbq5rHmIo2bNdRQ5ghs0Q3jw7YBrwLQ==",
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/@graphql-codegen/visitor-plugin-common/-/visitor-plugin-common-7.2.3.tgz",
+      "integrity": "sha512-uP7lF8vAbOLefjrkLyz85dcDTfOkw0TV1xY+sFFvVK6cguTjWIokxxwWRgEeKaghWyOMvyFd6WXN4kqQxdVIiQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -3941,22 +3955,67 @@
       "license": "MIT"
     },
     "node_modules/@semantic-release/changelog": {
-      "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/@semantic-release/changelog/-/changelog-6.0.3.tgz",
-      "integrity": "sha512-dZuR5qByyfe3Y03TpmCvAxCyTnp7r5XwtHRf/8vD9EAn4ZWbavUX8adMtXYzE86EVh0gyLA7lm5yW4IV30XUag==",
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/@semantic-release/changelog/-/changelog-7.0.0.tgz",
+      "integrity": "sha512-TNPyag5db24o7jWjre7UwKB4EcL8oJxbRhnDQ7hmZRAYqzreAc6PgdxQuU3pppp5xQinYtiumL0iG8SSKvnlzg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@semantic-release/error": "^3.0.0",
-        "aggregate-error": "^3.0.0",
-        "fs-extra": "^11.0.0",
-        "lodash": "^4.17.4"
+        "@semantic-release/error": "^4.0.0",
+        "aggregate-error": "^5.0.0",
+        "lodash-es": "^4.17.21"
       },
       "engines": {
-        "node": ">=14.17"
+        "node": "^22.22.2 || >=24.15"
       },
       "peerDependencies": {
-        "semantic-release": ">=18.0.0"
+        "semantic-release": ">=20.1.0"
+      }
+    },
+    "node_modules/@semantic-release/changelog/node_modules/aggregate-error": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-5.0.0.tgz",
+      "integrity": "sha512-gOsf2YwSlleG6IjRYG2A7k0HmBMEo6qVNk9Bp/EaLgAJT5ngH6PXbqa4ItvnEwCm/velL5jAnQgsHsWnjhGmvw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "clean-stack": "^5.2.0",
+        "indent-string": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@semantic-release/changelog/node_modules/clean-stack": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-5.3.0.tgz",
+      "integrity": "sha512-9ngPTOhYGQqNVSfeJkYXHmF7AGWp4/nN5D/QqNQs3Dvxd1Kk/WpjHfNujKHYUQ/5CoGyOyFNoWSPk5afzP0QVg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "escape-string-regexp": "5.0.0"
+      },
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@semantic-release/changelog/node_modules/indent-string": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-5.0.0.tgz",
+      "integrity": "sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/@semantic-release/commit-analyzer": {
@@ -3983,13 +4042,13 @@
       }
     },
     "node_modules/@semantic-release/error": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/@semantic-release/error/-/error-3.0.0.tgz",
-      "integrity": "sha512-5hiM4Un+tpl4cKw3lV4UgzJj+SmfNIDCLLw0TepzQxz9ZGV5ixnqkzIVF+3tp0ZHgcMKE+VNGHJjEeyFG2dcSw==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@semantic-release/error/-/error-4.0.0.tgz",
+      "integrity": "sha512-mgdxrHTLOjOddRVYIYDo0fR3/v61GNN1YGkfbrjuIKg/uMgCd+Qzo3UAXJ+woLQQpos4pl5Esuw5A7AoNlzjUQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=14.17"
+        "node": ">=18"
       }
     },
     "node_modules/@semantic-release/exec": {
@@ -4013,16 +4072,6 @@
         "semantic-release": ">=24.1.0"
       }
     },
-    "node_modules/@semantic-release/exec/node_modules/@semantic-release/error": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@semantic-release/error/-/error-4.0.0.tgz",
-      "integrity": "sha512-mgdxrHTLOjOddRVYIYDo0fR3/v61GNN1YGkfbrjuIKg/uMgCd+Qzo3UAXJ+woLQQpos4pl5Esuw5A7AoNlzjUQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      }
-    },
     "node_modules/@semantic-release/exec/node_modules/execa": {
       "version": "9.6.1",
       "resolved": "https://registry.npmjs.org/execa/-/execa-9.6.1.tgz",
@@ -4067,46 +4116,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/@semantic-release/exec/node_modules/human-signals": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-8.0.1.tgz",
-      "integrity": "sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18.0"
-      }
-    },
-    "node_modules/@semantic-release/exec/node_modules/is-stream": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-4.0.1.tgz",
-      "integrity": "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/@semantic-release/exec/node_modules/npm-run-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-6.0.0.tgz",
-      "integrity": "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "path-key": "^4.0.0",
-        "unicorn-magic": "^0.3.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/@semantic-release/exec/node_modules/parse-json": {
       "version": "8.3.0",
       "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-8.3.0.tgz",
@@ -4125,25 +4134,39 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/@semantic-release/exec/node_modules/path-key": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
-      "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
+    "node_modules/@semantic-release/git": {
+      "version": "11.0.1",
+      "resolved": "https://registry.npmjs.org/@semantic-release/git/-/git-11.0.1.tgz",
+      "integrity": "sha512-Zr8BUYCTZMc8V6wDKN2dpR7nJgewd9I6THL3ydLTnp3OEdTo1/4RBLNYaeRucYMsjMv+BXoCNfXA0NADj1kwhw==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "@semantic-release/error": "^4.0.0",
+        "aggregate-error": "^5.0.0",
+        "debug": "^4.0.0",
+        "dir-glob": "^3.0.0",
+        "execa": "^10.0.0",
+        "lodash-es": "^4.17.21",
+        "micromatch": "^4.0.0",
+        "p-reduce": "^3.0.0"
+      },
       "engines": {
-        "node": ">=12"
+        "node": "^22.22.2 || >=24.15"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+      "peerDependencies": {
+        "semantic-release": ">=20.1.0"
       }
     },
-    "node_modules/@semantic-release/exec/node_modules/strip-final-newline": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-4.0.0.tgz",
-      "integrity": "sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==",
+    "node_modules/@semantic-release/git/node_modules/aggregate-error": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-5.0.0.tgz",
+      "integrity": "sha512-gOsf2YwSlleG6IjRYG2A7k0HmBMEo6qVNk9Bp/EaLgAJT5ngH6PXbqa4ItvnEwCm/velL5jAnQgsHsWnjhGmvw==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "clean-stack": "^5.2.0",
+        "indent-string": "^5.0.0"
+      },
       "engines": {
         "node": ">=18"
       },
@@ -4151,40 +4174,33 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/@semantic-release/exec/node_modules/unicorn-magic": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz",
-      "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==",
+    "node_modules/@semantic-release/git/node_modules/clean-stack": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-5.3.0.tgz",
+      "integrity": "sha512-9ngPTOhYGQqNVSfeJkYXHmF7AGWp4/nN5D/QqNQs3Dvxd1Kk/WpjHfNujKHYUQ/5CoGyOyFNoWSPk5afzP0QVg==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "escape-string-regexp": "5.0.0"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=14.16"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/@semantic-release/git": {
-      "version": "10.0.1",
-      "resolved": "https://registry.npmjs.org/@semantic-release/git/-/git-10.0.1.tgz",
-      "integrity": "sha512-eWrx5KguUcU2wUPaO6sfvZI0wPafUKAMNC18aXY4EnNcrZL86dEmpNVnC9uMpGZkmZJ9EfCVJBQx4pV4EMGT1w==",
+    "node_modules/@semantic-release/git/node_modules/indent-string": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-5.0.0.tgz",
+      "integrity": "sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@semantic-release/error": "^3.0.0",
-        "aggregate-error": "^3.0.0",
-        "debug": "^4.0.0",
-        "dir-glob": "^3.0.0",
-        "execa": "^5.0.0",
-        "lodash": "^4.17.4",
-        "micromatch": "^4.0.0",
-        "p-reduce": "^2.0.0"
-      },
       "engines": {
-        "node": ">=14.17"
+        "node": ">=12"
       },
-      "peerDependencies": {
-        "semantic-release": ">=18.0.0"
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/@semantic-release/github": {
@@ -4219,16 +4235,6 @@
         "semantic-release": ">=24.1.0"
       }
     },
-    "node_modules/@semantic-release/github/node_modules/@semantic-release/error": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@semantic-release/error/-/error-4.0.0.tgz",
-      "integrity": "sha512-mgdxrHTLOjOddRVYIYDo0fR3/v61GNN1YGkfbrjuIKg/uMgCd+Qzo3UAXJ+woLQQpos4pl5Esuw5A7AoNlzjUQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      }
-    },
     "node_modules/@semantic-release/github/node_modules/aggregate-error": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-5.0.0.tgz",
@@ -4305,16 +4311,6 @@
         "semantic-release": ">=20.1.0"
       }
     },
-    "node_modules/@semantic-release/npm/node_modules/@semantic-release/error": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@semantic-release/error/-/error-4.0.0.tgz",
-      "integrity": "sha512-mgdxrHTLOjOddRVYIYDo0fR3/v61GNN1YGkfbrjuIKg/uMgCd+Qzo3UAXJ+woLQQpos4pl5Esuw5A7AoNlzjUQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      }
-    },
     "node_modules/@semantic-release/npm/node_modules/aggregate-error": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-5.0.0.tgz",
@@ -4405,16 +4401,6 @@
         "node": "^20.17.0 || >=22.9.0"
       }
     },
-    "node_modules/@semantic-release/npm/node_modules/human-signals": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-8.0.1.tgz",
-      "integrity": "sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18.0"
-      }
-    },
     "node_modules/@semantic-release/npm/node_modules/indent-string": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-5.0.0.tgz",
@@ -4428,19 +4414,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/@semantic-release/npm/node_modules/is-stream": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-4.0.1.tgz",
-      "integrity": "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/@semantic-release/npm/node_modules/lru-cache": {
       "version": "11.3.5",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.3.5.tgz",
@@ -4466,23 +4439,6 @@
         "node": "^20.17.0 || >=22.9.0"
       }
     },
-    "node_modules/@semantic-release/npm/node_modules/npm-run-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-6.0.0.tgz",
-      "integrity": "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "path-key": "^4.0.0",
-        "unicorn-magic": "^0.3.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/@semantic-release/npm/node_modules/parse-json": {
       "version": "8.3.0",
       "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-8.3.0.tgz",
@@ -4501,19 +4457,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/@semantic-release/npm/node_modules/path-key": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
-      "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/@semantic-release/npm/node_modules/read-pkg": {
       "version": "10.1.0",
       "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-10.1.0.tgz",
@@ -4563,32 +4506,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/@semantic-release/npm/node_modules/strip-final-newline": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-4.0.0.tgz",
-      "integrity": "sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/@semantic-release/npm/node_modules/unicorn-magic": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz",
-      "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/@semantic-release/release-notes-generator": {
       "version": "14.1.1",
       "resolved": "https://registry.npmjs.org/@semantic-release/release-notes-generator/-/release-notes-generator-14.1.1.tgz",
@@ -6021,16 +5938,16 @@
       }
     },
     "node_modules/conventional-changelog-conventionalcommits": {
-      "version": "10.2.0",
-      "resolved": "https://registry.npmjs.org/conventional-changelog-conventionalcommits/-/conventional-changelog-conventionalcommits-10.2.0.tgz",
-      "integrity": "sha512-UtlM9GqolY7OmlQh5L/UEVoKsTUpTgUVy1PU8JN5gl5Ydaejb7WRklGliG1SKPxxj7hzA173eG3Kt5fYWE2pmg==",
+      "version": "9.3.1",
+      "resolved": "https://registry.npmjs.org/conventional-changelog-conventionalcommits/-/conventional-changelog-conventionalcommits-9.3.1.tgz",
+      "integrity": "sha512-dTYtpIacRpcZgrvBYvBfArMmK2xvIpv2TaxM0/ZI5CBtNUzvF2x0t15HsbRABWprS6UPmvj+PzHVjSx4qAVKyw==",
       "dev": true,
       "license": "ISC",
       "dependencies": {
-        "@conventional-changelog/template": "^1.2.0"
+        "compare-func": "^2.0.0"
       },
       "engines": {
-        "node": ">=22"
+        "node": ">=18"
       }
     },
     "node_modules/conventional-changelog-writer": {
@@ -6622,62 +6539,49 @@
       "license": "MIT"
     },
     "node_modules/execa": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz",
-      "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==",
+      "version": "10.0.1",
+      "resolved": "https://registry.npmjs.org/execa/-/execa-10.0.1.tgz",
+      "integrity": "sha512-ge98qjkRK4IB7tL7Ju/6qmm5LHoH1eEMt5FNZrz3f4UIYhF28lggX20z3FaX1sgc67msLEn0N0BscOs29iuwyw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "cross-spawn": "^7.0.3",
-        "get-stream": "^6.0.0",
-        "human-signals": "^2.1.0",
-        "is-stream": "^2.0.0",
-        "merge-stream": "^2.0.0",
-        "npm-run-path": "^4.0.1",
-        "onetime": "^5.1.2",
-        "signal-exit": "^3.0.3",
-        "strip-final-newline": "^2.0.0"
+        "@sindresorhus/merge-streams": "^4.0.0",
+        "figures": "^6.1.0",
+        "get-stream": "^9.0.1",
+        "human-signals": "^8.0.1",
+        "is-plain-obj": "^4.1.0",
+        "is-stream": "^4.0.1",
+        "npm-run-path": "^6.0.0",
+        "pretty-ms": "^9.3.0",
+        "signal-exit": "^4.1.0",
+        "strip-final-newline": "^4.0.0",
+        "which-command": "^0.1.0",
+        "yoctocolors": "^2.1.2"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=22"
       },
       "funding": {
         "url": "https://github.com/sindresorhus/execa?sponsor=1"
       }
     },
-    "node_modules/execa/node_modules/mimic-fn": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
-      "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/execa/node_modules/onetime": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz",
-      "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==",
+    "node_modules/execa/node_modules/get-stream": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-9.0.1.tgz",
+      "integrity": "sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "mimic-fn": "^2.1.0"
+        "@sec-ant/readable-stream": "^0.4.1",
+        "is-stream": "^4.0.1"
       },
       "engines": {
-        "node": ">=6"
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/execa/node_modules/signal-exit": {
-      "version": "3.0.7",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
-      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
-      "dev": true,
-      "license": "ISC"
-    },
     "node_modules/expect-type": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
@@ -7040,9 +6944,9 @@
       }
     },
     "node_modules/get-tsconfig": {
-      "version": "4.14.0",
-      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.14.0.tgz",
-      "integrity": "sha512-yTb+8DXzDREzgvYmh6s9vHsSVCHeC0G3PI5bEXNBHtmshPnO+S5O7qgLEOn0I5QvMy6kpZN8K1NKGyilLb93wA==",
+      "version": "4.14.1",
+      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.14.1.tgz",
+      "integrity": "sha512-Dz/6HxkrxgNehhxLVeyv8sad9UzF2xBVeaKBQNDfJ5XiSXmp2gTR0eO0RWiT2NCKS5aGP9jjkOMggTN90qU50A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -7380,13 +7284,13 @@
       }
     },
     "node_modules/human-signals": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz",
-      "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==",
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-8.0.1.tgz",
+      "integrity": "sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==",
       "dev": true,
       "license": "Apache-2.0",
       "engines": {
-        "node": ">=10.17.0"
+        "node": ">=18.18.0"
       }
     },
     "node_modules/iconv-lite": {
@@ -7639,13 +7543,13 @@
       }
     },
     "node_modules/is-stream": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
-      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-4.0.1.tgz",
+      "integrity": "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=8"
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
@@ -7905,9 +7809,9 @@
       }
     },
     "node_modules/knip": {
-      "version": "6.31.0",
-      "resolved": "https://registry.npmjs.org/knip/-/knip-6.31.0.tgz",
-      "integrity": "sha512-NbeIEmUS2VUMjAkbiSNOKPJeV9wpCsr0660sUyKyMQbk4Iom0++nTLInVp4MJ+LfR4kORnw67bDi5tvO7YLnzA==",
+      "version": "6.32.0",
+      "resolved": "https://registry.npmjs.org/knip/-/knip-6.32.0.tgz",
+      "integrity": "sha512-KDX9OmmOFmlvmxTkrx6Z0GHISMut+pXMSKR8eg84bovaxJKx2NdQD4JYCXveSbvieRe107W6vCD2xCpmz0qBYA==",
       "dev": true,
       "funding": [
         {
@@ -7923,7 +7827,7 @@
       "dependencies": {
         "fdir": "^6.5.0",
         "formatly": "^0.3.0",
-        "get-tsconfig": "4.14.0",
+        "get-tsconfig": "4.14.1",
         "jiti": "^2.7.0",
         "oxc-parser": "^0.142.0",
         "oxc-resolver": "11.24.2",
@@ -8508,13 +8412,6 @@
         "node": ">=4"
       }
     },
-    "node_modules/lodash": {
-      "version": "4.18.1",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
-      "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/lodash-es": {
       "version": "4.18.1",
       "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.18.1.tgz",
@@ -9217,16 +9114,46 @@
       }
     },
     "node_modules/npm-run-path": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz",
-      "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==",
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-6.0.0.tgz",
+      "integrity": "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "path-key": "^3.0.0"
+        "path-key": "^4.0.0",
+        "unicorn-magic": "^0.3.0"
       },
       "engines": {
-        "node": ">=8"
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/npm-run-path/node_modules/path-key": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
+      "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/npm-run-path/node_modules/unicorn-magic": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz",
+      "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/npm/node_modules/@gar/promise-retry": {
@@ -11188,13 +11115,16 @@
       }
     },
     "node_modules/p-reduce": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/p-reduce/-/p-reduce-2.1.0.tgz",
-      "integrity": "sha512-2USApvnsutq8uoxZBGbbWM0JIYLiEMJ9RlaN7fAzVNb9OZN0SHjjTTfIcb667XynS5Y1VhwDJVDa72TnPzAYWw==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/p-reduce/-/p-reduce-3.0.0.tgz",
+      "integrity": "sha512-xsrIUgI0Kn6iyDYm9StOpOeK29XM1aboGji26+QEortiFST1hGZaUQOLhtEbqHErPpGW/aSz6allwK2qcptp0Q==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/p-timeout": {
@@ -11785,9 +11715,9 @@
       "license": "MIT"
     },
     "node_modules/semantic-release": {
-      "version": "25.0.8",
-      "resolved": "https://registry.npmjs.org/semantic-release/-/semantic-release-25.0.8.tgz",
-      "integrity": "sha512-w/iZ0bur36rKffXZYmIUmy068eoBY3Ij1DCCddx2JwWEM5Tg+eU9ld/E9qSInVvPASyyR2Ln/XGfQ9OZrMlhtw==",
+      "version": "25.0.9",
+      "resolved": "https://registry.npmjs.org/semantic-release/-/semantic-release-25.0.9.tgz",
+      "integrity": "sha512-bxve7csK0/Txr++CkfrmV+X1r4jqiSOw2WsSad9E2S68R+ZfLBwDn8IceM8WfiOmKQIHgsQc1cNA8Dzg7U75pg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -11827,16 +11757,6 @@
         "node": "^22.14.0 || >= 24.10.0"
       }
     },
-    "node_modules/semantic-release/node_modules/@semantic-release/error": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@semantic-release/error/-/error-4.0.0.tgz",
-      "integrity": "sha512-mgdxrHTLOjOddRVYIYDo0fR3/v61GNN1YGkfbrjuIKg/uMgCd+Qzo3UAXJ+woLQQpos4pl5Esuw5A7AoNlzjUQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      }
-    },
     "node_modules/semantic-release/node_modules/aggregate-error": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-5.0.0.tgz",
@@ -11927,16 +11847,6 @@
         "node": "^20.17.0 || >=22.9.0"
       }
     },
-    "node_modules/semantic-release/node_modules/human-signals": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-8.0.1.tgz",
-      "integrity": "sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18.0"
-      }
-    },
     "node_modules/semantic-release/node_modules/indent-string": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-5.0.0.tgz",
@@ -11950,19 +11860,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/semantic-release/node_modules/is-stream": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-4.0.1.tgz",
-      "integrity": "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/semantic-release/node_modules/lru-cache": {
       "version": "11.5.2",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.2.tgz",
@@ -11988,36 +11885,6 @@
         "node": "^20.17.0 || >=22.9.0"
       }
     },
-    "node_modules/semantic-release/node_modules/npm-run-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-6.0.0.tgz",
-      "integrity": "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "path-key": "^4.0.0",
-        "unicorn-magic": "^0.3.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/semantic-release/node_modules/p-reduce": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/p-reduce/-/p-reduce-3.0.0.tgz",
-      "integrity": "sha512-xsrIUgI0Kn6iyDYm9StOpOeK29XM1aboGji26+QEortiFST1hGZaUQOLhtEbqHErPpGW/aSz6allwK2qcptp0Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/semantic-release/node_modules/parse-json": {
       "version": "8.3.0",
       "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-8.3.0.tgz",
@@ -12049,19 +11916,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/semantic-release/node_modules/path-key": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
-      "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/semantic-release/node_modules/read-package-up": {
       "version": "12.0.0",
       "resolved": "https://registry.npmjs.org/read-package-up/-/read-package-up-12.0.0.tgz",
@@ -12113,19 +11967,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/semantic-release/node_modules/strip-final-newline": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-4.0.0.tgz",
-      "integrity": "sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/semantic-release/node_modules/type-fest": {
       "version": "5.8.0",
       "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-5.8.0.tgz",
@@ -12142,19 +11983,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/semantic-release/node_modules/unicorn-magic": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz",
-      "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/semver": {
       "version": "7.7.3",
       "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
@@ -12613,13 +12441,16 @@
       }
     },
     "node_modules/strip-final-newline": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz",
-      "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-4.0.0.tgz",
+      "integrity": "sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=6"
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/strip-json-comments": {
@@ -12958,9 +12789,9 @@
       "license": "0BSD"
     },
     "node_modules/tsx": {
-      "version": "4.23.5",
-      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.23.5.tgz",
-      "integrity": "sha512-rw55FUaqOoI7RvlQwLbhO4nSDApnQ4/CykPuiQ/EPvtrX3WA9Ig55jIt9VvbBJbzJuj12ueRu4PMZ2SxPVbihg==",
+      "version": "4.23.10",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.23.10.tgz",
+      "integrity": "sha512-0Vb9eKU47njkxv/6B8CRZRDsxNDT/Pz+BIU+M5jw7xL3TdzAjSxlZUxu0xFL/kLpaG3sHZ0LH2wbK1T1yo7CUQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -13440,6 +13271,22 @@
         "node": ">= 8"
       }
     },
+    "node_modules/which-command": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/which-command/-/which-command-0.1.0.tgz",
+      "integrity": "sha512-XZyoF5/5hZtXitIwzrU4NKK+Wtbb9aB9CezUEw2Q0wlYK8NUYQxC1rRXgNueYLtBAJwXIb+/tFVk4dozciNJMA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "which-command": "cli.js"
+      },
+      "engines": {
+        "node": ">=22"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/which-command?sponsor=1"
+      }
+    },
     "node_modules/why-is-node-running": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
diff --git a/package.json b/package.json
index aaacb287..df56cafd 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "linearis",
-  "version": "2026.7.0",
+  "version": "2026.8.0-next.2",
   "description": "CLI tool for Linear.app with JSON output, smart ID resolution, and optimized GraphQL queries. Designed for LLM agents and humans who prefer structured data.",
   "main": "dist/main.js",
   "type": "module",
@@ -10,6 +10,7 @@
   },
   "files": [
     "dist/",
+    "schemas/",
     "README.md",
     "LICENSE.md",
     "USAGE.md"
@@ -35,6 +36,7 @@
     "check:ci": "biome check .",
     "knip": "knip --no-config-hints",
     "knip:ci": "knip --no-config-hints --reporter markdown",
+    "count:root-fields": "node scripts/count-root-fields.mjs",
     "verify:packed-binaries": "node scripts/verify-packed-binaries.mjs",
     "release": "npm test && npm run build && npm run verify:packed-binaries && rm -rf .clean-pkg && npx clean-publish --without-publish --temp-dir .clean-pkg && npm publish ./.clean-pkg --access public && rm -rf .clean-pkg",
     "prestart": "npm run generate",
@@ -81,10 +83,10 @@
     "@graphql-codegen/cli": "^7.0.0",
     "@graphql-codegen/client-preset": "^6.0.0",
     "@graphql-typed-document-node/core": "3.2.0",
-    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/changelog": "^7.0.0",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/exec": "^7.1.0",
-    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/git": "^11.0.0",
     "@semantic-release/github": "^12.0.0",
     "@semantic-release/npm": "^13.0.0",
     "@semantic-release/release-notes-generator": "^14.1.0",
@@ -92,6 +94,7 @@
     "@vitest/coverage-v8": "^4.0.0",
     "@vitest/ui": "^4.0.0",
     "clean-publish": "^7.0.0",
+    "conventional-changelog-conventionalcommits": "9.3.1",
     "knip": "^6.24.0",
     "lefthook": "^2.1.0",
     "semantic-release": "^25.0.1",
diff --git a/renovate.json b/renovate.json
index f2f81624..06ee019b 100644
--- a/renovate.json
+++ b/renovate.json
@@ -22,6 +22,11 @@
       "matchUpdateTypes": ["minor", "patch"],
       "groupName": "dev dependencies (non-major)"
     },
+    {
+      "description": "Hold conventional-changelog-conventionalcommits on the 9.x line: v10 moved to the @conventional-changelog/writer@2 API (function template/commitPartial), which @semantic-release/release-notes-generator's Handlebars writer@8 cannot render. The result is silently empty release notes, not a build failure. Lift once release-notes-generator ships writer@2 support.",
+      "matchPackageNames": ["conventional-changelog-conventionalcommits"],
+      "allowedVersions": "<10"
+    },
     {
       "description": "Group GitHub Actions updates (SHA-pinned actions + docker digests)",
       "matchManagers": ["github-actions"],
diff --git a/schemas/issues-batch-create.schema.json b/schemas/issues-batch-create.schema.json
new file mode 100644
index 00000000..1b3230e3
--- /dev/null
+++ b/schemas/issues-batch-create.schema.json
@@ -0,0 +1,127 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/linearis-oss/linearis/next/schemas/issues-batch-create.schema.json",
+  "title": "linearis issues batch create document",
+  "description": "Input document for `linearis issues batch create --file <path>` (or `--json <json>`). A JSON array of issues to create in a single transaction. The keys mirror the `issues create` flags with the leading dashes dropped; unknown keys are rejected rather than ignored.",
+  "type": "array",
+  "minItems": 1,
+  "items": { "$ref": "#/$defs/entry" },
+  "$defs": {
+    "nonEmptyString": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "\\S"
+    },
+    "entry": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["title", "team"],
+      "dependentRequired": {
+        "projectMilestone": ["project"]
+      },
+      "properties": {
+        "title": {
+          "$ref": "#/$defs/nonEmptyString",
+          "description": "Issue title."
+        },
+        "team": {
+          "$ref": "#/$defs/nonEmptyString",
+          "description": "Team key (ENG), team name, or team UUID. Every entry names its own team."
+        },
+        "description": {
+          "$ref": "#/$defs/nonEmptyString",
+          "description": "Issue description in Markdown."
+        },
+        "assignee": {
+          "$ref": "#/$defs/nonEmptyString",
+          "description": "Assignee as display name, email, UUID, or `me`."
+        },
+        "priority": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 4,
+          "description": "1=urgent, 2=high, 3=medium, 4=low. Omit for no priority."
+        },
+        "estimate": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Estimate points. Validated against the team's estimation scale (fibonacci, exponential, linear, or t-shirt sizes), so the accepted values depend on the team."
+        },
+        "project": {
+          "$ref": "#/$defs/nonEmptyString",
+          "description": "Project name or UUID."
+        },
+        "projectMilestone": {
+          "$ref": "#/$defs/nonEmptyString",
+          "description": "Milestone name or UUID. Milestones are scoped by project, so `project` must be set as well."
+        },
+        "cycle": {
+          "$ref": "#/$defs/nonEmptyString",
+          "description": "Cycle number, name, `current`/`next`/`previous`, or UUID."
+        },
+        "status": {
+          "$ref": "#/$defs/nonEmptyString",
+          "description": "Workflow state name (Todo, In Progress, ...) or UUID, resolved within the entry's team."
+        },
+        "parentTicket": {
+          "$ref": "#/$defs/nonEmptyString",
+          "description": "Parent issue as identifier (ABC-123) or UUID."
+        },
+        "labels": {
+          "description": "Label names or UUIDs, either as an array or as a comma-separated string.",
+          "oneOf": [
+            {
+              "type": "array",
+              "minItems": 1,
+              "items": { "$ref": "#/$defs/nonEmptyString" }
+            },
+            { "$ref": "#/$defs/nonEmptyString" }
+          ]
+        },
+        "subscribers": {
+          "description": "Users to subscribe on creation, each a display name, email, UUID, or `me`. Either an array or a comma-separated string.",
+          "oneOf": [
+            {
+              "type": "array",
+              "minItems": 1,
+              "items": { "$ref": "#/$defs/nonEmptyString" }
+            },
+            { "$ref": "#/$defs/nonEmptyString" }
+          ]
+        },
+        "delegate": {
+          "$ref": "#/$defs/nonEmptyString",
+          "description": "Delegate as display name, email, UUID, or `me`. A delegate acts for the assignee."
+        },
+        "dueDate": {
+          "type": "string",
+          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+          "description": "Due date as YYYY-MM-DD. The date must exist in the calendar."
+        }
+      }
+    }
+  },
+  "examples": [
+    [
+      {
+        "title": "Fix login redirect loop",
+        "team": "ENG",
+        "description": "Users bounce between /login and /dashboard after SSO.",
+        "assignee": "alice",
+        "priority": 1,
+        "labels": ["bug", "auth"],
+        "dueDate": "2026-09-01"
+      },
+      {
+        "title": "Document the SSO flow",
+        "team": "ENG",
+        "project": "Q3 Auth",
+        "projectMilestone": "Beta",
+        "status": "Todo",
+        "estimate": 2,
+        "subscribers": ["bob", "carol@example.com"],
+        "delegate": "me"
+      }
+    ]
+  ]
+}
diff --git a/schemas/issues-batch-update.schema.json b/schemas/issues-batch-update.schema.json
new file mode 100644
index 00000000..7943c004
--- /dev/null
+++ b/schemas/issues-batch-update.schema.json
@@ -0,0 +1,123 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/linearis-oss/linearis/next/schemas/issues-batch-update.schema.json",
+  "title": "linearis issues batch update document",
+  "description": "Input document for `linearis issues batch update --file <path>` (or `--json <json>`). One patch applied to an explicit list of issues in a single transaction. The patch keys mirror the `issues update` flags with the leading dashes dropped; `null` clears a field, the way the `--clear-*` flags do. Unknown keys are rejected rather than ignored.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["issues", "patch"],
+  "properties": {
+    "issues": {
+      "description": "Issues to patch, each an identifier (ABC-123) or UUID. Either an array or a comma-separated string.",
+      "$ref": "#/$defs/stringList"
+    },
+    "patch": { "$ref": "#/$defs/patch" }
+  },
+  "$defs": {
+    "nonEmptyString": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "\\S"
+    },
+    "stringList": {
+      "oneOf": [
+        {
+          "type": "array",
+          "minItems": 1,
+          "items": { "$ref": "#/$defs/nonEmptyString" }
+        },
+        { "$ref": "#/$defs/nonEmptyString" }
+      ]
+    },
+    "nullableString": {
+      "oneOf": [{ "$ref": "#/$defs/nonEmptyString" }, { "type": "null" }]
+    },
+    "patch": {
+      "description": "The fields to change. Every listed issue receives this same patch, so a status, cycle or label named by word requires all targets to share one team — pass a UUID otherwise.",
+      "type": "object",
+      "additionalProperties": false,
+      "minProperties": 1,
+      "dependentSchemas": {
+        "projectMilestone": {
+          "anyOf": [
+            { "properties": { "projectMilestone": { "type": "null" } } },
+            {
+              "required": ["project"],
+              "properties": { "project": { "type": "string" } }
+            }
+          ]
+        }
+      },
+      "properties": {
+        "title": {
+          "$ref": "#/$defs/nonEmptyString",
+          "description": "New title for every listed issue."
+        },
+        "description": {
+          "$ref": "#/$defs/nonEmptyString",
+          "description": "New description in Markdown, replacing the current one."
+        },
+        "status": {
+          "$ref": "#/$defs/nonEmptyString",
+          "description": "Workflow state name (Todo, In Progress, ...) or UUID. A name resolves within the targets' single team."
+        },
+        "priority": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 4,
+          "description": "1=urgent, 2=high, 3=medium, 4=low."
+        },
+        "estimate": {
+          "oneOf": [{ "type": "integer", "minimum": 0 }, { "type": "null" }],
+          "description": "Estimate points, or null to clear. Validated against the estimation scale of every team the batch spans, so the accepted values depend on those teams."
+        },
+        "assignee": {
+          "$ref": "#/$defs/nullableString",
+          "description": "Assignee as display name, email, UUID, or `me`. Null unassigns."
+        },
+        "project": {
+          "$ref": "#/$defs/nullableString",
+          "description": "Project name or UUID. Null removes the issues from their project, and their project milestone with it."
+        },
+        "labels": {
+          "description": "Label names or UUIDs, either as an array or as a comma-separated string. Overwrites the current labels; null removes them all. Named labels may be team-scoped, so they require all targets to share one team.",
+          "oneOf": [{ "$ref": "#/$defs/stringList" }, { "type": "null" }]
+        },
+        "parentTicket": {
+          "$ref": "#/$defs/nullableString",
+          "description": "Parent issue as identifier (ABC-123) or UUID. Null detaches from the parent."
+        },
+        "projectMilestone": {
+          "$ref": "#/$defs/nullableString",
+          "description": "Milestone name or UUID. Milestones are scoped by project, so setting one requires `project` as well. Null detaches from the milestone."
+        },
+        "cycle": {
+          "$ref": "#/$defs/nullableString",
+          "description": "Cycle number, name, `current`/`next`/`previous`, or UUID. Null removes the issues from their cycle."
+        },
+        "dueDate": {
+          "oneOf": [
+            {
+              "type": "string",
+              "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
+            },
+            { "type": "null" }
+          ],
+          "description": "Due date as YYYY-MM-DD, or null to clear. The date must exist in the calendar."
+        }
+      }
+    }
+  },
+  "examples": [
+    {
+      "issues": ["ENG-42", "ENG-43", "ENG-44"],
+      "patch": {
+        "status": "In Progress",
+        "assignee": "alice",
+        "priority": 2,
+        "cycle": "current",
+        "dueDate": null
+      }
+    }
+  ]
+}
diff --git a/scripts/count-root-fields.mjs b/scripts/count-root-fields.mjs
new file mode 100644
index 00000000..60102b91
--- /dev/null
+++ b/scripts/count-root-fields.mjs
@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+/**
+ * Counts the Linear root fields this CLI wires.
+ *
+ * The README's coverage section quotes a number ("wires N of them"). Before
+ * this script that number was asserted by hand and drifted — it read 83 while
+ * the documents held 81. Run this and paste the result rather than guessing.
+ *
+ * A "wired root field" is a top-level selection inside an operation in
+ * `graphql/{queries,mutations}/*.graphql`. Fragments are skipped; a field
+ * selected in several operations counts once. Note that a handful of names —
+ * `projectUpdate`, for one — exist as both a query and a mutation, so the
+ * operation count `--verify` reports is slightly higher than the name count.
+ *
+ *   node scripts/count-root-fields.mjs            # the count and the list
+ *   node scripts/count-root-fields.mjs --json     # machine-readable
+ *   node scripts/count-root-fields.mjs --verify   # also check against the live
+ *                                                 # schema (needs network; the
+ *                                                 # endpoint allows anonymous
+ *                                                 # introspection)
+ *
+ * `--verify` reports the API-wide totals the README also quotes, and flags any
+ * name that is not actually a root field — which would mean this parser has
+ * mistaken a nested selection for one.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const graphqlRoot = path.join(repoRoot, "graphql");
+
+/** Strip comments and string literals so braces and names parse cleanly. */
+function stripNoise(source) {
+  return source
+    .replace(/"""[\s\S]*?"""/g, " ")
+    .replace(/"(?:[^"\\]|\\.)*"/g, '""')
+    .replace(/#[^\n]*/g, "");
+}
+
+/**
+ * Extract the top-level selections of every operation in one document.
+ *
+ * Walks brace depth rather than using a GraphQL parser so the script stays
+ * dependency-free: names at depth 1 inside an operation body are root fields.
+ */
+function rootFieldsIn(source) {
+  const text = stripNoise(source);
+  const found = new Set();
+  const operation = /\b(query|mutation)\b[^{]*\{/g;
+
+  let match = operation.exec(text);
+  while (match !== null) {
+    let depth = 1;
+    let index = match.index + match[0].length;
+    let expectFieldName = true;
+
+    while (index < text.length && depth > 0) {
+      const char = text[index];
+
+      if (char === "{") {
+        depth += 1;
+        expectFieldName = false;
+        index += 1;
+        continue;
+      }
+
+      if (char === "}") {
+        depth -= 1;
+        expectFieldName = depth === 1;
+        index += 1;
+        continue;
+      }
+
+      if (char === "(") {
+        // Skip the argument list wholesale; nothing in it is a root field.
+        let parens = 1;
+        index += 1;
+        while (index < text.length && parens > 0) {
+          if (text[index] === "(") parens += 1;
+          if (text[index] === ")") parens -= 1;
+          index += 1;
+        }
+        expectFieldName = false;
+        continue;
+      }
+
+      const name = /^[A-Za-z_][A-Za-z0-9_]*/.exec(text.slice(index));
+      if (name) {
+        if (depth === 1 && expectFieldName) {
+          // `alias: field` — the name before the colon is the caller's label,
+          // not a root field. Leave expectFieldName set so the real one lands.
+          const isAlias = /^\s*:/.test(text.slice(index + name[0].length));
+          if (!isAlias) {
+            found.add(name[0]);
+            expectFieldName = false;
+          }
+        }
+        index += name[0].length;
+        continue;
+      }
+
+      if (char === "\n" || char === ",") {
+        // A newline or comma at depth 1 ends one selection and starts the next.
+        if (depth === 1) expectFieldName = true;
+      } else if (char === ":") {
+        // An alias: the name after the colon is the real field.
+        if (depth === 1) expectFieldName = true;
+      }
+
+      index += 1;
+    }
+
+    operation.lastIndex = index;
+    match = operation.exec(text);
+  }
+
+  return found;
+}
+
+const documents = ["queries", "mutations"].flatMap((kind) => {
+  const dir = path.join(graphqlRoot, kind);
+  return fs
+    .readdirSync(dir)
+    .filter((file) => file.endsWith(".graphql"))
+    .map((file) => path.join(dir, file));
+});
+
+const byField = new Map();
+for (const file of documents) {
+  const relative = path.relative(repoRoot, file);
+  for (const field of rootFieldsIn(fs.readFileSync(file, "utf8"))) {
+    const sources = byField.get(field) ?? [];
+    sources.push(relative);
+    byField.set(field, sources);
+  }
+}
+
+const fields = [...byField.keys()].sort();
+
+const ENDPOINT = "https://api.linear.app/graphql";
+
+async function introspectRootFields() {
+  const response = await fetch(ENDPOINT, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      query:
+        'query { q: __type(name: "Query") { fields { name } } m: __type(name: "Mutation") { fields { name } } }',
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`introspection failed: HTTP ${response.status}`);
+  }
+
+  const { data, errors } = await response.json();
+  if (errors) {
+    throw new Error(`introspection failed: ${JSON.stringify(errors)}`);
+  }
+
+  return {
+    queries: data.q.fields.map((field) => field.name),
+    mutations: data.m.fields.map((field) => field.name),
+  };
+}
+
+const verify = process.argv.includes("--verify");
+const schema = verify ? await introspectRootFields() : null;
+
+let report = null;
+if (schema) {
+  const wired = new Set(fields);
+  const queries = schema.queries.filter((name) => wired.has(name));
+  const mutations = schema.mutations.filter((name) => wired.has(name));
+  const known = new Set([...schema.queries, ...schema.mutations]);
+
+  report = {
+    wired: queries.length + mutations.length,
+    queries: { wired: queries.length, total: schema.queries.length },
+    mutations: { wired: mutations.length, total: schema.mutations.length },
+    total: schema.queries.length + schema.mutations.length,
+    // A name like `projectUpdate` is both a query and a mutation, so the
+    // operation count exceeds the count of distinct names.
+    sharedNames: queries.filter((name) => mutations.includes(name)),
+    notRootFields: fields.filter((name) => !known.has(name)),
+  };
+}
+
+if (process.argv.includes("--json")) {
+  console.log(
+    JSON.stringify(
+      { count: fields.length, fields, ...(report && { report }) },
+      null,
+      2,
+    ),
+  );
+} else {
+  for (const field of fields) {
+    console.log(field);
+  }
+  console.log(`\n${fields.length} distinct root field names wired`);
+
+  if (report) {
+    console.log(
+      `${report.wired} of ${report.total} root operations ` +
+        `(${report.queries.wired}/${report.queries.total} queries, ` +
+        `${report.mutations.wired}/${report.mutations.total} mutations)`,
+    );
+
+    if (report.wired !== fields.length) {
+      console.log(
+        `${report.wired - fields.length} more operations than names: ` +
+          "some names exist as both a query and a mutation " +
+          `(${report.sharedNames.join(", ")})`,
+      );
+    }
+
+    if (report.notRootFields.length > 0) {
+      console.log(
+        `\nnot root fields — this parser is wrong about: ${report.notRootFields.join(", ")}`,
+      );
+      process.exitCode = 1;
+    }
+  }
+}
diff --git a/src/commands/attachments.ts b/src/commands/attachments.ts
index 14c9ab2e..81b87147 100644
--- a/src/commands/attachments.ts
+++ b/src/commands/attachments.ts
@@ -10,6 +10,7 @@ import {
   type CreateAttachmentInput,
   createAttachment,
   deleteAttachment,
+  disableExternalSync,
   listAttachments,
 } from "../services/attachment-service.js";
 
@@ -22,12 +23,14 @@ export const ATTACHMENTS_META: DomainMeta = {
     "title, subtitle, sourceType (e.g. 'github', 'slack'), and metadata",
     "with integration-specific data. creating an attachment with the same",
     "url on the same issue updates the existing record (idempotent).",
+    "attachments created by an integration can keep the issue in sync with",
+    "the external resource; `disable-sync` stops that for one attachment.",
   ].join("\n"),
   arguments: {
     issue: "issue identifier (UUID or ABC-123)",
     id: "attachment UUID",
   },
-  seeAlso: ["issues read --with-attachments"],
+  seeAlso: ["issues read --with-attachments", "attachments disable-sync <id>"],
 };
 
 interface ListOptions {
@@ -142,6 +145,22 @@ export function setupAttachmentsCommands(program: Command): void {
       }),
     );
 
+  attachments
+    .command("disable-sync <id>")
+    .description("stop syncing the issue with an attachment's external source")
+    .addHelpText(
+      "after",
+      "\nKeyed by attachment, not by issue: an issue can carry several synced attachments and they are disabled one at a time.",
+    )
+    .action(
+      handleCommand(async (...args: unknown[]) => {
+        const [id, , command] = args as [string, unknown, Command];
+        const ctx = createContext(getRootOpts(command));
+        const result = await disableExternalSync(ctx.gql, asUuid(id));
+        outputSuccess(result);
+      }),
+    );
+
   attachments
     .command("usage")
     .description("show detailed usage for attachments")
diff --git a/src/commands/initiatives/updates.ts b/src/commands/initiatives/updates.ts
index 96d16504..76c81e18 100644
--- a/src/commands/initiatives/updates.ts
+++ b/src/commands/initiatives/updates.ts
@@ -1,5 +1,6 @@
 import type { Command } from "commander";
 import { createContext, getRootOpts } from "../../common/context.js";
+import { parseHealth } from "../../common/domain-values.js";
 import { invalidParameterError } from "../../common/errors.js";
 import { asUuid } from "../../common/identifier.js";
 import {
@@ -15,7 +16,6 @@ import {
   createInitiativeUpdate,
   getInitiativeUpdate,
   listInitiativeUpdates,
-  parseHealth,
   type UpdateInitiativeUpdateInput,
   unarchiveInitiativeUpdate,
   updateInitiativeUpdate,
diff --git a/src/commands/issues-batch.ts b/src/commands/issues-batch.ts
new file mode 100644
index 00000000..a7c853a2
--- /dev/null
+++ b/src/commands/issues-batch.ts
@@ -0,0 +1,1122 @@
+import { readFileSync } from "node:fs";
+import type { Command } from "commander";
+import type { GraphQLClient } from "../client/graphql-client.js";
+import { createContext, getRootOpts } from "../common/context.js";
+import {
+  invalidParameterError,
+  requiresParameterError,
+} from "../common/errors.js";
+import { validateEstimateAgainstTeamConfig } from "../common/estimate-validation.js";
+import { isUuid, parseDueDate, type UUID } from "../common/identifier.js";
+import { parseCommaSeparated } from "../common/issue-filter.js";
+import {
+  parseEstimateOption,
+  parsePriorityOption,
+} from "../common/number-options.js";
+import { commandAction, outputSuccess } from "../common/output.js";
+import {
+  type ResolveCreateIssueIdsInput,
+  type ResolvedCreateIssueIds,
+  type ResolveUpdateIssueIdsInput,
+  resolveBatchCreateIssueIds,
+  resolveUpdateIssueIds,
+  type UpdateIssueContext,
+} from "../resolvers/issue-mutation-resolver.js";
+import {
+  type ResolvedIssueRef,
+  resolveIssueRefs,
+} from "../resolvers/issue-resolver.js";
+import { resolveTeamEstimateContext } from "../resolvers/team-resolver.js";
+import {
+  batchCreateIssues,
+  batchUpdateIssues,
+  type CreateIssueInput,
+  type UpdateIssueInput,
+} from "../services/issue-service.js";
+
+/**
+ * `issues batch create` / `issues batch update`.
+ *
+ * Kept beside `issues.ts` rather than inside it: the batch subgroup carries its
+ * own input format (a JSON document rather than flags) and its own
+ * single-team constraint, and `issues.ts` is already the largest command file
+ * in the project.
+ */
+
+/**
+ * One entry of a `batch create` document.
+ *
+ * The keys are deliberately the single-issue flag names with the leading
+ * dashes dropped, so a caller who knows `issues create` already knows this
+ * format and there is no second schema to learn.
+ */
+interface BatchCreateEntry {
+  title: string;
+  team: string;
+  description?: string;
+  assignee?: string;
+  priority?: number;
+  estimate?: number;
+  project?: string;
+  labels?: string[];
+  projectMilestone?: string;
+  cycle?: string;
+  status?: string;
+  parentTicket?: string;
+  dueDate?: string;
+  subscribers?: string[];
+  delegate?: string;
+}
+
+/** The two ways every batch command takes its JSON document. */
+interface DocumentOptions {
+  file?: string;
+  json?: string;
+}
+
+type BatchCreateOptions = DocumentOptions;
+
+interface BatchUpdateOptions extends DocumentOptions {
+  issues?: string;
+  title?: string;
+  description?: string;
+  status?: string;
+  priority?: string;
+  estimate?: string;
+  clearEstimate?: boolean;
+  assignee?: string;
+  clearAssignee?: boolean;
+  project?: string;
+  clearProject?: boolean;
+  labels?: string;
+  clearLabels?: boolean;
+  parentTicket?: string;
+  clearParentTicket?: boolean;
+  projectMilestone?: string;
+  clearProjectMilestone?: boolean;
+  cycle?: string;
+  clearCycle?: boolean;
+  dueDate?: string;
+  clearDueDate?: boolean;
+}
+
+/**
+ * A `batch update` patch in normalised form, shared by both input paths.
+ *
+ * `undefined` leaves a field alone and `null` clears it — the distinction the
+ * flags draw with their `--clear-*` pairs and the document draws with a JSON
+ * `null`. Both forms are normalised into this one shape so the guard rails
+ * below (team scoping, estimate validation, the built mutation input) have a
+ * single thing to reason about.
+ */
+export interface BatchUpdatePatch {
+  title?: string;
+  description?: string;
+  status?: string;
+  priority?: number;
+  estimate?: number | null;
+  assignee?: string | null;
+  project?: string | null;
+  labels?: string[] | null;
+  parentTicket?: string | null;
+  projectMilestone?: string | null;
+  cycle?: string | null;
+  dueDate?: string | null;
+}
+
+/** A parsed `batch update` request: the targets and the one patch they share. */
+interface BatchUpdateRequest {
+  issues: string[];
+  patch: BatchUpdatePatch;
+}
+
+/**
+ * Where the published copies of the batch schemas live.
+ *
+ * Pinned to the raw files on the default branch rather than a tag: a schema
+ * tracks the parser below, and a caller validating against it wants the
+ * contract of the CLI they will actually run, not the one at release time.
+ */
+const SCHEMA_BASE_URL =
+  "https://raw.githubusercontent.com/linearis-oss/linearis/next/schemas";
+const BATCH_CREATE_SCHEMA_URL = `${SCHEMA_BASE_URL}/issues-batch-create.schema.json`;
+const BATCH_UPDATE_SCHEMA_URL = `${SCHEMA_BASE_URL}/issues-batch-update.schema.json`;
+
+/**
+ * Exported so the schema drift test can assert that
+ * `schemas/issues-batch-create.schema.json` still describes exactly the keys
+ * this parser accepts — the schema is what callers write against, so the two
+ * silently diverging is worse than either being wrong on its own.
+ */
+export const KNOWN_ENTRY_KEYS: ReadonlySet<string> = new Set([
+  "title",
+  "team",
+  "description",
+  "assignee",
+  "priority",
+  "estimate",
+  "project",
+  "labels",
+  "projectMilestone",
+  "cycle",
+  "status",
+  "parentTicket",
+  "dueDate",
+  "subscribers",
+  "delegate",
+]);
+
+/**
+ * Keys a `batch update` patch may carry, mirroring the update flags.
+ *
+ * Exported for the same reason as {@link KNOWN_ENTRY_KEYS}: the schema drift
+ * test asserts that `schemas/issues-batch-update.schema.json` describes exactly
+ * this set.
+ */
+export const KNOWN_PATCH_KEYS: ReadonlySet<string> = new Set([
+  "title",
+  "description",
+  "status",
+  "priority",
+  "estimate",
+  "assignee",
+  "project",
+  "labels",
+  "parentTicket",
+  "projectMilestone",
+  "cycle",
+  "dueDate",
+]);
+
+/**
+ * Patch keys that accept `null` to clear the field.
+ *
+ * These are exactly the fields with a `--clear-*` flag. `title`, `description`,
+ * `status` and `priority` have none, because Linear has no empty state for them
+ * that a batch could sensibly write.
+ */
+export const CLEARABLE_PATCH_KEYS: ReadonlySet<string> = new Set([
+  "estimate",
+  "assignee",
+  "project",
+  "labels",
+  "parentTicket",
+  "projectMilestone",
+  "cycle",
+  "dueDate",
+]);
+
+/** Reads the batch document from `--json`, a file, or stdin via `--file -`. */
+function readBatchDocument(options: DocumentOptions): string {
+  if (options.json !== undefined && options.file !== undefined) {
+    throw invalidParameterError("--json", "cannot be combined with --file");
+  }
+
+  if (options.json !== undefined) {
+    return options.json;
+  }
+
+  if (options.file === undefined) {
+    throw invalidParameterError("--file", "is required (use - for stdin)");
+  }
+
+  return readFileSync(options.file === "-" ? 0 : options.file, "utf8");
+}
+
+/**
+ * Parses and validates the batch document.
+ *
+ * Validation is strict about unknown keys: a typo like `assingee` would
+ * otherwise create the whole batch with the field silently dropped, and a
+ * partially-wrong batch of issues is far more annoying to unpick than a
+ * rejected command.
+ */
+export function parseBatchCreateEntries(document: string): BatchCreateEntry[] {
+  let parsed: unknown;
+
+  try {
+    parsed = JSON.parse(document);
+  } catch (error) {
+    throw invalidParameterError(
+      "batch document",
+      `is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+
+  if (!Array.isArray(parsed)) {
+    throw invalidParameterError(
+      "batch document",
+      "must be a JSON array of issue objects",
+    );
+  }
+
+  if (parsed.length === 0) {
+    throw invalidParameterError("batch document", "must not be empty");
+  }
+
+  return parsed.map((entry, index) => parseBatchCreateEntry(entry, index));
+}
+
+function parseBatchCreateEntry(
+  entry: unknown,
+  index: number,
+): BatchCreateEntry {
+  const at = `batch document entry ${index}`;
+
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    throw invalidParameterError(at, "must be an object");
+  }
+
+  const record = entry as Record<string, unknown>;
+
+  for (const key of Object.keys(record)) {
+    if (!KNOWN_ENTRY_KEYS.has(key)) {
+      throw invalidParameterError(
+        at,
+        `has unknown key "${key}" (expected one of: ${[...KNOWN_ENTRY_KEYS].join(", ")})`,
+      );
+    }
+  }
+
+  const parsedEntry: BatchCreateEntry = {
+    title: requireString(record, "title", at),
+    team: requireString(record, "team", at),
+  };
+
+  for (const key of [
+    "description",
+    "assignee",
+    "project",
+    "projectMilestone",
+    "cycle",
+    "status",
+    "parentTicket",
+    "delegate",
+  ] as const) {
+    const value = optionalString(record, key, at);
+    if (value !== undefined) parsedEntry[key] = value;
+  }
+
+  const priority = optionalInteger(record, "priority", at, 1, 4);
+  if (priority !== undefined) parsedEntry.priority = priority;
+
+  const estimate = optionalInteger(
+    record,
+    "estimate",
+    at,
+    0,
+    Number.MAX_SAFE_INTEGER,
+  );
+  if (estimate !== undefined) parsedEntry.estimate = estimate;
+
+  const dueDate = optionalString(record, "dueDate", at);
+  if (dueDate !== undefined) parsedEntry.dueDate = parseDueDate(dueDate);
+
+  if (record["labels"] !== undefined) {
+    parsedEntry.labels = parseStringList(record["labels"], "labels", at);
+  }
+
+  if (record["subscribers"] !== undefined) {
+    parsedEntry.subscribers = parseStringList(
+      record["subscribers"],
+      "subscribers",
+      at,
+    );
+  }
+
+  if (
+    parsedEntry.projectMilestone !== undefined &&
+    parsedEntry.project === undefined
+  ) {
+    throw invalidParameterError(at, "has projectMilestone without project");
+  }
+
+  return parsedEntry;
+}
+
+function requireString(
+  record: Record<string, unknown>,
+  key: string,
+  at: string,
+): string {
+  const value = record[key];
+
+  if (typeof value !== "string" || value.trim() === "") {
+    throw invalidParameterError(at, `requires a non-empty string "${key}"`);
+  }
+
+  return value;
+}
+
+function optionalString(
+  record: Record<string, unknown>,
+  key: string,
+  at: string,
+): string | undefined {
+  const value = record[key];
+
+  if (value === undefined) return undefined;
+  if (typeof value !== "string" || value.trim() === "") {
+    throw invalidParameterError(at, `has a non-string or empty "${key}"`);
+  }
+
+  return value;
+}
+
+function optionalInteger(
+  record: Record<string, unknown>,
+  key: string,
+  at: string,
+  min: number,
+  max: number,
+): number | undefined {
+  const value = record[key];
+
+  if (value === undefined) return undefined;
+  if (
+    typeof value !== "number" ||
+    !Number.isInteger(value) ||
+    value < min ||
+    value > max
+  ) {
+    throw invalidParameterError(
+      at,
+      `has "${key}" outside the allowed range (integer ${min}-${max})`,
+    );
+  }
+
+  return value;
+}
+
+/** Accepts both a JSON array and the comma-separated form the flags take. */
+function parseStringList(value: unknown, key: string, at: string): string[] {
+  if (typeof value === "string") {
+    // parseCommaSeparated speaks in flags, not documents: on `"a,,b"` it would
+    // report a bare "comma-separated list", leaving the caller to guess which
+    // of a hundred entries it came from. Restate it with the same locator the
+    // array branch uses.
+    try {
+      return parseCommaSeparated(value);
+    } catch {
+      throw invalidParameterError(
+        at,
+        `has "${key}" with empty segments in its comma-separated value`,
+      );
+    }
+  }
+
+  if (
+    !Array.isArray(value) ||
+    value.length === 0 ||
+    !value.every((item) => typeof item === "string" && item.trim() !== "")
+  ) {
+    throw invalidParameterError(
+      at,
+      `has "${key}" that is not a non-empty array of strings`,
+    );
+  }
+
+  return value;
+}
+
+/** As {@link optionalString}, but `null` survives as the "clear it" marker. */
+function nullableString(
+  record: Record<string, unknown>,
+  key: string,
+  at: string,
+): string | null | undefined {
+  return record[key] === null ? null : optionalString(record, key, at);
+}
+
+/** As {@link optionalInteger}, but `null` survives as the "clear it" marker. */
+function nullableInteger(
+  record: Record<string, unknown>,
+  key: string,
+  at: string,
+  min: number,
+  max: number,
+): number | null | undefined {
+  return record[key] === null
+    ? null
+    : optionalInteger(record, key, at, min, max);
+}
+
+/**
+ * Parses a `batch update` document: the issues to patch, and the single patch
+ * every one of them receives.
+ *
+ * The shape is `{"issues": [...], "patch": {...}}` rather than a per-issue
+ * array, because that is what the underlying mutation can actually do — one
+ * patch, one transaction. An array of per-issue patches would have to fan out
+ * into N mutations and lose the all-or-nothing guarantee that is the reason to
+ * batch in the first place.
+ *
+ * Unknown keys are rejected here just as they are in `batch create`: a typo
+ * that silently skipped a field would leave a half-applied mass edit to unpick.
+ */
+export function parseBatchUpdateDocument(document: string): BatchUpdateRequest {
+  let parsed: unknown;
+
+  try {
+    parsed = JSON.parse(document);
+  } catch (error) {
+    throw invalidParameterError(
+      "batch document",
+      `is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw invalidParameterError(
+      "batch document",
+      'must be a JSON object with "issues" and "patch"',
+    );
+  }
+
+  const record = parsed as Record<string, unknown>;
+
+  for (const key of Object.keys(record)) {
+    if (key !== "issues" && key !== "patch") {
+      throw invalidParameterError(
+        "batch document",
+        `has unknown key "${key}" (expected one of: issues, patch)`,
+      );
+    }
+  }
+
+  if (record["issues"] === undefined) {
+    throw invalidParameterError("batch document", 'requires "issues"');
+  }
+
+  const patch = record["patch"];
+
+  if (typeof patch !== "object" || patch === null || Array.isArray(patch)) {
+    throw invalidParameterError(
+      "batch document",
+      'requires "patch" as an object of fields to change',
+    );
+  }
+
+  return {
+    issues: parseStringList(record["issues"], "issues", "batch document"),
+    patch: parseBatchUpdatePatch(patch as Record<string, unknown>),
+  };
+}
+
+function parseBatchUpdatePatch(
+  record: Record<string, unknown>,
+): BatchUpdatePatch {
+  const at = "batch document patch";
+  const keys = Object.keys(record);
+
+  if (keys.length === 0) {
+    throw invalidParameterError(at, "needs at least one field to change");
+  }
+
+  for (const key of keys) {
+    if (!KNOWN_PATCH_KEYS.has(key)) {
+      throw invalidParameterError(
+        at,
+        `has unknown key "${key}" (expected one of: ${[...KNOWN_PATCH_KEYS].join(", ")})`,
+      );
+    }
+
+    if (record[key] === null && !CLEARABLE_PATCH_KEYS.has(key)) {
+      throw invalidParameterError(at, `cannot clear "${key}" with null`);
+    }
+  }
+
+  const patch: BatchUpdatePatch = {};
+
+  for (const key of ["title", "description", "status"] as const) {
+    const value = optionalString(record, key, at);
+    if (value !== undefined) patch[key] = value;
+  }
+
+  for (const key of [
+    "assignee",
+    "project",
+    "parentTicket",
+    "projectMilestone",
+    "cycle",
+  ] as const) {
+    const value = nullableString(record, key, at);
+    if (value !== undefined) patch[key] = value;
+  }
+
+  const priority = optionalInteger(record, "priority", at, 1, 4);
+  if (priority !== undefined) patch.priority = priority;
+
+  const estimate = nullableInteger(
+    record,
+    "estimate",
+    at,
+    0,
+    Number.MAX_SAFE_INTEGER,
+  );
+  if (estimate !== undefined) patch.estimate = estimate;
+
+  const dueDate = nullableString(record, "dueDate", at);
+  if (dueDate !== undefined) {
+    patch.dueDate = dueDate === null ? null : parseDueDate(dueDate);
+  }
+
+  if (record["labels"] !== undefined) {
+    patch.labels =
+      record["labels"] === null
+        ? null
+        : parseStringList(record["labels"], "labels", at);
+  }
+
+  // Milestones are scoped by project, and a batch has no single "current"
+  // project to fall back on the way a single-issue update does.
+  if (
+    typeof patch.projectMilestone === "string" &&
+    typeof patch.project !== "string"
+  ) {
+    throw invalidParameterError(at, "has projectMilestone without project");
+  }
+
+  return patch;
+}
+
+function toResolverInput(entry: BatchCreateEntry): ResolveCreateIssueIdsInput {
+  const input: ResolveCreateIssueIdsInput = {
+    team: entry.team,
+    withEstimateContext: entry.estimate !== undefined,
+  };
+
+  if (entry.assignee !== undefined) input.assignee = entry.assignee;
+  if (entry.project !== undefined) input.project = entry.project;
+  if (entry.labels !== undefined) input.labels = entry.labels;
+  if (entry.projectMilestone !== undefined) {
+    input.projectMilestone = entry.projectMilestone;
+  }
+  if (entry.cycle !== undefined) input.cycle = entry.cycle;
+  if (entry.status !== undefined) input.status = entry.status;
+  if (entry.parentTicket !== undefined) input.parentTicket = entry.parentTicket;
+  if (entry.subscribers !== undefined) input.subscribers = entry.subscribers;
+  if (entry.delegate !== undefined) input.delegate = entry.delegate;
+
+  return input;
+}
+
+function toCreateInput(
+  entry: BatchCreateEntry,
+  ids: ResolvedCreateIssueIds,
+): CreateIssueInput {
+  const input: CreateIssueInput = { title: entry.title, teamId: ids.teamId };
+
+  if (entry.description !== undefined) input.description = entry.description;
+  if (entry.priority !== undefined) input.priority = entry.priority;
+  if (entry.estimate !== undefined) input.estimate = entry.estimate;
+  if (entry.dueDate !== undefined) input.dueDate = entry.dueDate;
+  if (ids.assigneeId) input.assigneeId = ids.assigneeId;
+  if (ids.projectId) input.projectId = ids.projectId;
+  if (ids.labelIds) input.labelIds = ids.labelIds;
+  if (ids.projectMilestoneId) input.projectMilestoneId = ids.projectMilestoneId;
+  if (ids.cycleId) input.cycleId = ids.cycleId;
+  if (ids.stateId) input.stateId = ids.stateId;
+  if (ids.parentId) input.parentId = ids.parentId;
+  if (ids.subscriberIds) input.subscriberIds = ids.subscriberIds;
+  if (ids.delegateId) input.delegateId = ids.delegateId;
+
+  return input;
+}
+
+/**
+ * Derives the lookup scope for a batch patch from the targets themselves.
+ *
+ * `issueBatchUpdate` applies one `stateId`/`cycleId`/`labelIds` to every
+ * target, so a status, cycle or label named by word is only meaningful when all
+ * targets live in the same team. Rejecting the mixed-team case is better than
+ * resolving against an arbitrary one of them and moving four issues into a
+ * fifth team's workflow state.
+ *
+ * Labels are in that set because Linear labels may be team-scoped: two teams
+ * can each own a "bug", the name lookup matches both, and the first hit wins —
+ * so half the batch would silently get the other team's label.
+ *
+ * A UUID needs no team to resolve against, so it is the documented escape
+ * hatch and must pass the guard — `resolveUpdateIssueIds` hands UUIDs straight
+ * through without consulting the scope. `--labels` is checked entry by entry,
+ * since it takes a list that may mix UUIDs and names.
+ *
+ * Exported so that escape hatch can be tested without driving a full command.
+ */
+export function buildBatchUpdateContext(
+  targets: readonly ResolvedIssueRef[],
+  patch: BatchUpdatePatch,
+): UpdateIssueContext {
+  const teamKeys = [...new Set(targets.map((target) => target.teamKey))];
+  const [onlyTarget] = targets;
+
+  if (teamKeys.length > 1) {
+    const crossTeam = (field: string): never => {
+      throw invalidParameterError(
+        field,
+        `cannot be resolved by name across teams ${teamKeys.join(", ")} — pass a UUID, or split the batch per team`,
+      );
+    };
+
+    for (const field of ["status", "cycle"] as const) {
+      const value = patch[field];
+      if (typeof value === "string" && !isUuid(value)) crossTeam(field);
+    }
+
+    if (
+      Array.isArray(patch.labels) &&
+      patch.labels.some((label) => !isUuid(label))
+    ) {
+      crossTeam("labels");
+    }
+
+    return {};
+  }
+
+  return onlyTarget
+    ? { teamId: onlyTarget.teamId, teamKey: onlyTarget.teamKey }
+    : {};
+}
+
+/**
+ * Validates `--estimate` against the estimation scale of every team the batch
+ * touches.
+ *
+ * `issues update` and `batch create` both reject an off-scale estimate before
+ * sending anything; without this, `batch update` was the one path that let
+ * `--estimate 7` reach a fibonacci team and come back as a raw API error.
+ *
+ * Every distinct team is checked, not just the single-team case: one patch
+ * applies the same estimate to all targets, so it has to be valid on each of
+ * their scales. That is one extra lookup per distinct team, and a batch
+ * spanning teams is already the rare shape.
+ *
+ * Exported so the validation can be tested without driving a full command.
+ */
+export async function validateBatchUpdateEstimate(
+  client: GraphQLClient,
+  targets: readonly ResolvedIssueRef[],
+  patch: BatchUpdatePatch,
+): Promise<void> {
+  const estimate = patch.estimate;
+
+  if (typeof estimate !== "number") return;
+
+  const teamIds = [...new Set(targets.map((target) => target.teamId))];
+  const teams = await Promise.all(
+    teamIds.map((teamId) => resolveTeamEstimateContext(client, teamId)),
+  );
+
+  for (const team of teams) {
+    validateEstimateAgainstTeamConfig(estimate, {
+      teamKey: team.teamKey,
+      issueEstimationType: team.issueEstimationType,
+      issueEstimationExtended: team.issueEstimationExtended,
+      issueEstimationAllowZero: team.issueEstimationAllowZero,
+    });
+  }
+}
+
+function buildBatchUpdateResolverInput(
+  patch: BatchUpdatePatch,
+): ResolveUpdateIssueIdsInput {
+  const input: ResolveUpdateIssueIdsInput = {};
+
+  for (const key of [
+    "assignee",
+    "project",
+    "projectMilestone",
+    "cycle",
+    "status",
+    "parentTicket",
+  ] as const) {
+    const value = patch[key];
+    if (typeof value === "string") input[key] = value;
+  }
+
+  if (Array.isArray(patch.labels)) input.labels = patch.labels;
+
+  return input;
+}
+
+/**
+ * The update flags, minus the two that select the document form.
+ *
+ * Kept as a list so mixing a document with flags can be refused by name: a
+ * silently ignored `--status` on a document run would apply a different patch
+ * than the caller wrote, to every issue at once.
+ */
+const BATCH_UPDATE_FLAG_KEYS = [
+  "issues",
+  "title",
+  "description",
+  "status",
+  "priority",
+  "estimate",
+  "clearEstimate",
+  "assignee",
+  "clearAssignee",
+  "project",
+  "clearProject",
+  "labels",
+  "clearLabels",
+  "parentTicket",
+  "clearParentTicket",
+  "projectMilestone",
+  "clearProjectMilestone",
+  "cycle",
+  "clearCycle",
+  "dueDate",
+  "clearDueDate",
+] as const satisfies ReadonlyArray<keyof BatchUpdateOptions>;
+
+/** Picks the input path — a JSON document, or the flags — and parses it. */
+function readBatchUpdateRequest(
+  options: BatchUpdateOptions,
+): BatchUpdateRequest {
+  if (options.file === undefined && options.json === undefined) {
+    if (options.issues === undefined) {
+      throw invalidParameterError(
+        "--issues",
+        "is required (or pass a document with --file/--json)",
+      );
+    }
+
+    return {
+      issues: parseCommaSeparated(options.issues),
+      patch: patchFromFlags(options),
+    };
+  }
+
+  const used = BATCH_UPDATE_FLAG_KEYS.filter(
+    (key) => options[key] !== undefined,
+  );
+
+  if (used.length > 0) {
+    throw invalidParameterError(
+      used.map((key) => `--${toFlagName(key)}`).join(", "),
+      "cannot be combined with a JSON document — put the field in the document instead",
+    );
+  }
+
+  return parseBatchUpdateDocument(readBatchDocument(options));
+}
+
+function toFlagName(key: string): string {
+  return key.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+
+/**
+ * Normalises the update flags into a {@link BatchUpdatePatch}.
+ *
+ * The `--clear-*` flags collapse into a `null` here, which is also what the
+ * document form writes — past this point nothing needs to know which of the two
+ * input paths the patch came from.
+ */
+function patchFromFlags(options: BatchUpdateOptions): BatchUpdatePatch {
+  validateBatchUpdateOptions(options);
+
+  const patch: BatchUpdatePatch = {};
+
+  if (options.title) patch.title = options.title;
+  if (options.description) patch.description = options.description;
+  if (options.status) patch.status = options.status;
+  if (options.priority !== undefined) {
+    patch.priority = parsePriorityOption(options.priority);
+  }
+
+  if (options.clearEstimate) {
+    patch.estimate = null;
+  } else if (options.estimate !== undefined) {
+    patch.estimate = parseEstimateOption(options.estimate);
+  }
+
+  if (options.clearDueDate) {
+    patch.dueDate = null;
+  } else if (options.dueDate) {
+    patch.dueDate = parseDueDate(options.dueDate);
+  }
+
+  if (options.clearLabels) {
+    patch.labels = null;
+  } else if (options.labels) {
+    patch.labels = parseCommaSeparated(options.labels);
+  }
+
+  for (const [key, value, cleared] of [
+    ["assignee", options.assignee, options.clearAssignee],
+    ["project", options.project, options.clearProject],
+    ["parentTicket", options.parentTicket, options.clearParentTicket],
+    [
+      "projectMilestone",
+      options.projectMilestone,
+      options.clearProjectMilestone,
+    ],
+    ["cycle", options.cycle, options.clearCycle],
+  ] as const) {
+    if (cleared) {
+      patch[key] = null;
+    } else if (value) {
+      patch[key] = value;
+    }
+  }
+
+  return patch;
+}
+
+function validateBatchUpdateOptions(options: BatchUpdateOptions): void {
+  const exclusions: Array<[string, unknown, string, unknown]> = [
+    ["--assignee", options.assignee, "--clear-assignee", options.clearAssignee],
+    ["--project", options.project, "--clear-project", options.clearProject],
+    ["--labels", options.labels, "--clear-labels", options.clearLabels],
+    ["--estimate", options.estimate, "--clear-estimate", options.clearEstimate],
+    ["--due-date", options.dueDate, "--clear-due-date", options.clearDueDate],
+    [
+      "--parent-ticket",
+      options.parentTicket,
+      "--clear-parent-ticket",
+      options.clearParentTicket,
+    ],
+    [
+      "--project-milestone",
+      options.projectMilestone,
+      "--clear-project-milestone",
+      options.clearProjectMilestone,
+    ],
+    ["--cycle", options.cycle, "--clear-cycle", options.clearCycle],
+  ];
+
+  for (const [flag, value, clearFlag, clearValue] of exclusions) {
+    if (value && clearValue) {
+      throw invalidParameterError(flag, `cannot be used with ${clearFlag}`);
+    }
+  }
+
+  // Milestones are scoped by project, and a batch has no single "current"
+  // project to fall back on the way a single-issue update does.
+  if (options.projectMilestone && !options.project) {
+    throw requiresParameterError("--project-milestone", "--project");
+  }
+}
+
+export function addBatchCommands(issues: Command): void {
+  const batch = issues
+    .command("batch")
+    .description("Bulk issue operations in a single transaction");
+
+  batch
+    .command("create")
+    .description("create many issues from a JSON document")
+    .addHelpText(
+      "after",
+      [
+        "",
+        "The document is a JSON array whose keys mirror the `issues create` flags:",
+        '  [{"title":"Fix login","team":"ENG","assignee":"alice","labels":["bug"]}]',
+        "Unknown keys are rejected rather than ignored.",
+        "",
+        `The full input contract is published as JSON Schema (draft 2020-12) at ${BATCH_CREATE_SCHEMA_URL}`,
+        "Point an editor or a validator at it to check a document before sending it:",
+        "  check-jsonschema --schemafile <schema-url> issues.json",
+      ].join("\n"),
+    )
+    .option(
+      "--file <path>",
+      "path to the JSON document, or - for stdin (see `issues usage` for the JSON Schema)",
+    )
+    .option("--json <json>", "the JSON document inline")
+    .action(
+      commandAction<[BatchCreateOptions, Command]>(async (options, command) => {
+        const entries = parseBatchCreateEntries(readBatchDocument(options));
+        const ctx = createContext(getRootOpts(command));
+
+        const resolved = await resolveBatchCreateIssueIds(
+          ctx.gql,
+          entries.map(toResolverInput),
+        );
+
+        const inputs = entries.map((entry, index) => {
+          // Positional pairing is safe: resolveBatchCreateIssueIds preserves
+          // input order even when it collapses duplicate lookups.
+          const ids = resolved[index] as ResolvedCreateIssueIds;
+
+          if (entry.estimate !== undefined && ids.estimateContext) {
+            validateEstimateAgainstTeamConfig(entry.estimate, {
+              teamKey: ids.estimateContext.teamKey,
+              issueEstimationType: ids.estimateContext.issueEstimationType,
+              issueEstimationExtended:
+                ids.estimateContext.issueEstimationExtended,
+              issueEstimationAllowZero:
+                ids.estimateContext.issueEstimationAllowZero,
+            });
+          }
+
+          return toCreateInput(entry, ids);
+        });
+
+        const result = await batchCreateIssues(ctx.gql, inputs);
+        outputSuccess(result);
+      }),
+    );
+
+  batch
+    .command("update")
+    .description("apply one patch to an explicit list of issues")
+    .addHelpText(
+      "after",
+      [
+        "",
+        "The patch is applied to every listed issue in one transaction.",
+        "This is deliberately not filter-driven: a mass mutation selected by",
+        "filter has no dry-run story. Name the issues you mean.",
+        "",
+        "The targets and the patch can also come from a JSON document, where",
+        "null clears a field the way the --clear-* flags do:",
+        '  {"issues":["ENG-1","ENG-2"],"patch":{"status":"Done","cycle":null}}',
+        "Unknown keys are rejected rather than ignored.",
+        "",
+        `The full input contract is published as JSON Schema (draft 2020-12) at ${BATCH_UPDATE_SCHEMA_URL}`,
+        "Point an editor or a validator at it to check a document before sending it:",
+        "  check-jsonschema --schemafile <schema-url> patch.json",
+      ].join("\n"),
+    )
+    .option("--issues <issues>", "issues to update (comma-separated)")
+    .option(
+      "--file <path>",
+      "path to a JSON patch document, or - for stdin (replaces the flags below)",
+    )
+    .option("--json <json>", "the JSON patch document inline")
+    .option("--title <text>", "new title")
+    .option("--description <text>", "new description")
+    .option("--status <status>", "new status")
+    .option("--priority <1-4>", "1=urgent 2=high 3=medium 4=low")
+    .option("--assignee <user>", "new assignee")
+    .option("--clear-assignee", "clear assignee")
+    .option("--project <project>", "new project")
+    .option("--clear-project", "clear project")
+    .option(
+      "--labels <labels>",
+      "labels to apply (comma-separated, overwrites)",
+    )
+    .option("--clear-labels", "remove all labels")
+    .option("--parent-ticket <issue>", "set parent issue")
+    .option("--clear-parent-ticket", "clear parent")
+    .option(
+      "--project-milestone <ms>",
+      "set project milestone (requires --project)",
+    )
+    .option("--clear-project-milestone", "clear project milestone")
+    .option("--cycle <cycle>", "set cycle")
+    .option("--clear-cycle", "remove issues from their cycle")
+    .option("--estimate <n>", "new estimate")
+    .option("--clear-estimate", "clear estimate")
+    .option("--due-date <date>", "set due date (YYYY-MM-DD)")
+    .option("--clear-due-date", "clear due date")
+    .action(
+      commandAction<[BatchUpdateOptions, Command]>(async (options, command) => {
+        const { issues, patch } = readBatchUpdateRequest(options);
+
+        const ctx = createContext(getRootOpts(command));
+        const targets = await resolveIssueRefs(ctx.gql, issues);
+        const context = buildBatchUpdateContext(targets, patch);
+
+        await validateBatchUpdateEstimate(ctx.gql, targets, patch);
+
+        const resolverInput = buildBatchUpdateResolverInput(patch);
+        const ids =
+          Object.keys(resolverInput).length > 0
+            ? await resolveUpdateIssueIds(ctx.gql, resolverInput, context)
+            : {};
+
+        const input = buildBatchUpdateInput(patch, ids);
+
+        if (Object.keys(input).length === 0) {
+          throw invalidParameterError(
+            "batch update",
+            "needs at least one field to change",
+          );
+        }
+
+        const result = await batchUpdateIssues(
+          ctx.gql,
+          targets.map((target) => target.id),
+          input,
+        );
+        outputSuccess(result);
+      }),
+    );
+}
+
+/**
+ * Turns the flags into the single patch every target receives.
+ *
+ * Exported so the clear-versus-set branches can be asserted without driving a
+ * full command; `null` and "absent" mean different things to the API, and only
+ * the built input shows which one a flag produced.
+ */
+export function buildBatchUpdateInput(
+  patch: BatchUpdatePatch,
+  ids: {
+    assigneeId?: UUID;
+    projectId?: UUID;
+    labelIds?: UUID[];
+    projectMilestoneId?: UUID;
+    cycleId?: UUID;
+    stateId?: UUID;
+    parentId?: UUID;
+  },
+): UpdateIssueInput {
+  const input: UpdateIssueInput = {};
+
+  if (patch.title !== undefined) input.title = patch.title;
+  if (patch.description !== undefined) input.description = patch.description;
+  if (patch.priority !== undefined) input.priority = patch.priority;
+  if (patch.estimate !== undefined) input.estimate = patch.estimate;
+  if (patch.dueDate !== undefined) input.dueDate = patch.dueDate;
+
+  if (patch.assignee === null) {
+    input.assigneeId = null;
+  } else if (ids.assigneeId) {
+    input.assigneeId = ids.assigneeId;
+  }
+
+  if (patch.project === null) {
+    input.projectId = null;
+    input.projectMilestoneId = null;
+  } else if (ids.projectId) {
+    input.projectId = ids.projectId;
+  }
+
+  // Only overwrite semantics here: add/remove would need each target's current
+  // label set, which a single-patch mutation cannot express.
+  if (patch.labels === null) {
+    input.labelIds = [];
+  } else if (ids.labelIds) {
+    input.labelIds = ids.labelIds;
+  }
+
+  if (patch.parentTicket === null) {
+    input.parentId = null;
+  } else if (ids.parentId) {
+    input.parentId = ids.parentId;
+  }
+
+  // Clearing the project already nulls the milestone above; clearing the
+  // milestone alone has to work too, for a batch that stays in its project.
+  if (patch.projectMilestone === null) {
+    input.projectMilestoneId = null;
+  } else if (ids.projectMilestoneId) {
+    input.projectMilestoneId = ids.projectMilestoneId;
+  }
+
+  if (patch.cycle === null) {
+    input.cycleId = null;
+  } else if (ids.cycleId) {
+    input.cycleId = ids.cycleId;
+  }
+
+  if (ids.stateId) input.stateId = ids.stateId;
+
+  return input;
+}
diff --git a/src/commands/issues.ts b/src/commands/issues.ts
index 15ca9c4d..cf817c6a 100644
--- a/src/commands/issues.ts
+++ b/src/commands/issues.ts
@@ -2,10 +2,16 @@ import type { Command } from "commander";
 import { firstOrThrow } from "../common/array.js";
 import type { CommandContext } from "../common/context.js";
 import { createContext, getRootOpts } from "../common/context.js";
-import { parseLabelMode } from "../common/domain-values.js";
+import { parseDateTimeOption } from "../common/datetime.js";
+import {
+  parseLabelMode,
+  parseSetMode,
+  type SetMode,
+} from "../common/domain-values.js";
 import { resolveReactionEmojiInput } from "../common/emoji.js";
 import { invalidParameterError } from "../common/errors.js";
 import { validateEstimateAgainstTeamConfig } from "../common/estimate-validation.js";
+import { getCurrentBranch } from "../common/git.js";
 import {
   asUuid,
   isUuid,
@@ -13,16 +19,22 @@ import {
   parseIssueIdentifier,
   type UUID,
 } from "../common/identifier.js";
-import type { RawFilterFlags } from "../common/issue-filter.js";
+import {
+  parseCommaSeparated,
+  type RawFilterFlags,
+} from "../common/issue-filter.js";
 import {
   parseEstimateOption,
   parsePriorityOption,
 } from "../common/number-options.js";
 import { commandAction, outputSuccess, parseLimit } from "../common/output.js";
 import { resolveFilterOptions } from "../common/resolve-filters.js";
-import { buildPaginationOptions } from "../common/types.js";
+import {
+  buildPaginationOptions,
+  type PaginationOptions,
+} from "../common/types.js";
 import { type DomainMeta, formatDomainUsage } from "../common/usage.js";
-import type { IssueRelationType } from "../gql/graphql.js";
+import type { IssueRelationType, PaginationOrderBy } from "../gql/graphql.js";
 import {
   type ResolveCreateIssueIdsInput,
   type ResolvedUpdateIssueIds,
@@ -35,6 +47,8 @@ import {
   resolveIssueEstimateContext,
   resolveIssueId,
 } from "../resolvers/issue-resolver.js";
+import { resolveTeamEstimateContext } from "../resolvers/team-resolver.js";
+import { resolveUserId, resolveViewerId } from "../resolvers/user-resolver.js";
 import { getIssueActivity } from "../services/activity-service.js";
 import {
   createDiscussionCommentReaction,
@@ -65,6 +79,7 @@ import {
   type CreateIssueInput,
   createIssue,
   deleteIssue,
+  findIssueByBranch,
   getIssue,
   getIssueByIdentifier,
   getIssueByIdentifierWithAttachments,
@@ -75,10 +90,19 @@ import {
   getIssueWithComments,
   getIssueWithCommentThreads,
   getIssueWithReactions,
+  type IssueDetail,
+  type IssueReadOptions,
   listIssues,
+  remindOnIssue,
+  restoreIssue,
   searchIssues,
+  shareIssue,
+  snoozeIssue,
+  subscribeToIssue,
   type UpdateIssueInput,
   unarchiveIssue,
+  unshareIssue,
+  unsubscribeFromIssue,
   updateIssue,
 } from "../services/issue-service.js";
 import {
@@ -86,11 +110,14 @@ import {
   deleteOwnReactionByEmoji,
   deleteOwnReactionById,
 } from "../services/reaction-service.js";
+import { addBatchCommands } from "./issues-batch.js";
 
 interface FilterOptions extends RawFilterFlags {
   limit: string;
   after?: string;
   query?: string;
+  includeArchived?: boolean;
+  orderBy?: string;
 }
 
 interface CreateOptions {
@@ -105,6 +132,8 @@ interface CreateOptions {
   cycle?: string;
   status?: string;
   parentTicket?: string;
+  subscribers?: string;
+  delegate?: string;
   dueDate?: string;
   blocks?: string;
   blockedBy?: string;
@@ -133,6 +162,12 @@ interface UpdateOptions {
   clearProjectMilestone?: boolean;
   cycle?: string;
   clearCycle?: boolean;
+  team?: string;
+  subscribers?: string;
+  subscriberMode?: string;
+  clearSubscribers?: boolean;
+  delegate?: string;
+  clearDelegate?: boolean;
   dueDate?: string;
   clearDueDate?: boolean;
   blocks?: string;
@@ -164,6 +199,90 @@ function validateReadOptions(options: ReadOptions): void {
   }
 }
 
+interface SubscriberOptions {
+  user?: string;
+}
+
+interface ShareOptions {
+  with: string;
+}
+
+interface RemindOptions {
+  at: string;
+}
+
+interface SnoozeOptions {
+  until?: string;
+  clear?: boolean;
+}
+
+/** `--until <when>` snoozes; `--clear` wakes. Exactly one is required. */
+function parseSnoozeTarget(options: SnoozeOptions): string | null {
+  if (options.until && options.clear) {
+    throw invalidParameterError("--until", "cannot be used with --clear");
+  }
+
+  if (options.clear) {
+    return null;
+  }
+
+  if (!options.until) {
+    throw invalidParameterError("--until", "is required (or pass --clear)");
+  }
+
+  return parseDateTimeOption("--until", options.until);
+}
+
+/**
+ * Resolves the issue and the user a subscribe/share command acts on.
+ *
+ * The two lookups are independent, so they run concurrently. An omitted user
+ * means the caller themselves — subscribing yourself is the overwhelmingly
+ * common case, and `me` is accepted as the explicit spelling of the same thing
+ * (see `resolveUserId`).
+ */
+async function resolveIssueAndUser(
+  ctx: CommandContext,
+  issue: string,
+  user: string | undefined,
+): Promise<[UUID, UUID]> {
+  return Promise.all([
+    resolveIssueId(ctx.gql, issue),
+    user === undefined
+      ? resolveViewerId(ctx.gql)
+      : resolveUserId(ctx.gql, user),
+  ]);
+}
+
+/**
+ * Combines a set-valued flag with the issue's current members.
+ *
+ * `overwrite` (and an omitted mode) replaces, matching the API's own
+ * replace-the-list semantics for `labelIds`/`subscriberIds`; `add` and
+ * `remove` are computed here from the issue's current values because the API
+ * has no incremental form for either field.
+ */
+function applySetMode(
+  mode: SetMode | undefined,
+  current: readonly UUID[],
+  requested: readonly UUID[],
+): UUID[] {
+  if (mode === "add") {
+    return [...new Set([...current, ...requested])];
+  }
+
+  if (mode === "remove") {
+    return current.filter((id) => !requested.includes(id));
+  }
+
+  return [...requested];
+}
+
+/** The issue's current subscriber UUIDs, for `--subscriber-mode add|remove`. */
+function currentSubscriberIds(issue: IssueDetail | undefined): UUID[] {
+  return (issue?.subscribers?.nodes ?? []).map((user) => asUuid(user.id));
+}
+
 interface ReactionOptions {
   shortcode?: string;
 }
@@ -267,18 +386,69 @@ export const ISSUES_META: DomainMeta = {
     "issues can have labels, a due date, belong to a project, be part of a",
     "cycle (sprint), and reference a project milestone. parent-child",
     "relationships and issue relations (blocks, blocked-by, relates-to,",
-    "duplicate-of) are supported.",
+    "duplicate-of) are supported. an issue can also be moved between teams",
+    "with `update --team`.",
+    "",
+    "an issue has three separate 'put it away' states, and they do not",
+    "overlap: archive (`archive`/`unarchive`), trash (`delete`/`restore`),",
+    "and snooze until a time (`snooze --until|--clear`). archived issues are",
+    "reachable by identifier everywhere, but excluded from `list`/`search`",
+    "unless you pass --include-archived.",
+    "",
+    "`list` also hides completed issues by default. saying anything about",
+    "state lifts that narrowing: --status and --state-type replace it with",
+    "what you asked for, and --include-archived drops it too. so on `list`",
+    "--include-archived widens the result twice — archived issues are nearly",
+    "always completed, and keeping the default clause would hide the very",
+    "issues the flag was passed to surface. to see completed work without",
+    "archived issues, pass --state-type completed instead.",
+    "",
+    "full-text search does not narrow by state: `search`, and `list --query`",
+    "which runs the same query, return completed issues whether or not you",
+    "pass --include-archived. there --include-archived only adds archived",
+    "issues. filter with --state-type if you want a state-bounded search.",
+    "",
+    "people attach to an issue in four ways: assignee (one, owns it),",
+    "delegate (one, acts for the assignee), subscribers (many, get notified),",
+    "and shared access (`share --with`, which grants a user visibility of an",
+    "issue they otherwise could not see — it does not produce a link; the",
+    "issue's permalink is the `url` field on any read).",
+    "",
+    "both batch commands take a JSON document instead of flags, with unknown",
+    "keys rejected rather than ignored. `batch create` takes an array with one",
+    "object per issue, keys named after the `issues create` flags. `batch",
+    'update` takes {"issues": [...], "patch": {...}}, keys named after the',
+    "`issues update` flags, where null clears a field the way --clear-* does.",
+    "each contract is published as JSON Schema (draft 2020-12) in `schemas/`,",
+    "also shipped in the npm package and served raw from the repository's",
+    "default branch:",
+    "https://raw.githubusercontent.com/linearis-oss/linearis/next/schemas/issues-batch-create.schema.json",
+    "https://raw.githubusercontent.com/linearis-oss/linearis/next/schemas/issues-batch-update.schema.json",
+    "write the document against the schema, validate it locally, then pass it",
+    "with --file (or - for stdin).",
   ].join("\n"),
   arguments: {
     issue: "issue identifier (UUID or ABC-123)",
     title: "string",
     query: "full-text search term",
+    user: "display name, email, UUID, or `me` for yourself",
+    when: "ISO-8601 instant (2026-08-14T09:00:00Z) or offset (+2h, +3d)",
   },
   seeAlso: [
     "issues activity <issue>",
+    "issues batch create --file issues.json",
+    "issues batch update --issues ENG-1,ENG-2 --status Done",
+    "issues batch update --file patch.json",
+    "issues from-branch",
+    "issues subscribe <issue> [--user <user>]",
+    "issues share <issue> --with <user>",
+    "issues remind <issue> --at +2h",
+    "issues snooze <issue> --until 2026-08-20",
+    "issues restore <issue>",
     "comments create <issue>",
     "documents list --issue <issue>",
     "attachments list <issue>",
+    "attachments disable-sync <id>",
     "issues read --with-attachments",
     "issues archive <issue>",
     "issues unarchive <issue>",
@@ -492,6 +662,35 @@ async function resolveAndApplyRelations(
   }
 }
 
+/**
+ * Fold `--include-archived` into the pagination options. The key is left absent
+ * rather than set to `false` so the request matches the pre-flag shape exactly
+ * under `exactOptionalPropertyTypes`.
+ */
+function buildIssueReadOptions(
+  pagination: PaginationOptions,
+  options: Pick<FilterOptions, "includeArchived" | "orderBy">,
+): IssueReadOptions {
+  return {
+    ...pagination,
+    ...(options.includeArchived ? { includeArchived: true } : {}),
+    ...(options.orderBy ? { orderBy: parseOrderBy(options.orderBy) } : {}),
+  };
+}
+
+/**
+ * Maps the CLI's `created`/`updated` onto Linear's `PaginationOrderBy`.
+ *
+ * The API spells them `createdAt`/`updatedAt`; both spellings are accepted so a
+ * caller who read the field name in a payload is not told they are wrong.
+ */
+function parseOrderBy(value: string): PaginationOrderBy {
+  if (value === "created" || value === "createdAt") return "createdAt";
+  if (value === "updated" || value === "updatedAt") return "updatedAt";
+
+  throw invalidParameterError("--order-by", "must be 'created' or 'updated'");
+}
+
 function addFilterOptions(cmd: ReturnType<Command["command"]>): typeof cmd {
   return cmd
     .option("--team <team>", "filter by team")
@@ -520,12 +719,24 @@ function addFilterOptions(cmd: ReturnType<Command["command"]>): typeof cmd {
     .option("--updated-after <date>", "updated after date (YYYY-MM-DD)")
     .option("--updated-before <date>", "updated before date (YYYY-MM-DD)")
     .option("--has-blockers", "only issues that are blocked")
-    .option("--is-blocking", "only issues that block others");
+    .option("--is-blocking", "only issues that block others")
+    .option("--unassigned", "only issues with no assignee")
+    .option(
+      "--state-type <type>",
+      "filter by state category (triage, backlog, unstarted, started, completed, canceled)",
+    )
+    .option("--subscriber <user>", "filter by subscriber")
+    .option(
+      "--include-archived",
+      "include archived issues (on `list`, also drops the default 'hide completed' narrowing; full-text search never applies it)",
+    );
 }
 
 export function setupIssuesCommands(program: Command): void {
   const issues = program.command("issues").description("Issue operations");
 
+  addBatchCommands(issues);
+
   const relations = issues
     .command("relations")
     .description("Issue relation operations");
@@ -599,15 +810,25 @@ export function setupIssuesCommands(program: Command): void {
       .command("list")
       .description("list issues with optional filters")
       .option("--query <query>", "deprecated: use `issues search <query>`")
+      .option("--order-by <field>", "created | updated (default: updated)")
       .option("-l, --limit <n>", "max results", "50")
       .option("--after <cursor>", "cursor for next page"),
   ).action(
     commandAction<[FilterOptions, Command]>(async (options, command) => {
+      // Full-text results come back relevance-ordered from the API, so
+      // --order-by has nothing to act on down that path.
+      if (options.orderBy && options.query) {
+        throw invalidParameterError(
+          "--order-by",
+          "cannot be combined with --query, whose results are relevance-ordered",
+        );
+      }
+
       const ctx = createContext(getRootOpts(command));
 
-      const paginationOptions = buildPaginationOptions(
-        parseLimit(options.limit),
-        options.after,
+      const readOptions = buildIssueReadOptions(
+        buildPaginationOptions(parseLimit(options.limit), options.after),
+        options,
       );
 
       const filterOptions = await resolveFilterOptions(ctx, options);
@@ -617,14 +838,14 @@ export function setupIssuesCommands(program: Command): void {
         const result = await searchIssues(
           ctx.gql,
           options.query,
-          paginationOptions,
+          readOptions,
           filter,
         );
         outputSuccess(result);
         return;
       }
 
-      const result = await listIssues(ctx.gql, paginationOptions, filter);
+      const result = await listIssues(ctx.gql, readOptions, filter);
       outputSuccess(result);
     }),
   );
@@ -640,19 +861,14 @@ export function setupIssuesCommands(program: Command): void {
       async (query, options, command) => {
         const ctx = createContext(getRootOpts(command));
 
-        const paginationOptions = buildPaginationOptions(
-          parseLimit(options.limit),
-          options.after,
+        const readOptions = buildIssueReadOptions(
+          buildPaginationOptions(parseLimit(options.limit), options.after),
+          options,
         );
 
         const filterOptions = await resolveFilterOptions(ctx, options);
         const filter = buildIssueFilter(filterOptions);
-        const result = await searchIssues(
-          ctx.gql,
-          query,
-          paginationOptions,
-          filter,
-        );
+        const result = await searchIssues(ctx.gql, query, readOptions, filter);
         outputSuccess(result);
       },
     ),
@@ -1142,6 +1358,8 @@ export function setupIssuesCommands(program: Command): void {
     .option("--status <status>", "set status")
     .option("--estimate <n>", "set estimate")
     .option("--parent-ticket <issue>", "set parent issue")
+    .option("--subscribers <users>", "subscribe users (comma-separated)")
+    .option("--delegate <user>", "delegate to a user")
     .option("--due-date <date>", "due date (YYYY-MM-DD)")
     .option("--blocks <issue>", "this issue blocks <issue>")
     .option("--blocked-by <issue>", "this issue is blocked by <issue>")
@@ -1190,6 +1408,10 @@ export function setupIssuesCommands(program: Command): void {
           if (options.status) idsInput.status = options.status;
           if (options.parentTicket)
             idsInput.parentTicket = options.parentTicket;
+          if (options.subscribers) {
+            idsInput.subscribers = parseCommaSeparated(options.subscribers);
+          }
+          if (options.delegate) idsInput.delegate = options.delegate;
 
           const ids = await resolveCreateIssueIds(ctx.gql, idsInput);
 
@@ -1249,6 +1471,14 @@ export function setupIssuesCommands(program: Command): void {
             input.parentId = ids.parentId;
           }
 
+          if (ids.subscriberIds) {
+            input.subscriberIds = ids.subscriberIds;
+          }
+
+          if (ids.delegateId) {
+            input.delegateId = ids.delegateId;
+          }
+
           if (options.dueDate) {
             input.dueDate = parseDueDate(options.dueDate);
           }
@@ -1292,6 +1522,12 @@ export function setupIssuesCommands(program: Command): void {
     .option("--clear-project-milestone", "clear project milestone")
     .option("--cycle <cycle>", "set cycle")
     .option("--clear-cycle", "clear cycle")
+    .option("--team <team>", "move the issue to another team")
+    .option("--subscribers <users>", "subscribers to apply (comma-separated)")
+    .option("--subscriber-mode <mode>", "add | remove | overwrite")
+    .option("--clear-subscribers", "remove all subscribers")
+    .option("--delegate <user>", "set delegate")
+    .option("--clear-delegate", "clear delegate")
     .option("--estimate <n>", "new estimate")
     .option("--clear-estimate", "clear estimate")
     .option("--due-date <date>", "set due date (YYYY-MM-DD)")
@@ -1363,7 +1599,35 @@ export function setupIssuesCommands(program: Command): void {
             throw new Error("--clear-labels cannot be used with --label-mode");
           }
 
+          if (options.subscriberMode && !options.subscribers) {
+            throw new Error(
+              "--subscriber-mode requires --subscribers to be specified",
+            );
+          }
+
+          if (options.clearSubscribers && options.subscribers) {
+            throw new Error(
+              "--clear-subscribers cannot be used with --subscribers",
+            );
+          }
+
+          if (options.clearSubscribers && options.subscriberMode) {
+            throw new Error(
+              "--clear-subscribers cannot be used with --subscriber-mode",
+            );
+          }
+
+          if (options.delegate && options.clearDelegate) {
+            throw new Error(
+              "Cannot use --delegate and --clear-delegate together",
+            );
+          }
+
           const labelMode = parseLabelMode(options.labelMode);
+          const subscriberMode = parseSetMode(
+            "--subscriber-mode",
+            options.subscriberMode,
+          );
 
           const parsedPriority =
             options.priority !== undefined
@@ -1378,8 +1642,18 @@ export function setupIssuesCommands(program: Command): void {
 
           const ctx = createContext(getRootOpts(command));
 
+          // The estimate has to satisfy the scale of the team that ends up
+          // owning the issue. With --team that is the destination, not the
+          // team the issue is leaving: validating against the current team
+          // would reject a value the move makes legal and wave through one it
+          // makes illegal, which then comes back as a raw API error.
+          const destinationEstimateTeam =
+            parsedEstimate !== undefined && options.team
+              ? await resolveTeamEstimateContext(ctx.gql, options.team)
+              : undefined;
+
           const issueEstimateContext =
-            parsedEstimate !== undefined
+            parsedEstimate !== undefined && !destinationEstimateTeam
               ? await resolveIssueEstimateContext(ctx.gql, issue)
               : undefined;
 
@@ -1387,15 +1661,15 @@ export function setupIssuesCommands(program: Command): void {
             ? issueEstimateContext.issueId
             : await resolveIssueId(ctx.gql, issue);
 
-          if (parsedEstimate !== undefined && issueEstimateContext) {
+          const estimateTeam =
+            destinationEstimateTeam ?? issueEstimateContext?.team;
+
+          if (parsedEstimate !== undefined && estimateTeam) {
             validateEstimateAgainstTeamConfig(parsedEstimate, {
-              teamKey: issueEstimateContext.team.teamKey,
-              issueEstimationType:
-                issueEstimateContext.team.issueEstimationType,
-              issueEstimationExtended:
-                issueEstimateContext.team.issueEstimationExtended,
-              issueEstimationAllowZero:
-                issueEstimateContext.team.issueEstimationAllowZero,
+              teamKey: estimateTeam.teamKey,
+              issueEstimationType: estimateTeam.issueEstimationType,
+              issueEstimationExtended: estimateTeam.issueEstimationExtended,
+              issueEstimationAllowZero: estimateTeam.issueEstimationAllowZero,
             });
           }
 
@@ -1403,7 +1677,10 @@ export function setupIssuesCommands(program: Command): void {
             options.status ||
             options.projectMilestone ||
             options.cycle ||
-            (options.labels && (labelMode === "add" || labelMode === "remove"));
+            (options.labels &&
+              (labelMode === "add" || labelMode === "remove")) ||
+            (options.subscribers &&
+              (subscriberMode === "add" || subscriberMode === "remove"));
           const issueContext = needsContext
             ? await getIssue(ctx.gql, resolvedIssueId)
             : undefined;
@@ -1443,6 +1720,13 @@ export function setupIssuesCommands(program: Command): void {
           if (!options.clearParentTicket && options.parentTicket) {
             updIdsInput.parentTicket = options.parentTicket;
           }
+          if (options.team) updIdsInput.team = options.team;
+          if (!options.clearSubscribers && options.subscribers) {
+            updIdsInput.subscribers = parseCommaSeparated(options.subscribers);
+          }
+          if (!options.clearDelegate && options.delegate) {
+            updIdsInput.delegate = options.delegate;
+          }
 
           const needsResolution =
             updIdsInput.assignee !== undefined ||
@@ -1451,7 +1735,10 @@ export function setupIssuesCommands(program: Command): void {
             updIdsInput.projectMilestone !== undefined ||
             updIdsInput.cycle !== undefined ||
             updIdsInput.status !== undefined ||
-            updIdsInput.parentTicket !== undefined;
+            updIdsInput.parentTicket !== undefined ||
+            updIdsInput.team !== undefined ||
+            updIdsInput.subscribers !== undefined ||
+            updIdsInput.delegate !== undefined;
 
           const ids: ResolvedUpdateIssueIds = needsResolution
             ? await resolveUpdateIssueIds(ctx.gql, updIdsInput, updContext)
@@ -1504,15 +1791,7 @@ export function setupIssuesCommands(program: Command): void {
                 ? issueContext.labels.nodes.map((l) => asUuid(l.id))
                 : [];
 
-            if (labelMode === "add") {
-              input.labelIds = [...new Set([...currentLabels, ...labelIds])];
-            } else if (labelMode === "remove") {
-              input.labelIds = currentLabels.filter(
-                (id) => !labelIds.includes(id),
-              );
-            } else {
-              input.labelIds = labelIds;
-            }
+            input.labelIds = applySetMode(labelMode, currentLabels, labelIds);
           }
 
           if (options.clearParentTicket) {
@@ -1539,6 +1818,26 @@ export function setupIssuesCommands(program: Command): void {
             input.cycleId = ids.cycleId;
           }
 
+          if (ids.teamId) {
+            input.teamId = ids.teamId;
+          }
+
+          if (options.clearSubscribers) {
+            input.subscriberIds = [];
+          } else if (options.subscribers && ids.subscriberIds) {
+            input.subscriberIds = applySetMode(
+              subscriberMode,
+              currentSubscriberIds(issueContext),
+              ids.subscriberIds,
+            );
+          }
+
+          if (options.clearDelegate) {
+            input.delegateId = null;
+          } else if (ids.delegateId) {
+            input.delegateId = ids.delegateId;
+          }
+
           if (options.clearDueDate) {
             input.dueDate = null;
           } else if (options.dueDate) {
@@ -1560,6 +1859,142 @@ export function setupIssuesCommands(program: Command): void {
       ),
     );
 
+  issues
+    .command("from-branch [branch]")
+    .description("find the issue a git branch belongs to")
+    .addHelpText(
+      "after",
+      "\nWith no argument the current checkout's branch is used, so this works as `linearis issues from-branch` inside a worktree.",
+    )
+    .action(
+      commandAction<[string | undefined, unknown, Command]>(
+        async (branch, _unused1, command) => {
+          const branchName = branch ?? getCurrentBranch();
+          const ctx = createContext(getRootOpts(command));
+          const result = await findIssueByBranch(ctx.gql, branchName);
+
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  issues
+    .command("subscribe <issue>")
+    .description("subscribe a user to an issue's notifications")
+    .addHelpText(
+      "after",
+      `\nWhen passing issue IDs, both UUID and identifiers like ABC-123 are supported.`,
+    )
+    .option("--user <user>", "user to subscribe (defaults to you)")
+    .action(
+      commandAction<[string, SubscriberOptions, Command]>(
+        async (issue, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+          const [issueId, userId] = await resolveIssueAndUser(
+            ctx,
+            issue,
+            options.user,
+          );
+          const result = await subscribeToIssue(ctx.gql, issueId, userId);
+
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  issues
+    .command("unsubscribe <issue>")
+    .description("remove a user from an issue's subscribers")
+    .addHelpText(
+      "after",
+      `\nWhen passing issue IDs, both UUID and identifiers like ABC-123 are supported.`,
+    )
+    .option("--user <user>", "user to unsubscribe (defaults to you)")
+    .action(
+      commandAction<[string, SubscriberOptions, Command]>(
+        async (issue, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+          const [issueId, userId] = await resolveIssueAndUser(
+            ctx,
+            issue,
+            options.user,
+          );
+          const result = await unsubscribeFromIssue(ctx.gql, issueId, userId);
+
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  issues
+    .command("share <issue>")
+    .description("grant a user access to an issue")
+    .addHelpText(
+      "after",
+      `\nWhen passing issue IDs, both UUID and identifiers like ABC-123 are supported.\nThis grants access; it does not mint a link. The issue's permalink is the \`url\` field on \`issues read\`.`,
+    )
+    .requiredOption("--with <user>", "user to grant access to")
+    .action(
+      commandAction<[string, ShareOptions, Command]>(
+        async (issue, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+          const [issueId, userId] = await resolveIssueAndUser(
+            ctx,
+            issue,
+            options.with,
+          );
+          const result = await shareIssue(ctx.gql, issueId, userId);
+
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  issues
+    .command("unshare <issue>")
+    .description("revoke a user's access to an issue")
+    .addHelpText(
+      "after",
+      `\nWhen passing issue IDs, both UUID and identifiers like ABC-123 are supported.`,
+    )
+    .requiredOption("--with <user>", "user to revoke access from")
+    .action(
+      commandAction<[string, ShareOptions, Command]>(
+        async (issue, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+          const [issueId, userId] = await resolveIssueAndUser(
+            ctx,
+            issue,
+            options.with,
+          );
+          const result = await unshareIssue(ctx.gql, issueId, userId);
+
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  issues
+    .command("remind <issue>")
+    .description("schedule a reminder for yourself on an issue")
+    .addHelpText(
+      "after",
+      `\nWhen passing issue IDs, both UUID and identifiers like ABC-123 are supported.\n--at accepts an ISO-8601 instant (2026-08-14T09:00:00Z) or a relative offset (+2h, +3d).`,
+    )
+    .requiredOption("--at <when>", "when to be reminded")
+    .action(
+      commandAction<[string, RemindOptions, Command]>(
+        async (issue, options, command) => {
+          const reminderAt = parseDateTimeOption("--at", options.at);
+          const ctx = createContext(getRootOpts(command));
+          const issueId = await resolveIssueId(ctx.gql, issue);
+          const result = await remindOnIssue(ctx.gql, issueId, reminderAt);
+
+          outputSuccess(result);
+        },
+      ),
+    );
+
   issues
     .command("archive <issue>")
     .description("archive an issue")
@@ -1588,6 +2023,47 @@ export function setupIssuesCommands(program: Command): void {
       ),
     );
 
+  issues
+    .command("restore <issue>")
+    .description("restore an issue from the trash")
+    .addHelpText(
+      "after",
+      "\n`issues delete` trashes rather than destroys, and this is the way back. Archiving is a separate state — use `issues unarchive` for that.",
+    )
+    .action(
+      commandAction<[string, unknown, Command]>(
+        async (issue, _unused1, command) => {
+          const ctx = createContext(getRootOpts(command));
+          const issueId = await resolveIssueId(ctx.gql, issue);
+          const result = await restoreIssue(ctx.gql, issueId);
+
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  issues
+    .command("snooze <issue>")
+    .description("snooze an issue until a given time, or wake it")
+    .addHelpText(
+      "after",
+      "\n--until accepts an ISO-8601 instant (2026-08-20T09:00:00Z) or a relative offset (+2h, +3d).",
+    )
+    .option("--until <when>", "snooze until this instant")
+    .option("--clear", "wake the issue now")
+    .action(
+      commandAction<[string, SnoozeOptions, Command]>(
+        async (issue, options, command) => {
+          const snoozedUntilAt = parseSnoozeTarget(options);
+          const ctx = createContext(getRootOpts(command));
+          const issueId = await resolveIssueId(ctx.gql, issue);
+          const result = await snoozeIssue(ctx.gql, issueId, snoozedUntilAt);
+
+          outputSuccess(result);
+        },
+      ),
+    );
+
   issues
     .command("delete <issue>")
     .description("delete an issue")
diff --git a/src/commands/labels.ts b/src/commands/labels.ts
index a22e4bdf..9a4ce232 100644
--- a/src/commands/labels.ts
+++ b/src/commands/labels.ts
@@ -11,8 +11,10 @@ import { handleCommand, outputSuccess, parseLimit } from "../common/output.js";
 import { type DomainMeta, formatDomainUsage } from "../common/usage.js";
 import {
   type LabelResolverScope,
+  type ResolveLabelOptions,
   resolveLabelId,
 } from "../resolvers/label-resolver.js";
+import { resolveProjectLabelId } from "../resolvers/project-resolver.js";
 import { resolveTeamId } from "../resolvers/team-resolver.js";
 import {
   type CreateLabelInput,
@@ -23,6 +25,8 @@ import {
   type LabelType,
   listLabels,
   listProjectLabels,
+  restoreLabel,
+  retireLabel,
   type UpdateLabelInput,
   updateLabel,
 } from "../services/label-service.js";
@@ -36,20 +40,28 @@ interface ListLabelsOptions extends CommandOptions {
 }
 
 interface LabelLookupOptions extends CommandOptions {
+  type?: string;
   team?: string;
   scope?: string;
 }
 
 interface CreateLabelOptions extends CommandOptions {
+  type?: string;
   team?: string;
   color?: string;
   description?: string;
+  parent?: string;
+  group?: boolean;
 }
 
 interface UpdateLabelOptions extends LabelLookupOptions {
   name?: string;
   color?: string;
   description?: string;
+  parent?: string;
+  clearParent?: boolean;
+  group?: boolean;
+  notGroup?: boolean;
 }
 
 function parseLabelType(value?: string): LabelType {
@@ -83,14 +95,85 @@ function parseLabelColor(value?: string): string | undefined {
   return value;
 }
 
-async function resolveIssueLabelLookup(
+/**
+ * Project labels have no team dimension at all, so silently ignoring
+ * `--team`/`--scope` would answer a question the caller did not ask.
+ */
+function rejectTeamScopingForProjectLabels(
+  team: string | undefined,
+  scope: LabelScope | undefined,
+): void {
+  if (team) {
+    throw invalidParameterError(
+      "--team",
+      "cannot be used with --type project because project labels are workspace-scoped",
+    );
+  }
+
+  if (scope) {
+    throw invalidParameterError(
+      "--scope",
+      "cannot be used with --type project because project labels are always workspace-scoped",
+    );
+  }
+}
+
+/**
+ * Resolves `--parent` against the same label kind as the label being written.
+ *
+ * A group and its children are always the same kind, so routing the parent
+ * through the other resolver could only ever produce a not-found or a
+ * cross-kind parent the API would reject.
+ *
+ * Issue-label lookups take the same team scoping the written label was
+ * resolved with. Without it the workspace-wide name match wins, so in a
+ * workspace where two teams each own a group called "Area" the new label would
+ * land in whichever one the API returned first.
+ */
+async function resolveLabelParentId(
+  client: ReturnType<typeof createContext>["gql"],
+  parent: string,
+  type: LabelType,
+  scoping: ResolveLabelOptions,
+): Promise<UUID> {
+  return type === "project"
+    ? resolveProjectLabelId(client, parent)
+    : resolveLabelId(client, parent, scoping);
+}
+
+/**
+ * Resolves `<label>` to a UUID for whichever label kind `--type` selects.
+ *
+ * Project labels are always workspace-scoped, so `--team` and `--scope` are
+ * rejected rather than quietly ignored — the same guard `labels list`
+ * already applies.
+ */
+async function resolveLabelLookup(
   command: Command,
   label: string,
   options: LabelLookupOptions,
-): Promise<{ ctx: ReturnType<typeof createContext>; labelId: UUID }> {
+): Promise<{
+  ctx: ReturnType<typeof createContext>;
+  labelId: UUID;
+  type: LabelType;
+  /** The scoping `<label>` was resolved with, so `--parent` can reuse it. */
+  scoping: ResolveLabelOptions;
+}> {
   const ctx = createContext(getRootOpts(command));
+  const type = parseLabelType(options.type);
   const scope = parseLabelScope(options.scope);
 
+  if (type === "project") {
+    rejectTeamScopingForProjectLabels(options.team, scope);
+
+    return {
+      ctx,
+      labelId: await resolveProjectLabelId(ctx.gql, label),
+      type,
+      scoping: {},
+    };
+  }
+
   if (scope === "team" && !options.team) {
     throw invalidParameterError("--scope", "team scope requires --team");
   }
@@ -105,22 +188,42 @@ async function resolveIssueLabelLookup(
   const teamId = options.team
     ? await resolveTeamId(ctx.gql, options.team)
     : undefined;
-  const labelId = await resolveLabelId(
-    ctx.gql,
-    label,
-    omitUndefined({
-      teamId,
-      scope: scope as LabelResolverScope | undefined,
-    }),
-  );
+  const scoping = omitUndefined({
+    teamId,
+    scope: scope as LabelResolverScope | undefined,
+  });
+  const labelId = await resolveLabelId(ctx.gql, label, scoping);
+
+  return { ctx, labelId, type, scoping };
+}
+
+/**
+ * Both label update inputs take `null` for `parentId` and `isGroup`, so every
+ * setter here has an inverse: without one a label could be moved into a group
+ * or turned into a group but never taken back out.
+ */
+function rejectContradictoryLabelFlags(options: UpdateLabelOptions): void {
+  if (options.parent && options.clearParent) {
+    throw invalidParameterError(
+      "--parent",
+      "cannot be combined with --clear-parent",
+    );
+  }
 
-  return { ctx, labelId };
+  if (options.group && options.notGroup) {
+    throw invalidParameterError(
+      "--group",
+      "cannot be combined with --not-group",
+    );
+  }
 }
 
 function buildUpdateInput(options: UpdateLabelOptions): UpdateLabelInput {
   const input: UpdateLabelInput = {};
   const color = parseLabelColor(options.color);
 
+  rejectContradictoryLabelFlags(options);
+
   if (options.name) {
     input.name = options.name;
   }
@@ -133,7 +236,20 @@ function buildUpdateInput(options: UpdateLabelOptions): UpdateLabelInput {
     input.description = options.description;
   }
 
-  if (Object.keys(input).length === 0) {
+  if (options.clearParent) {
+    input.parentId = null;
+  }
+
+  if (options.group) {
+    input.isGroup = true;
+  } else if (options.notGroup) {
+    input.isGroup = false;
+  }
+
+  // An empty --parent never reaches the mutation (the action only sets
+  // parentId when the value is truthy), so it must not satisfy this guard
+  // either — otherwise the update reports success having sent nothing.
+  if (Object.keys(input).length === 0 && !options.parent) {
     throw invalidParameterError(
       "label update",
       "at least one option must be provided",
@@ -148,10 +264,21 @@ export const LABELS_META: DomainMeta = {
   summary: "categorization tags for issues and projects",
   context: [
     "issue labels can exist at workspace level or be scoped to a specific",
-    "team. project labels are workspace-level only. use labels list to",
-    "inspect existing labels, labels create/read/update/delete for issue",
-    "labels, and issues/projects create/update --labels plus update",
-    "--label-mode remove or --clear-labels to apply or remove them.",
+    "team. project labels are workspace-level only, so --team and --scope",
+    "are rejected with --type project. every verb takes --type issue",
+    "(default) or --type project.",
+    "",
+    "retire is the reversible alternative to delete: a retired label stays",
+    "on whatever already carries it but cannot be applied to anything new.",
+    "restore undoes it.",
+    "",
+    "a label group (--group) contains child labels (--parent <group>); a",
+    "group is not itself applicable to issues or projects. update",
+    "--clear-parent lifts a label out of its group and --not-group turns a",
+    "group back into a plain label.",
+    "",
+    "use issues/projects create/update --labels plus update --label-mode",
+    "remove or --clear-labels to apply or remove labels.",
   ].join("\n"),
   arguments: { name: "label name or UUID" },
   seeAlso: [
@@ -159,6 +286,8 @@ export const LABELS_META: DomainMeta = {
     "labels read <label>",
     "labels update <label>",
     "labels delete <label>",
+    "labels retire <label>",
+    "labels restore <label>",
     "issues create --labels",
     "issues update --labels",
     "projects create --labels",
@@ -190,19 +319,7 @@ export function setupLabelsCommands(program: Command): void {
         });
 
         if (type === "project") {
-          if (options.team) {
-            throw invalidParameterError(
-              "--team",
-              "cannot be used with --type project because project labels are workspace-scoped",
-            );
-          }
-
-          if (scope) {
-            throw invalidParameterError(
-              "--scope",
-              "cannot be used with --type project because project labels are always workspace-scoped",
-            );
-          }
+          rejectTeamScopingForProjectLabels(options.team, scope);
 
           outputSuccess(await listProjectLabels(ctx.gql, pagination));
           return;
@@ -229,10 +346,13 @@ export function setupLabelsCommands(program: Command): void {
 
   labels
     .command("create <name>")
-    .description("create an issue label")
+    .description("create a label")
+    .option("--type <type>", "label type: issue (default) or project", "issue")
     .option("--team <team>", "create a team-scoped label (key, name, or UUID)")
     .option("--color <hex>", "label color as a hex code (for example #B45309)")
     .option("--description <text>", "label description")
+    .option("--parent <label>", "place the label inside this label group")
+    .option("--group", "create a label group rather than a label")
     .action(
       handleCommand(async (...args: unknown[]) => {
         const [name, options, command] = args as [
@@ -241,12 +361,21 @@ export function setupLabelsCommands(program: Command): void {
           Command,
         ];
         const ctx = createContext(getRootOpts(command));
+        const type = parseLabelType(options.type);
+
+        if (type === "project") {
+          rejectTeamScopingForProjectLabels(options.team, undefined);
+        }
 
         const input: CreateLabelInput = { name };
         const color = parseLabelColor(options.color);
 
-        if (options.team) {
-          input.teamId = await resolveTeamId(ctx.gql, options.team);
+        const teamId = options.team
+          ? await resolveTeamId(ctx.gql, options.team)
+          : undefined;
+
+        if (teamId) {
+          input.teamId = teamId;
         }
 
         if (color) {
@@ -257,13 +386,27 @@ export function setupLabelsCommands(program: Command): void {
           input.description = options.description;
         }
 
-        outputSuccess(await createLabel(ctx.gql, input));
+        if (options.parent) {
+          input.parentId = await resolveLabelParentId(
+            ctx.gql,
+            options.parent,
+            type,
+            omitUndefined({ teamId }),
+          );
+        }
+
+        if (options.group) {
+          input.isGroup = true;
+        }
+
+        outputSuccess(await createLabel(ctx.gql, input, type));
       }),
     );
 
   labels
     .command("read <label>")
-    .description("read an issue label")
+    .description("read a label")
+    .option("--type <type>", "label type: issue (default) or project", "issue")
     .option(
       "--team <team>",
       "resolve a team-scoped label by team (key, name, or UUID)",
@@ -276,19 +419,20 @@ export function setupLabelsCommands(program: Command): void {
           LabelLookupOptions,
           Command,
         ];
-        const { ctx, labelId } = await resolveIssueLabelLookup(
+        const { ctx, labelId, type } = await resolveLabelLookup(
           command,
           label,
           options,
         );
 
-        outputSuccess(await getLabel(ctx.gql, labelId));
+        outputSuccess(await getLabel(ctx.gql, labelId, type));
       }),
     );
 
   labels
     .command("update <label>")
-    .description("update an issue label")
+    .description("update a label")
+    .option("--type <type>", "label type: issue (default) or project", "issue")
     .option(
       "--team <team>",
       "resolve a team-scoped label by team (key, name, or UUID)",
@@ -297,6 +441,10 @@ export function setupLabelsCommands(program: Command): void {
     .option("--name <name>", "new label name")
     .option("--color <hex>", "new label color as a hex code")
     .option("--description <text>", "new label description")
+    .option("--parent <label>", "move the label into this label group")
+    .option("--clear-parent", "move the label out of its label group")
+    .option("--group", "turn the label into a label group")
+    .option("--not-group", "turn the label group back into a plain label")
     .action(
       handleCommand(async (...args: unknown[]) => {
         const [label, options, command] = args as [
@@ -305,19 +453,29 @@ export function setupLabelsCommands(program: Command): void {
           Command,
         ];
         const input = buildUpdateInput(options);
-        const { ctx, labelId } = await resolveIssueLabelLookup(
+        const { ctx, labelId, type, scoping } = await resolveLabelLookup(
           command,
           label,
           options,
         );
 
-        outputSuccess(await updateLabel(ctx.gql, labelId, input));
+        if (options.parent) {
+          input.parentId = await resolveLabelParentId(
+            ctx.gql,
+            options.parent,
+            type,
+            scoping,
+          );
+        }
+
+        outputSuccess(await updateLabel(ctx.gql, labelId, input, type));
       }),
     );
 
   labels
     .command("delete <label>")
-    .description("delete an issue label")
+    .description("delete a label")
+    .option("--type <type>", "label type: issue (default) or project", "issue")
     .option(
       "--team <team>",
       "resolve a team-scoped label by team (key, name, or UUID)",
@@ -330,16 +488,53 @@ export function setupLabelsCommands(program: Command): void {
           LabelLookupOptions,
           Command,
         ];
-        const { ctx, labelId } = await resolveIssueLabelLookup(
+        const { ctx, labelId, type } = await resolveLabelLookup(
           command,
           label,
           options,
         );
 
-        outputSuccess(await deleteLabel(ctx.gql, labelId));
+        outputSuccess(await deleteLabel(ctx.gql, labelId, type));
       }),
     );
 
+  for (const verb of ["retire", "restore"] as const) {
+    labels
+      .command(`${verb} <label>`)
+      .description(
+        verb === "retire"
+          ? "retire a label: keeps it where it is, blocks new uses"
+          : "restore a retired label so it can be applied again",
+      )
+      .option(
+        "--type <type>",
+        "label type: issue (default) or project",
+        "issue",
+      )
+      .option(
+        "--team <team>",
+        "resolve a team-scoped label by team (key, name, or UUID)",
+      )
+      .option("--scope <scope>", "resolve within workspace or team scope")
+      .action(
+        handleCommand(async (...args: unknown[]) => {
+          const [label, options, command] = args as [
+            string,
+            LabelLookupOptions,
+            Command,
+          ];
+          const { ctx, labelId, type } = await resolveLabelLookup(
+            command,
+            label,
+            options,
+          );
+
+          const apply = verb === "retire" ? retireLabel : restoreLabel;
+          outputSuccess(await apply(ctx.gql, labelId, type));
+        }),
+      );
+  }
+
   labels
     .command("usage")
     .description("show detailed usage for labels")
diff --git a/src/commands/projects.ts b/src/commands/projects/entity.ts
similarity index 79%
rename from src/commands/projects.ts
rename to src/commands/projects/entity.ts
index 23a53453..52e42c69 100644
--- a/src/commands/projects.ts
+++ b/src/commands/projects/entity.ts
@@ -1,19 +1,23 @@
 import type { Command } from "commander";
-import { createContext, getRootOpts } from "../common/context.js";
-import { type Priority, parseLabelMode } from "../common/domain-values.js";
-import { resolveReactionEmojiInput } from "../common/emoji.js";
-import { invalidParameterError } from "../common/errors.js";
-import { asUuid } from "../common/identifier.js";
-import { commandAction, outputSuccess, parseLimit } from "../common/output.js";
-import { buildPaginationOptions } from "../common/types.js";
-import { type DomainMeta, formatDomainUsage } from "../common/usage.js";
+import { createContext, getRootOpts } from "../../common/context.js";
+import { type Priority, parseLabelMode } from "../../common/domain-values.js";
+import { resolveReactionEmojiInput } from "../../common/emoji.js";
+import { invalidParameterError } from "../../common/errors.js";
+import { asUuid } from "../../common/identifier.js";
+import {
+  commandAction,
+  outputSuccess,
+  parseLimit,
+} from "../../common/output.js";
+import { buildPaginationOptions } from "../../common/types.js";
+import type { ExternalSyncService } from "../../gql/graphql.js";
 import {
   resolveProjectId,
   resolveProjectLabelIds,
-} from "../resolvers/project-resolver.js";
-import { resolveProjectStatusId } from "../resolvers/project-status-resolver.js";
-import { resolveTeamId } from "../resolvers/team-resolver.js";
-import { resolveUserId } from "../resolvers/user-resolver.js";
+} from "../../resolvers/project-resolver.js";
+import { resolveProjectStatusId } from "../../resolvers/project-status-resolver.js";
+import { resolveTeamId } from "../../resolvers/team-resolver.js";
+import { resolveUserId } from "../../resolvers/user-resolver.js";
 import {
   createDiscussionCommentReaction,
   deleteDiscussionComment,
@@ -30,19 +34,21 @@ import {
   resolveDiscussion,
   startProjectDiscussion,
   unresolveDiscussion,
-} from "../services/discussion-service.js";
+} from "../../services/discussion-service.js";
+import { getProjectActivity } from "../../services/project-activity-service.js";
 import {
-  archiveProject,
+  applyProjectLabels,
   type CreateProjectInput,
   createProject,
   deleteProject,
+  disableProjectExternalSync,
   getProject,
-  getProjectLabelIds,
   listProjects,
+  searchProjects,
   type UpdateProjectInput,
   unarchiveProject,
   updateProject,
-} from "../services/project-service.js";
+} from "../../services/project-service.js";
 
 interface ListOptions {
   limit: string;
@@ -55,6 +61,24 @@ interface ReadOptions {
   issuesFirst: string;
 }
 
+interface SearchOptions {
+  limit: string;
+  after?: string;
+  includeArchived?: boolean;
+  team?: string;
+}
+
+interface DisableSyncOptions {
+  source: string;
+}
+
+interface ActivityOptions {
+  limit: string;
+  after?: string;
+  commentsOnly?: boolean;
+  withReactions?: boolean;
+}
+
 interface DiscussionsOptions {
   limit?: string;
   after?: string;
@@ -174,26 +198,22 @@ interface UpdateOptions {
   clearLabels?: boolean;
 }
 
-export const PROJECTS_META: DomainMeta = {
-  name: "projects",
-  summary: "groups of issues toward a goal",
-  context: [
-    "a project collects related issues across teams. projects can have",
-    "milestones to track progress toward deadlines or phases. projects",
-    "have a status (backlog, planned, started, paused, completed,",
-    "canceled), priority (0-4), health (onTrack, atRisk, offTrack),",
-    "and can be assigned labels, a lead, and members.",
-  ].join("\n"),
-  arguments: {
-    project: "project identifier (UUID or name)",
-    name: "string",
-  },
-  seeAlso: [
-    "milestones list --project",
-    "documents list --project",
-    "issues create --project",
-  ],
-};
+const EXTERNAL_SYNC_SOURCES = [
+  "jira",
+  "github",
+  "slack",
+] as const satisfies readonly ExternalSyncService[];
+
+function parseExternalSyncSource(value: string): ExternalSyncService {
+  const match = EXTERNAL_SYNC_SOURCES.find((source) => source === value);
+  if (!match) {
+    throw invalidParameterError(
+      "--source",
+      `must be one of: ${EXTERNAL_SYNC_SOURCES.join(", ")}`,
+    );
+  }
+  return match;
+}
 
 function parsePriority(value: string): Priority {
   const priority = Number.parseInt(value, 10);
@@ -249,11 +269,7 @@ function getUpdateTeamNames(options: UpdateOptions): string[] | undefined {
   return parseCommaSeparatedOption(options.teams ? "--teams" : "--team", teams);
 }
 
-export function setupProjectsCommands(program: Command): void {
-  const projects = program
-    .command("projects")
-    .description("Project operations");
-
+export function setupProjectEntityCommands(projects: Command): void {
   projects
     .command("list")
     .description("list projects")
@@ -273,6 +289,39 @@ export function setupProjectsCommands(program: Command): void {
       }),
     );
 
+  projects
+    .command("search <query>")
+    .description("full-text search projects")
+    .addHelpText(
+      "after",
+      "\nResults are relevance-ordered by the API, so there is no sort\n" +
+        "option. This endpoint is rate-limited more tightly than\n" +
+        "`projects list` — prefer list when a filter would do.",
+    )
+    .option("-l, --limit <n>", "max results", "25")
+    .option("--after <cursor>", "cursor for next page")
+    .option("--include-archived", "include archived projects")
+    .option("--team <team>", "restrict to one team (key, name, or UUID)")
+    .action(
+      commandAction<[string, SearchOptions, Command]>(
+        async (query, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+
+          const teamId = options.team
+            ? await resolveTeamId(ctx.gql, options.team)
+            : undefined;
+
+          const result = await searchProjects(ctx.gql, query, {
+            ...buildPaginationOptions(parseLimit(options.limit), options.after),
+            includeArchived: options.includeArchived ?? false,
+            ...(teamId !== undefined ? { teamId } : {}),
+          });
+
+          outputSuccess(result);
+        },
+      ),
+    );
+
   projects
     .command("read <project>")
     .description("get full project details")
@@ -306,6 +355,39 @@ export function setupProjectsCommands(program: Command): void {
       ),
     );
 
+  projects
+    .command("activity <project>")
+    .description(
+      "chronological timeline: discussions, history events, status updates",
+    )
+    .addHelpText(
+      "after",
+      "\nHistory items carry Linear's opaque `entries` object verbatim.\n" +
+        "`ProjectHistory` has no typed from/to fields the way `IssueHistory`\n" +
+        "does, so this is not the normalized `changes[]` shape that\n" +
+        "`issues activity` returns.",
+    )
+    .option("-l, --limit <n>", "max timeline items", "50")
+    .option("--after <cursor>", "cursor for next page")
+    .option("--comments-only", "exclude history events and status updates")
+    .option("--with-reactions", "include normalized comment reactions")
+    .action(
+      commandAction<[string, ActivityOptions, Command]>(
+        async (project, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+
+          const projectId = await resolveProjectId(ctx.gql, project);
+          const result = await getProjectActivity(ctx.gql, projectId, {
+            ...buildPaginationOptions(parseLimit(options.limit), options.after),
+            commentsOnly: Boolean(options.commentsOnly),
+            withReactions: Boolean(options.withReactions),
+          });
+
+          outputSuccess(result);
+        },
+      ),
+    );
+
   projects
     .command("discuss <project>")
     .description("start a discussion thread on a project")
@@ -728,13 +810,7 @@ export function setupProjectsCommands(program: Command): void {
           }
 
           const labelMode = parseLabelMode(options.labelMode);
-
           const projectId = await resolveProjectId(ctx.gql, project);
-          const needsLabelContext =
-            options.labels && (labelMode === "add" || labelMode === "remove");
-          const currentLabelIds = needsLabelContext
-            ? await getProjectLabelIds(ctx.gql, projectId)
-            : [];
 
           const input: UpdateProjectInput = {};
 
@@ -804,48 +880,70 @@ export function setupProjectsCommands(program: Command): void {
             );
           }
 
+          // `add`/`remove` go through the incremental mutations; only
+          // `overwrite` and `--clear-labels` touch the full-replacement
+          // `labelIds` input, which is the only path that can drop a label
+          // it never read.
+          const incrementalLabelIds =
+            options.labels && (labelMode === "add" || labelMode === "remove")
+              ? await resolveProjectLabelIds(
+                  ctx.gql,
+                  parseCommaSeparatedOption("--labels", options.labels),
+                )
+              : undefined;
+
           if (options.clearLabels) {
             input.labelIds = [];
-          } else if (options.labels) {
-            const labelNames = options.labels
-              .split(",")
-              .map((l) => l.trim())
-              .filter(Boolean);
-            const labelIds = await resolveProjectLabelIds(ctx.gql, labelNames);
-
-            if (labelMode === "add") {
-              input.labelIds = [...new Set([...currentLabelIds, ...labelIds])];
-            } else if (labelMode === "remove") {
-              input.labelIds = currentLabelIds.filter(
-                (id) => !labelIds.includes(id),
-              );
-            } else {
-              input.labelIds = labelIds;
-            }
+          } else if (options.labels && !incrementalLabelIds) {
+            input.labelIds = await resolveProjectLabelIds(
+              ctx.gql,
+              parseCommaSeparatedOption("--labels", options.labels),
+            );
           }
 
-          if (Object.keys(input).length === 0) {
+          const hasFieldUpdates = Object.keys(input).length > 0;
+
+          if (!hasFieldUpdates && !incrementalLabelIds) {
             throw invalidParameterError(
               "update options",
               "at least one option must be provided",
             );
           }
 
-          const result = await updateProject(ctx.gql, projectId, input);
-          outputSuccess(result);
+          const updated = hasFieldUpdates
+            ? await updateProject(ctx.gql, projectId, input)
+            : undefined;
+
+          // Labels last, so the emitted project reflects every change made.
+          outputSuccess(
+            incrementalLabelIds
+              ? await applyProjectLabels(
+                  ctx.gql,
+                  projectId,
+                  incrementalLabelIds,
+                  labelMode === "add" ? "add" : "remove",
+                )
+              : updated,
+          );
         },
       ),
     );
 
   projects
-    .command("archive <project>")
-    .description("archive a project")
+    .command("disable-sync <project>")
+    .description("stop syncing a project with an external tracker")
+    .requiredOption("--source <source>", EXTERNAL_SYNC_SOURCES.join(" | "))
     .action(
-      commandAction<[string, unknown, Command]>(
-        async (project, _unused1, command) => {
+      commandAction<[string, DisableSyncOptions, Command]>(
+        async (project, options, command) => {
           const ctx = createContext(getRootOpts(command));
+          const source = parseExternalSyncSource(options.source);
           const projectId = await resolveProjectId(ctx.gql, project);
-          const result = await archiveProject(ctx.gql, projectId);
+          const result = await disableProjectExternalSync(
+            ctx.gql,
+            projectId,
+            source,
+          );
           outputSuccess(result);
         },
       ),
@@ -853,7 +951,7 @@ export function setupProjectsCommands(program: Command): void {
 
   projects
     .command("unarchive <project>")
-    .description("unarchive a project")
+    .description("restore a project from the trash")
     .action(
       commandAction<[string, unknown, Command]>(
         async (project, _unused1, command) => {
@@ -869,7 +967,7 @@ export function setupProjectsCommands(program: Command): void {
 
   projects
     .command("delete <project>")
-    .description("delete a project")
+    .description("move a project to the trash (restore with unarchive)")
     .action(
       commandAction<[string, unknown, Command]>(
         async (project, _unused1, command) => {
@@ -882,11 +980,4 @@ export function setupProjectsCommands(program: Command): void {
         },
       ),
     );
-
-  projects
-    .command("usage")
-    .description("show detailed usage for projects")
-    .action(() => {
-      console.log(formatDomainUsage(projects, PROJECTS_META));
-    });
 }
diff --git a/src/commands/projects/index.ts b/src/commands/projects/index.ts
new file mode 100644
index 00000000..997b2c5a
--- /dev/null
+++ b/src/commands/projects/index.ts
@@ -0,0 +1,71 @@
+import type { Command } from "commander";
+import { type DomainMeta, formatDomainUsage } from "../../common/usage.js";
+import { setupProjectEntityCommands } from "./entity.js";
+import { setupProjectRelationCommands } from "./relations.js";
+import { setupProjectStatusCommands } from "./statuses.js";
+import { setupProjectUpdateCommands } from "./updates.js";
+
+export const PROJECTS_META: DomainMeta = {
+  name: "projects",
+  summary: "groups of issues toward a goal",
+  context: [
+    "a project collects related issues across teams. projects can have",
+    "milestones to track progress toward deadlines or phases. projects",
+    "have a status (backlog, planned, started, paused, completed,",
+    "canceled), priority (0-4), health (onTrack, atRisk, offTrack),",
+    "and can be assigned labels, a lead, and members.",
+    "",
+    "projects have one put-away state, not two: `delete` trashes a project",
+    "and `unarchive` restores it. there is no `archive` verb.",
+    "",
+    "a project's health is derived from its most recent status update, so",
+    "changing health means posting one with `projects updates create`.",
+    "",
+    "project statuses are workspace-scoped, not per-team: `projects",
+    "statuses` administers the one ordered flow every project draws from.",
+    "",
+    "project labels are managed under `labels --type project`, not here.",
+    "`projects create/update --labels` applies existing ones by name.",
+    "",
+    "`projects activity` shares the envelope and flags of `issues activity`",
+    "but not the item shape: Linear's ProjectHistory carries one opaque",
+    "`entries` object instead of typed from/to fields, so history items are",
+    "passed through verbatim rather than normalized into `changes[]`.",
+    "",
+    "project relations are scheduling dependencies, not issue-style link",
+    "types: each end anchors to a project's start or end (or to one of its",
+    'milestones). `--from end --to start` is the default and means "this',
+    'must finish before that starts".',
+  ].join("\n"),
+  arguments: {
+    project: "project identifier (UUID or name)",
+    update: "project status update identifier (UUID)",
+    status: "project status identifier (UUID or name)",
+    relation: "project relation UUID, or a project when --blocks is given",
+    name: "string",
+  },
+  seeAlso: [
+    "labels list --type project",
+    "milestones list --project",
+    "documents list --project",
+    "issues create --project",
+  ],
+};
+
+export function setupProjectsCommands(program: Command): void {
+  const projects = program
+    .command("projects")
+    .description("Project operations");
+
+  setupProjectEntityCommands(projects);
+  setupProjectUpdateCommands(projects);
+  setupProjectStatusCommands(projects);
+  setupProjectRelationCommands(projects);
+
+  projects
+    .command("usage")
+    .description("show detailed usage for projects")
+    .action(() => {
+      console.log(formatDomainUsage(projects, PROJECTS_META));
+    });
+}
diff --git a/src/commands/projects/relations.ts b/src/commands/projects/relations.ts
new file mode 100644
index 00000000..e422d7c9
--- /dev/null
+++ b/src/commands/projects/relations.ts
@@ -0,0 +1,469 @@
+import type { Command } from "commander";
+import { createContext, getRootOpts } from "../../common/context.js";
+import { invalidParameterError } from "../../common/errors.js";
+import { asUuid, type UUID } from "../../common/identifier.js";
+import {
+  commandAction,
+  outputSuccess,
+  parseLimit,
+} from "../../common/output.js";
+import { buildPaginationOptions } from "../../common/types.js";
+import { resolveMilestoneId } from "../../resolvers/milestone-resolver.js";
+import { resolveProjectRelation } from "../../resolvers/project-relation-resolver.js";
+import { resolveProjectId } from "../../resolvers/project-resolver.js";
+import {
+  type CreateProjectRelationInput,
+  createProjectRelation,
+  deleteProjectRelation,
+  getProjectRelation,
+  listAllProjectRelations,
+  listProjectRelations,
+  PROJECT_RELATION_ANCHORS,
+  type ProjectRelationAnchor,
+  type UpdateProjectRelationInput,
+  updateProjectRelation,
+} from "../../services/project-relation-service.js";
+
+const ANCHOR_HELP =
+  "\nA project relation joins a point on one project to a point on another.\n" +
+  'The default, `--from end --to start`, reads as "this project must\n' +
+  "finish before that one starts\" — the shape Linear's UI creates.\n" +
+  "\n" +
+  "`--from-milestone`/`--to-milestone` anchor an end at a specific\n" +
+  "milestone instead of the project's own start or end date.\n" +
+  "\n" +
+  "Linear declares the relation type and both anchors as plain strings\n" +
+  "with no enum, so `start` and `end` are validated here against the\n" +
+  "values the live API is known to use.";
+
+interface RelationAddOptions {
+  blocks: string;
+  from?: string;
+  to?: string;
+  fromMilestone?: string;
+  toMilestone?: string;
+}
+
+interface RelationUpdateOptions {
+  blocks?: string;
+  from?: string;
+  to?: string;
+  fromMilestone?: string;
+  toMilestone?: string;
+  clearFromMilestone?: boolean;
+  clearToMilestone?: boolean;
+}
+
+interface RelationRemoveOptions {
+  blocks?: string;
+}
+
+interface RelationListOptions {
+  limit?: string;
+  after?: string;
+}
+
+const DEFAULT_LIMIT = "50";
+
+/**
+ * `relations list <project>` reads both directions of one project in a single
+ * query capped at a fixed page size each and reports `truncated` rather than
+ * a cursor (see `PROJECT_RELATION_PAGE_SIZE`), so `-l`/`--after` have nothing
+ * to act on. Accepting them silently would answer a different question than
+ * the one asked.
+ */
+function rejectPaginationForProject(
+  command: Command,
+  options: RelationListOptions,
+): void {
+  if (command.getOptionValueSource("limit") === "cli") {
+    throw invalidParameterError(
+      "--limit",
+      "cannot be used with a project: both directions are returned in full, with `truncated` set when the API caps them",
+    );
+  }
+
+  if (options.after !== undefined) {
+    throw invalidParameterError(
+      "--after",
+      "cannot be used with a project: the per-project query is not cursor-paginated",
+    );
+  }
+}
+
+function parseAnchor(flag: string, value: string): ProjectRelationAnchor {
+  const match = PROJECT_RELATION_ANCHORS.find((anchor) => anchor === value);
+  if (!match) {
+    throw invalidParameterError(
+      flag,
+      `must be one of: ${PROJECT_RELATION_ANCHORS.join(", ")}`,
+    );
+  }
+  return match;
+}
+
+function rejectContradictoryMilestoneFlags(
+  options: RelationUpdateOptions,
+): void {
+  if (options.fromMilestone && options.clearFromMilestone) {
+    throw invalidParameterError(
+      "--from-milestone",
+      "cannot be combined with --clear-from-milestone",
+    );
+  }
+
+  if (options.toMilestone && options.clearToMilestone) {
+    throw invalidParameterError(
+      "--to-milestone",
+      "cannot be combined with --clear-to-milestone",
+    );
+  }
+}
+
+export function setupProjectRelationCommands(projects: Command): void {
+  const relations = projects
+    .command("relations")
+    .description("project dependency operations")
+    .addHelpText("after", ANCHOR_HELP);
+
+  relations
+    .command("list [project]")
+    .description("list dependencies for a project, or across the workspace")
+    .addHelpText(
+      "after",
+      "\nWith a project, both directions are returned separately.\n" +
+        "Without one, the workspace-wide connection is paged instead — it\n" +
+        "takes no filter, so -l/--after are the only knobs it has.",
+    )
+    .option(
+      "-l, --limit <n>",
+      "max results (workspace-wide only)",
+      DEFAULT_LIMIT,
+    )
+    .option("--after <cursor>", "cursor for next page (workspace-wide only)")
+    .action(
+      commandAction<[string | undefined, RelationListOptions, Command]>(
+        async (project, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+
+          if (project === undefined) {
+            outputSuccess(
+              await listAllProjectRelations(
+                ctx.gql,
+                buildPaginationOptions(
+                  parseLimit(options.limit ?? DEFAULT_LIMIT),
+                  options.after,
+                ),
+              ),
+            );
+            return;
+          }
+
+          rejectPaginationForProject(command, options);
+
+          const projectId = await resolveProjectId(ctx.gql, project);
+          outputSuccess(await listProjectRelations(ctx.gql, projectId));
+        },
+      ),
+    );
+
+  relations
+    .command("read <relation>")
+    .description("read one dependency by UUID")
+    .action(
+      commandAction<[string, unknown, Command]>(
+        async (relation, _unused1, command) => {
+          const ctx = createContext(getRootOpts(command));
+          const { id } = await resolveProjectRelation(ctx.gql, relation);
+          outputSuccess(await getProjectRelation(ctx.gql, id));
+        },
+      ),
+    );
+
+  relations
+    .command("add <project>")
+    .description("make a project a dependency of another")
+    .addHelpText("after", ANCHOR_HELP)
+    .requiredOption("--blocks <project>", "the dependent project")
+    .option("--from <anchor>", "start | end of <project>", "end")
+    .option("--to <anchor>", "start | end of the dependent project", "start")
+    .option("--from-milestone <milestone>", "anchor this end at a milestone")
+    .option("--to-milestone <milestone>", "anchor the far end at a milestone")
+    .action(
+      commandAction<[string, RelationAddOptions, Command]>(
+        async (project, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+
+          const anchorType = parseAnchor("--from", options.from ?? "end");
+          const relatedAnchorType = parseAnchor("--to", options.to ?? "start");
+
+          const [projectId, relatedProjectId] = await Promise.all([
+            resolveProjectId(ctx.gql, project),
+            resolveProjectId(ctx.gql, options.blocks),
+          ]);
+
+          if (projectId === relatedProjectId) {
+            throw invalidParameterError(
+              "--blocks",
+              "a project cannot depend on itself",
+            );
+          }
+
+          const input: CreateProjectRelationInput = {
+            projectId,
+            relatedProjectId,
+            anchorType,
+            relatedAnchorType,
+          };
+
+          if (options.fromMilestone) {
+            input.projectMilestoneId = await resolveMilestoneId(
+              ctx.gql,
+              options.fromMilestone,
+              projectId,
+            );
+          }
+
+          if (options.toMilestone) {
+            input.relatedProjectMilestoneId = await resolveMilestoneId(
+              ctx.gql,
+              options.toMilestone,
+              relatedProjectId,
+            );
+          }
+
+          outputSuccess(await createProjectRelation(ctx.gql, input));
+        },
+      ),
+    );
+
+  relations
+    .command("update <relation>")
+    .description("re-anchor an existing dependency")
+    .addHelpText("after", ANCHOR_HELP)
+    .option(
+      "--blocks <project>",
+      "treat <relation> as a project and find its relation to this one",
+    )
+    .option("--from <anchor>", "start | end")
+    .option("--to <anchor>", "start | end")
+    .option("--from-milestone <milestone>", "anchor this end at a milestone")
+    .option("--clear-from-milestone", "anchor this end at the project again")
+    .option("--to-milestone <milestone>", "anchor the far end at a milestone")
+    .option("--clear-to-milestone", "anchor the far end at the project again")
+    .action(
+      commandAction<[string, RelationUpdateOptions, Command]>(
+        async (relation, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+
+          rejectContradictoryMilestoneFlags(options);
+
+          const ends: RelationEnds = {};
+
+          if (options.from !== undefined) {
+            ends.from = parseAnchor("--from", options.from);
+          }
+
+          if (options.to !== undefined) {
+            ends.to = parseAnchor("--to", options.to);
+          }
+
+          if (options.clearFromMilestone) {
+            ends.fromMilestoneId = null;
+          }
+
+          if (options.clearToMilestone) {
+            ends.toMilestoneId = null;
+          }
+
+          // Before resolving: an empty update otherwise spends two project
+          // lookups and a relation query only to be rejected, and on the UUID
+          // path the caller is told the relation was not found rather than
+          // what they actually left out.
+          if (
+            Object.keys(ends).length === 0 &&
+            !options.fromMilestone &&
+            !options.toMilestone
+          ) {
+            throw invalidParameterError(
+              "update options",
+              "at least one option must be provided",
+            );
+          }
+
+          const resolved = await resolveRelation(ctx, relation, options.blocks);
+
+          if (options.fromMilestone || options.toMilestone) {
+            const { projectId, relatedProjectId } = await relationEnds(
+              ctx,
+              resolved,
+            );
+
+            if (options.fromMilestone) {
+              ends.fromMilestoneId = await resolveMilestoneId(
+                ctx.gql,
+                options.fromMilestone,
+                projectId,
+              );
+            }
+
+            if (options.toMilestone) {
+              ends.toMilestoneId = await resolveMilestoneId(
+                ctx.gql,
+                options.toMilestone,
+                relatedProjectId,
+              );
+            }
+          }
+
+          outputSuccess(
+            await updateProjectRelation(
+              ctx.gql,
+              resolved.relationId,
+              orientToRelation(ends, resolved.inverted),
+            ),
+          );
+        },
+      ),
+    );
+
+  relations
+    .command("remove <relation>")
+    .description("remove a dependency")
+    .option(
+      "--blocks <project>",
+      "treat <relation> as a project and find its relation to this one",
+    )
+    .action(
+      commandAction<[string, RelationRemoveOptions, Command]>(
+        async (relation, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+          const { relationId } = await resolveRelation(
+            ctx,
+            relation,
+            options.blocks,
+          );
+          outputSuccess(await deleteProjectRelation(ctx.gql, relationId));
+        },
+      ),
+    );
+}
+
+/**
+ * The two ends of a relation as the caller named them: `from` is the project
+ * given as the argument, `to` is the one given as `--blocks`.
+ */
+interface RelationEnds {
+  from?: ProjectRelationAnchor;
+  to?: ProjectRelationAnchor;
+  fromMilestoneId?: UUID | null;
+  toMilestoneId?: UUID | null;
+}
+
+/**
+ * Turn caller-oriented ends into the mutation's relation-oriented fields.
+ *
+ * `anchorType`/`projectMilestoneId` belong to the relation's own `project`,
+ * which is not necessarily the project the caller named first: a relation
+ * found through `inverseRelations` is stored the other way round. Writing the
+ * flags through unswapped would silently re-anchor the wrong project.
+ */
+function orientToRelation(
+  ends: RelationEnds,
+  inverted: boolean,
+): UpdateProjectRelationInput {
+  const [ownAnchor, farAnchor] = inverted
+    ? [ends.to, ends.from]
+    : [ends.from, ends.to];
+  const [ownMilestoneId, farMilestoneId] = inverted
+    ? [ends.toMilestoneId, ends.fromMilestoneId]
+    : [ends.fromMilestoneId, ends.toMilestoneId];
+
+  const input: UpdateProjectRelationInput = {};
+
+  if (ownAnchor !== undefined) input.anchorType = ownAnchor;
+  if (farAnchor !== undefined) input.relatedAnchorType = farAnchor;
+  if (ownMilestoneId !== undefined) input.projectMilestoneId = ownMilestoneId;
+  if (farMilestoneId !== undefined) {
+    input.relatedProjectMilestoneId = farMilestoneId;
+  }
+
+  return input;
+}
+
+interface ResolvedRelation {
+  relationId: UUID;
+  inverted: boolean;
+  /** The caller's near end — absent when the relation was named by UUID. */
+  projectId?: UUID;
+  /** The caller's far end — absent when the relation was named by UUID. */
+  relatedProjectId?: UUID;
+}
+
+/**
+ * The two projects a relation joins, in the caller's orientation.
+ *
+ * A milestone must be looked up inside the project that owns its end, or a
+ * common name like "Launch" resolves to whichever project's milestone the
+ * workspace-wide search happens to hit first. The pair path already knows both
+ * IDs. The UUID path reads them off the relation instead, which costs one
+ * request but only when a milestone flag was actually given — and because that
+ * path reports `inverted: false`, the relation's own `project` is the near end.
+ */
+async function relationEnds(
+  ctx: ReturnType<typeof createContext>,
+  resolved: ResolvedRelation,
+): Promise<{ projectId: UUID; relatedProjectId: UUID }> {
+  const { projectId, relatedProjectId } = resolved;
+  if (projectId !== undefined && relatedProjectId !== undefined) {
+    return { projectId, relatedProjectId };
+  }
+
+  const relation = await getProjectRelation(ctx.gql, resolved.relationId);
+  return {
+    projectId: asUuid(relation.project.id),
+    relatedProjectId: asUuid(relation.relatedProject.id),
+  };
+}
+
+/**
+ * Accepts either a relation UUID or a project pair.
+ *
+ * Relation IDs appear nowhere but `relations list`, so requiring one would
+ * make every edit a two-step operation. `--blocks` lets callers name the
+ * relation the same way they created it.
+ *
+ * The milestone flags must be scoped to the right project, so the endpoint IDs
+ * come back too, alongside `inverted` — the relation may be stored with the
+ * endpoints the other way round. On the UUID path neither is known yet:
+ * {@link relationEnds} reads them back off the relation, and there is nothing
+ * to invert because the caller named no ends to invert against.
+ */
+async function resolveRelation(
+  ctx: ReturnType<typeof createContext>,
+  relation: string,
+  blocks: string | undefined,
+): Promise<ResolvedRelation> {
+  if (blocks === undefined) {
+    const resolved = await resolveProjectRelation(ctx.gql, relation);
+    return { relationId: resolved.id, inverted: resolved.inverted };
+  }
+
+  const [projectId, relatedProjectId] = await Promise.all([
+    resolveProjectId(ctx.gql, relation),
+    resolveProjectId(ctx.gql, blocks),
+  ]);
+
+  const resolved = await resolveProjectRelation(
+    ctx.gql,
+    projectId,
+    relatedProjectId,
+  );
+
+  return {
+    relationId: resolved.id,
+    inverted: resolved.inverted,
+    projectId,
+    relatedProjectId,
+  };
+}
diff --git a/src/commands/projects/statuses.ts b/src/commands/projects/statuses.ts
new file mode 100644
index 00000000..252114da
--- /dev/null
+++ b/src/commands/projects/statuses.ts
@@ -0,0 +1,315 @@
+import type { Command } from "commander";
+import { createContext, getRootOpts } from "../../common/context.js";
+import { invalidParameterError } from "../../common/errors.js";
+import type { UUID } from "../../common/identifier.js";
+import { commandAction, outputSuccess } from "../../common/output.js";
+import type { ProjectStatusType } from "../../gql/graphql.js";
+import { resolveProjectStatusId } from "../../resolvers/project-status-resolver.js";
+import {
+  type ArchivedProjectStatus,
+  archiveProjectStatus,
+  type CreateProjectStatusInput,
+  createProjectStatus,
+  getProjectStatus,
+  listProjectStatuses,
+  reassignProjectStatus,
+  type UpdateProjectStatusInput,
+  unarchiveProjectStatus,
+  updateProjectStatus,
+} from "../../services/project-status-service.js";
+
+const STATUS_TYPES = [
+  "backlog",
+  "planned",
+  "started",
+  "paused",
+  "completed",
+  "canceled",
+] as const satisfies readonly ProjectStatusType[];
+
+interface StatusesListOptions {
+  includeArchived?: boolean;
+}
+
+// `--type` and `--color` are requiredOption, so commander guarantees them.
+interface StatusesCreateOptions {
+  type: string;
+  color: string;
+  description?: string;
+  position?: string;
+  indefinite?: boolean;
+}
+
+interface StatusesUpdateOptions {
+  name?: string;
+  type?: string;
+  color?: string;
+  description?: string;
+  position?: string;
+  indefinite?: boolean;
+  notIndefinite?: boolean;
+}
+
+interface StatusesArchiveOptions {
+  reassignTo?: string;
+}
+
+function parseStatusType(value: string): ProjectStatusType {
+  const match = STATUS_TYPES.find((type) => type === value);
+  if (!match) {
+    throw invalidParameterError(
+      "--type",
+      `must be one of: ${STATUS_TYPES.join(", ")}`,
+    );
+  }
+  return match;
+}
+
+function parsePosition(value: string): number {
+  // Number.parseFloat stops at the first non-numeric character, so "1O" would
+  // silently become position 1. Match the whole string before converting.
+  if (!/^-?\d+(\.\d+)?$/.test(value)) {
+    throw invalidParameterError("--position", "must be a number");
+  }
+  return Number.parseFloat(value);
+}
+
+/**
+ * Archives a status whose projects have just been moved elsewhere.
+ *
+ * The reassignment is already committed by the time the archive runs, and
+ * Linear offers no transaction to tie the two together — it will still refuse
+ * to archive, for instance, the last status of a type. Rolling the projects
+ * back would be a second guess at what the caller wanted, so the error says
+ * plainly where they ended up instead of leaving the caller to discover it.
+ */
+async function archiveAfterReassign(
+  ctx: ReturnType<typeof createContext>,
+  statusId: UUID,
+  reassignTo: string,
+): Promise<ArchivedProjectStatus> {
+  try {
+    return await archiveProjectStatus(ctx.gql, statusId);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+
+    throw new Error(
+      `${reason} — projects were already moved to "${reassignTo}" and were not moved back`,
+    );
+  }
+}
+
+export function setupProjectStatusCommands(projects: Command): void {
+  const statuses = projects
+    .command("statuses")
+    .description("workspace project status flow operations")
+    .addHelpText(
+      "after",
+      "\nProject statuses are workspace-scoped, not per-team: every project\n" +
+        "in the workspace draws its status from this one ordered list.",
+    );
+
+  statuses
+    .command("list")
+    .description("list the workspace project statuses")
+    .option("--include-archived", "include archived statuses")
+    .addHelpText(
+      "after",
+      "\nThe flow is read in one page of 250, with `truncated` set when the\n" +
+        "workspace holds more than that.",
+    )
+    .action(
+      commandAction<[StatusesListOptions, Command]>(
+        async (options, command) => {
+          const ctx = createContext(getRootOpts(command));
+          const result = await listProjectStatuses(
+            ctx.gql,
+            options.includeArchived ?? false,
+          );
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  statuses
+    .command("read <status>")
+    .description("get a project status with its project count")
+    .action(
+      commandAction<[string, unknown, Command]>(
+        async (status, _unused1, command) => {
+          const ctx = createContext(getRootOpts(command));
+          const statusId = await resolveProjectStatusId(ctx.gql, status, {
+            includeArchived: true,
+          });
+          const result = await getProjectStatus(ctx.gql, statusId);
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  statuses
+    .command("create <name>")
+    .description("create a project status")
+    .requiredOption("--type <type>", STATUS_TYPES.join(" | "))
+    .requiredOption("--color <hex>", "status color as a hex string")
+    .option("--description <text>", "status description")
+    .option("--position <n>", "position in the flow; default is last")
+    .option("--indefinite", "projects may stay in this status indefinitely")
+    .action(
+      commandAction<[string, StatusesCreateOptions, Command]>(
+        async (name, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+
+          const input: CreateProjectStatusInput = {
+            name,
+            type: parseStatusType(options.type),
+            color: options.color,
+          };
+
+          if (options.description !== undefined) {
+            input.description = options.description;
+          }
+
+          if (options.position !== undefined) {
+            input.position = parsePosition(options.position);
+          }
+
+          if (options.indefinite) {
+            input.indefinite = true;
+          }
+
+          const result = await createProjectStatus(ctx.gql, input);
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  statuses
+    .command("update <status>")
+    .description("update a project status")
+    .option("--name <name>", "new name")
+    .option("--type <type>", STATUS_TYPES.join(" | "))
+    .option("--color <hex>", "new color as a hex string")
+    .option("--description <text>", "new description")
+    .option("--position <n>", "new position in the flow")
+    .option("--indefinite", "projects may stay in this status indefinitely")
+    .option("--not-indefinite", "projects may not stay in this status forever")
+    .action(
+      commandAction<[string, StatusesUpdateOptions, Command]>(
+        async (status, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+
+          const input: UpdateProjectStatusInput = {};
+
+          if (options.name !== undefined) {
+            input.name = options.name;
+          }
+
+          if (options.type !== undefined) {
+            input.type = parseStatusType(options.type);
+          }
+
+          if (options.color !== undefined) {
+            input.color = options.color;
+          }
+
+          if (options.description !== undefined) {
+            input.description = options.description;
+          }
+
+          if (options.position !== undefined) {
+            input.position = parsePosition(options.position);
+          }
+
+          if (options.indefinite && options.notIndefinite) {
+            throw invalidParameterError(
+              "--indefinite",
+              "cannot be combined with --not-indefinite",
+            );
+          }
+
+          if (options.indefinite) {
+            input.indefinite = true;
+          } else if (options.notIndefinite) {
+            input.indefinite = false;
+          }
+
+          if (Object.keys(input).length === 0) {
+            throw invalidParameterError(
+              "update options",
+              "at least one option must be provided",
+            );
+          }
+
+          const statusId = await resolveProjectStatusId(ctx.gql, status, {
+            includeArchived: true,
+          });
+          const result = await updateProjectStatus(ctx.gql, statusId, input);
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  statuses
+    .command("archive <status>")
+    .description("archive a project status")
+    .addHelpText(
+      "after",
+      "\nLinear refuses to archive a status that still has projects in it.\n" +
+        "--reassign-to moves them first, which is the only way to make that\n" +
+        "failure recoverable in one step.",
+    )
+    .option(
+      "--reassign-to <status>",
+      "move projects onto this status before archiving",
+    )
+    .action(
+      commandAction<[string, StatusesArchiveOptions, Command]>(
+        async (status, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+
+          const statusId = await resolveProjectStatusId(ctx.gql, status);
+
+          if (options.reassignTo !== undefined) {
+            const newStatusId = await resolveProjectStatusId(
+              ctx.gql,
+              options.reassignTo,
+            );
+
+            if (newStatusId === statusId) {
+              throw invalidParameterError(
+                "--reassign-to",
+                "must name a different status than the one being archived",
+              );
+            }
+
+            await reassignProjectStatus(ctx.gql, statusId, newStatusId);
+
+            outputSuccess(
+              await archiveAfterReassign(ctx, statusId, options.reassignTo),
+            );
+            return;
+          }
+
+          const result = await archiveProjectStatus(ctx.gql, statusId);
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  statuses
+    .command("unarchive <status>")
+    .description("unarchive a project status")
+    .action(
+      commandAction<[string, unknown, Command]>(
+        async (status, _unused1, command) => {
+          const ctx = createContext(getRootOpts(command));
+          const statusId = await resolveProjectStatusId(ctx.gql, status, {
+            includeArchived: true,
+          });
+          const result = await unarchiveProjectStatus(ctx.gql, statusId);
+          outputSuccess(result);
+        },
+      ),
+    );
+}
diff --git a/src/commands/projects/updates.ts b/src/commands/projects/updates.ts
new file mode 100644
index 00000000..305e3699
--- /dev/null
+++ b/src/commands/projects/updates.ts
@@ -0,0 +1,215 @@
+import type { Command } from "commander";
+import { createContext, getRootOpts } from "../../common/context.js";
+import { parseHealth } from "../../common/domain-values.js";
+import { invalidParameterError } from "../../common/errors.js";
+import { asUuid } from "../../common/identifier.js";
+import {
+  commandAction,
+  outputSuccess,
+  parseLimit,
+} from "../../common/output.js";
+import { buildPaginationOptions } from "../../common/types.js";
+import { resolveProjectId } from "../../resolvers/project-resolver.js";
+import { resolveUserId } from "../../resolvers/user-resolver.js";
+import {
+  archiveProjectUpdate,
+  type CreateProjectUpdateInput,
+  createProjectUpdate,
+  type EditProjectUpdateInput,
+  editProjectUpdate,
+  getProjectUpdate,
+  listProjectUpdates,
+  remindProjectUpdate,
+  unarchiveProjectUpdate,
+} from "../../services/project-update-service.js";
+
+interface ProjectUpdatesListOptions {
+  project: string;
+  limit: string;
+  after?: string;
+  includeArchived?: boolean;
+}
+
+interface ProjectUpdatesCreateOptions {
+  project: string;
+  body?: string;
+  health?: string;
+  hideDiff?: boolean;
+}
+
+interface ProjectUpdatesUpdateOptions {
+  body?: string;
+  health?: string;
+}
+
+interface ProjectUpdatesRemindOptions {
+  project: string;
+  user?: string;
+}
+
+export function setupProjectUpdateCommands(projects: Command): void {
+  const updates = projects
+    .command("updates")
+    .description("project status update operations");
+
+  updates
+    .command("list")
+    .description("list project status updates")
+    .requiredOption("--project <project>", "project name or UUID")
+    .option("-l, --limit <n>", "max results", "50")
+    .option("--after <cursor>", "cursor for next page")
+    .option("--include-archived", "include archived updates")
+    .action(
+      commandAction<[ProjectUpdatesListOptions, Command]>(
+        async (options, command) => {
+          const ctx = createContext(getRootOpts(command));
+
+          const projectId = await resolveProjectId(ctx.gql, options.project);
+
+          const result = await listProjectUpdates(ctx.gql, {
+            projectId,
+            ...buildPaginationOptions(parseLimit(options.limit), options.after),
+            includeArchived: options.includeArchived ?? false,
+          });
+
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  updates
+    .command("read <update>")
+    .description("get project status update details")
+    .action(
+      commandAction<[string, unknown, Command]>(
+        async (updateId, _unused1, command) => {
+          const ctx = createContext(getRootOpts(command));
+          const result = await getProjectUpdate(ctx.gql, asUuid(updateId));
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  updates
+    .command("create")
+    .description("post a project status update")
+    .requiredOption("--project <project>", "project name or UUID")
+    .option("--body <text>", "update body (markdown)")
+    .option("--health <health>", "onTrack, atRisk, offTrack")
+    .option("--hide-diff", "hide the diff against the previous update")
+    .action(
+      commandAction<[ProjectUpdatesCreateOptions, Command]>(
+        async (options, command) => {
+          const ctx = createContext(getRootOpts(command));
+
+          const projectId = await resolveProjectId(ctx.gql, options.project);
+
+          const input: CreateProjectUpdateInput = { projectId };
+
+          if (options.body !== undefined) {
+            input.body = options.body;
+          }
+
+          const health = parseHealth(options.health);
+          if (health) {
+            input.health = health;
+          }
+
+          if (options.hideDiff) {
+            input.isDiffHidden = true;
+          }
+
+          const result = await createProjectUpdate(ctx.gql, input);
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  updates
+    .command("update <update>")
+    .description("edit a project status update")
+    .option("--body <text>", "new body (markdown)")
+    .option("--health <health>", "onTrack, atRisk, offTrack")
+    .action(
+      commandAction<[string, ProjectUpdatesUpdateOptions, Command]>(
+        async (updateId, options, command) => {
+          const ctx = createContext(getRootOpts(command));
+
+          const input: EditProjectUpdateInput = {};
+
+          if (options.body !== undefined) {
+            input.body = options.body;
+          }
+
+          const health = parseHealth(options.health);
+          if (health) {
+            input.health = health;
+          }
+
+          if (Object.keys(input).length === 0) {
+            throw invalidParameterError(
+              "update options",
+              "at least one option must be provided",
+            );
+          }
+
+          const result = await editProjectUpdate(
+            ctx.gql,
+            asUuid(updateId),
+            input,
+          );
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  updates
+    .command("archive <update>")
+    .description("archive a project status update")
+    .action(
+      commandAction<[string, unknown, Command]>(
+        async (updateId, _unused1, command) => {
+          const ctx = createContext(getRootOpts(command));
+          const result = await archiveProjectUpdate(ctx.gql, asUuid(updateId));
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  updates
+    .command("unarchive <update>")
+    .description("unarchive a project status update")
+    .action(
+      commandAction<[string, unknown, Command]>(
+        async (updateId, _unused1, command) => {
+          const ctx = createContext(getRootOpts(command));
+          const result = await unarchiveProjectUpdate(
+            ctx.gql,
+            asUuid(updateId),
+          );
+          outputSuccess(result);
+        },
+      ),
+    );
+
+  updates
+    .command("remind")
+    .description("notify someone that the project is due an update")
+    .requiredOption("--project <project>", "project name or UUID")
+    .option("--user <user>", "user to remind; omitted, Linear picks the target")
+    .action(
+      commandAction<[ProjectUpdatesRemindOptions, Command]>(
+        async (options, command) => {
+          const ctx = createContext(getRootOpts(command));
+
+          const projectId = await resolveProjectId(ctx.gql, options.project);
+          const userId = options.user
+            ? await resolveUserId(ctx.gql, options.user)
+            : undefined;
+
+          const result = await remindProjectUpdate(ctx.gql, projectId, userId);
+          outputSuccess(result);
+        },
+      ),
+    );
+}
diff --git a/src/common/datetime.ts b/src/common/datetime.ts
new file mode 100644
index 00000000..f678d203
--- /dev/null
+++ b/src/common/datetime.ts
@@ -0,0 +1,119 @@
+import { invalidParameterError } from "./errors.js";
+
+/**
+ * Parsing for the CLI's point-in-time flags (`issues remind --at`,
+ * `issues snooze --until`).
+ *
+ * `parseDueDate` in `identifier.ts` covers Linear's `TimelessDate` scalar —
+ * a calendar day with no clock time. The flags here map to `DateTime`, so they
+ * need a different shape: a full instant, plus a relative shorthand, because
+ * "remind me in two hours" is the overwhelmingly common case and spelling it
+ * as an absolute timestamp on a command line is miserable.
+ */
+
+/** `+2h`, `+30m`, `+3d`, `+1w` — a whole number of units after `now`. */
+const RELATIVE_REGEX = /^\+(\d+)([mhdw])$/;
+
+/**
+ * ISO-8601 instants, with the time and zone both optional. A bare date is
+ * accepted and read as midnight UTC; a date-time with no zone is also read as
+ * UTC rather than local time, so the same command produces the same instant
+ * regardless of where it runs.
+ */
+const ISO_REGEX =
+  /^(\d{4}-\d{2}-\d{2})(?:[T ](\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?)(Z|[+-]\d{2}:?\d{2})?)?$/;
+
+const UNIT_MILLISECONDS: Record<string, number> = {
+  m: 60_000,
+  h: 3_600_000,
+  d: 86_400_000,
+  w: 604_800_000,
+};
+
+/**
+ * Parses a point-in-time flag value into an ISO-8601 UTC timestamp.
+ *
+ * @param flag - Flag name, used verbatim in the error message (e.g. `--at`)
+ * @param value - Either `+<n>[mhdw]` or an ISO-8601 date / date-time
+ * @param now - Reference instant for relative values; injected so the parser
+ *   stays pure and testable
+ * @throws Error if the value matches neither form, names a date that does not
+ *   exist (e.g. `2026-02-30`), or lands outside the range a `Date` can hold
+ */
+export function parseDateTimeOption(
+  flag: string,
+  value: string,
+  now: Date = new Date(),
+): string {
+  const relative = RELATIVE_REGEX.exec(value);
+  if (relative) {
+    const [, amountRaw, unit] = relative;
+    // Both groups are guaranteed present when the regex matches.
+    const amount = Number(amountRaw);
+    const unitMs = UNIT_MILLISECONDS[unit as string];
+
+    if (amount === 0 || unitMs === undefined) {
+      throw invalidParameterError(
+        flag,
+        `"${value}" must be a positive offset, e.g. +2h`,
+      );
+    }
+
+    // A large enough offset lands outside the representable range of a Date
+    // (±100 million days), where `toISOString()` throws a bare RangeError that
+    // names neither the flag nor the value. Report it like every other bad
+    // value here instead.
+    const instant = new Date(now.getTime() + amount * unitMs);
+    if (Number.isNaN(instant.getTime())) {
+      throw invalidParameterError(
+        flag,
+        `"${value}" is too far in the future to represent`,
+      );
+    }
+
+    return instant.toISOString();
+  }
+
+  const iso = ISO_REGEX.exec(value);
+  if (!iso) {
+    throw invalidParameterError(
+      flag,
+      `"${value}" must be an ISO-8601 date or date-time (2026-08-14T09:00:00Z) ` +
+        `or a relative offset (+2h, +3d)`,
+    );
+  }
+
+  const [, date, time, zone] = iso;
+
+  // The calendar day is checked on its own rather than by round-tripping the
+  // parsed instant: with an explicit offset the UTC day legitimately differs
+  // from the written one (`2026-08-14T01:00+05:00` is the 13th in UTC), so a
+  // round-trip comparison would reject valid input.
+  if (!isRealCalendarDay(date as string)) {
+    throw invalidParameterError(flag, `"${value}" is not a real date`);
+  }
+
+  const parsed = new Date(`${date}T${time ?? "00:00:00"}${zone ?? "Z"}`);
+
+  if (Number.isNaN(parsed.getTime())) {
+    throw invalidParameterError(flag, `"${value}" is not a real date-time`);
+  }
+
+  return parsed.toISOString();
+}
+
+/** True when `YYYY-MM-DD` names a day that exists (rejects 2026-02-30). */
+function isRealCalendarDay(date: string): boolean {
+  const [year, month, day] = date.split("-").map(Number) as [
+    number,
+    number,
+    number,
+  ];
+  const utc = new Date(Date.UTC(year, month - 1, day));
+
+  return (
+    utc.getUTCFullYear() === year &&
+    utc.getUTCMonth() === month - 1 &&
+    utc.getUTCDate() === day
+  );
+}
diff --git a/src/common/domain-values.ts b/src/common/domain-values.ts
index 0bd28bc9..e5d9f6d6 100644
--- a/src/common/domain-values.ts
+++ b/src/common/domain-values.ts
@@ -1,19 +1,73 @@
+import type {
+  InitiativeUpdateHealthType,
+  ProjectUpdateHealthType,
+} from "../gql/graphql.js";
 import { invalidParameterError } from "./errors.js";
 
 /** Linear priority scale: 0=none, 1=urgent, 2=high, 3=medium, 4=low. */
 export type Priority = 0 | 1 | 2 | 3 | 4;
 
-/** How `issues update --labels` combines with existing labels. */
-export type LabelMode = "add" | "remove" | "overwrite";
+/**
+ * How a set-valued update flag combines with the issue's existing values —
+ * shared by `--label-mode` and `--subscriber-mode`.
+ */
+export type SetMode = "add" | "remove" | "overwrite";
 
-export function parseLabelMode(
+/**
+ * @param flag - Flag name for the error message, so a shared parser still
+ *   reports the flag the caller actually typed
+ */
+export function parseSetMode(
+  flag: string,
   value: string | undefined,
-): LabelMode | undefined {
+): SetMode | undefined {
   if (value === undefined) return undefined;
   if (value === "add" || value === "remove" || value === "overwrite")
     return value;
   throw invalidParameterError(
-    "--label-mode",
+    flag,
     "must be one of 'add', 'remove', or 'overwrite'",
   );
 }
+
+/** How `issues update --labels` combines with existing labels. */
+export function parseLabelMode(value: string | undefined): SetMode | undefined {
+  return parseSetMode("--label-mode", value);
+}
+
+/**
+ * Health of a status update.
+ *
+ * Linear declares this twice — `InitiativeUpdateHealthType` and
+ * `ProjectUpdateHealthType` — with identical members, so one union serves both
+ * codegen enums. The `satisfies` pins that claim to the schema: the
+ * intersection keeps only members both enums still declare, so a value dropped
+ * from either one fails to compile here instead of failing at the API.
+ */
+const UPDATE_HEALTHS = [
+  "onTrack",
+  "atRisk",
+  "offTrack",
+] as const satisfies readonly (InitiativeUpdateHealthType &
+  ProjectUpdateHealthType)[];
+
+export type UpdateHealth = (typeof UPDATE_HEALTHS)[number];
+
+/**
+ * Parses `--health` case-insensitively, because the API spelling is
+ * camelCase and nobody types `atRisk` on a shell prompt reliably.
+ */
+export function parseHealth(value?: string): UpdateHealth | undefined {
+  if (!value) return undefined;
+
+  const normalized = value.trim().toLowerCase();
+  const match = UPDATE_HEALTHS.find(
+    (health) => health.toLowerCase() === normalized,
+  );
+  if (match) return match;
+
+  throw invalidParameterError(
+    "--health",
+    `must be one of: ${UPDATE_HEALTHS.map((health) => `"${health}"`).join(", ")}`,
+  );
+}
diff --git a/src/common/errors.ts b/src/common/errors.ts
index 11c97ff4..ee6a0e93 100644
--- a/src/common/errors.ts
+++ b/src/common/errors.ts
@@ -7,6 +7,18 @@ export function notFoundError(
   return new Error(`${entityType} "${identifier}"${contextStr} not found`);
 }
 
+/**
+ * Pluralises an entity type for the message below.
+ *
+ * Entity types here are short English noun phrases, so the sibilant rule
+ * covers every one of them: "status" needs "statuses", not "statuss".
+ */
+function pluralize(entityType: string): string {
+  return /(?:s|x|z|ch|sh)$/.test(entityType)
+    ? `${entityType}es`
+    : `${entityType}s`;
+}
+
 export function multipleMatchesError(
   entityType: string,
   identifier: string,
@@ -15,7 +27,7 @@ export function multipleMatchesError(
 ): Error {
   const matchList = matches.join(", ");
   return new Error(
-    `Multiple ${entityType}s found matching "${identifier}". ` +
+    `Multiple ${pluralize(entityType)} found matching "${identifier}". ` +
       `Candidates: ${matchList}. ` +
       `Please ${disambiguation}.`,
   );
diff --git a/src/common/git.ts b/src/common/git.ts
new file mode 100644
index 00000000..489ea7c3
--- /dev/null
+++ b/src/common/git.ts
@@ -0,0 +1,38 @@
+import { execFileSync } from "node:child_process";
+import { invalidParameterError } from "./errors.js";
+
+/**
+ * Reads the checked-out branch name.
+ *
+ * Uses `execFileSync` rather than `exec` so nothing reaches a shell. Both a
+ * missing/failing `git` and a detached HEAD surface as the same actionable
+ * error, because from the caller's point of view they are the same situation:
+ * there is no branch to infer, so name one explicitly.
+ *
+ * @throws Error if the current directory has no checked-out branch
+ */
+export function getCurrentBranch(): string {
+  let branch: string;
+
+  try {
+    branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    throw invalidParameterError(
+      "branch",
+      "could not be read from git — pass a branch name explicitly",
+    );
+  }
+
+  // `rev-parse --abbrev-ref HEAD` prints "HEAD" when the checkout is detached.
+  if (branch === "" || branch === "HEAD") {
+    throw invalidParameterError(
+      "branch",
+      "is not available (detached HEAD) — pass a branch name explicitly",
+    );
+  }
+
+  return branch;
+}
diff --git a/src/common/issue-filter.ts b/src/common/issue-filter.ts
index 20726b71..0e00f5e7 100644
--- a/src/common/issue-filter.ts
+++ b/src/common/issue-filter.ts
@@ -23,6 +23,9 @@ export interface IssueFilterOptions {
   updatedBefore?: string;
   hasBlockers?: boolean;
   isBlocking?: boolean;
+  unassigned?: boolean;
+  stateType?: WorkflowStateType;
+  subscriberId?: string;
 }
 
 export interface RawFilterFlags {
@@ -47,6 +50,37 @@ export interface RawFilterFlags {
   updatedBefore?: string;
   hasBlockers?: boolean;
   isBlocking?: boolean;
+  unassigned?: boolean;
+  stateType?: string;
+  subscriber?: string;
+}
+
+/**
+ * Workflow-state categories, as documented on `WorkflowState.type`.
+ *
+ * `duplicate` is omitted: it is not a category a caller filters a work list by,
+ * and Linear surfaces duplicates through the relation instead.
+ */
+export const WORKFLOW_STATE_TYPES = [
+  "triage",
+  "backlog",
+  "unstarted",
+  "started",
+  "completed",
+  "canceled",
+] as const;
+
+export type WorkflowStateType = (typeof WORKFLOW_STATE_TYPES)[number];
+
+export function parseWorkflowStateType(value: string): WorkflowStateType {
+  if ((WORKFLOW_STATE_TYPES as readonly string[]).includes(value)) {
+    return value as WorkflowStateType;
+  }
+
+  throw invalidParameterError(
+    "--state-type",
+    `must be one of ${WORKFLOW_STATE_TYPES.join(", ")}`,
+  );
 }
 
 export function validatePriority(value: number): void {
diff --git a/src/common/resolve-filters.ts b/src/common/resolve-filters.ts
index 02bf5b40..82a4003a 100644
--- a/src/common/resolve-filters.ts
+++ b/src/common/resolve-filters.ts
@@ -1,11 +1,13 @@
 import { resolveSearchFilterIds } from "../resolvers/issue-filter-resolver.js";
 import { resolveMilestoneId } from "../resolvers/milestone-resolver.js";
+import { resolveUserId } from "../resolvers/user-resolver.js";
 import type { CommandContext } from "./context.js";
 import { invalidParameterError } from "./errors.js";
 import { parseDueDate } from "./identifier.js";
 import {
   type IssueFilterOptions,
   parseCommaSeparated,
+  parseWorkflowStateType,
   type RawFilterFlags,
   validateDateRange,
   validateEstimate,
@@ -82,9 +84,22 @@ export async function resolveFilterOptions(
     validateEstimate(parsedEstimate);
   }
 
+  const parsedStateType = opts.stateType
+    ? parseWorkflowStateType(opts.stateType)
+    : undefined;
+
   // 2. Dependency validation
   validateFilterDependencies(opts);
 
+  // --unassigned and --assignee describe the same field in contradictory ways;
+  // combining them would silently produce a filter that matches nothing.
+  if (opts.unassigned && opts.assignee) {
+    throw invalidParameterError(
+      "--unassigned",
+      "cannot be combined with --assignee",
+    );
+  }
+
   // 3. Date range validation
   validateDateRange(opts.dueAfter, opts.dueBefore, "due date");
   validateDateRange(opts.createdAfter, opts.createdBefore, "created date");
@@ -122,9 +137,12 @@ export async function resolveFilterOptions(
       )
     : {};
 
-  const milestoneId = opts.milestone
-    ? await resolveMilestoneId(ctx.gql, opts.milestone, opts.project)
-    : undefined;
+  const [milestoneId, subscriberId] = await Promise.all([
+    opts.milestone
+      ? resolveMilestoneId(ctx.gql, opts.milestone, opts.project)
+      : undefined,
+    opts.subscriber ? resolveUserId(ctx.gql, opts.subscriber) : undefined,
+  ]);
 
   const resolved: IssueFilterOptions = omitUndefined({
     ...batchResolved,
@@ -141,6 +159,9 @@ export async function resolveFilterOptions(
     updatedBefore: opts.updatedBefore,
     hasBlockers: opts.hasBlockers,
     isBlocking: opts.isBlocking,
+    unassigned: opts.unassigned,
+    stateType: parsedStateType,
+    subscriberId,
   });
 
   return resolved;
diff --git a/src/common/timeline.ts b/src/common/timeline.ts
new file mode 100644
index 00000000..199d5582
--- /dev/null
+++ b/src/common/timeline.ts
@@ -0,0 +1,55 @@
+/**
+ * Shared timeline assembly for activity commands.
+ *
+ * `issues activity` and `projects activity` merge several independent
+ * connections into one chronological list and slice it with an opaque id
+ * cursor. Only the item type differs, so the entry shape, the sort order and
+ * the cursor arithmetic live here — a fix to the cursor logic must not have
+ * to be made twice.
+ */
+
+/** One timeline item reduced to the fields the merge and the cursor need. */
+export interface TimelineEntry<TItem> {
+  createdAt: string;
+  id: string;
+  item: TItem;
+}
+
+export interface TimelinePage<TItem> {
+  nodes: TItem[];
+  hasNextPage: boolean;
+  endCursor: string | null;
+}
+
+/** Ascending by creation time, with the id as a stable tiebreaker. */
+export function compareTimelineEntries<TItem>(
+  a: TimelineEntry<TItem>,
+  b: TimelineEntry<TItem>,
+): number {
+  const byCreatedAt = a.createdAt.localeCompare(b.createdAt);
+  return byCreatedAt !== 0 ? byCreatedAt : a.id.localeCompare(b.id);
+}
+
+/** Slice a sorted timeline using an opaque id cursor (mirrors reply pagination). */
+export function paginateTimeline<TItem>(
+  entries: readonly TimelineEntry<TItem>[],
+  limit: number,
+  after?: string,
+): TimelinePage<TItem> {
+  const startIndex =
+    after === undefined
+      ? 0
+      : entries.findIndex((entry) => entry.id === after) + 1;
+
+  if (after !== undefined && startIndex === 0) {
+    throw new Error(`Activity cursor "${after}" not found`);
+  }
+
+  const page = entries.slice(startIndex, startIndex + limit);
+
+  return {
+    nodes: page.map((entry) => entry.item),
+    hasNextPage: startIndex + limit < entries.length,
+    endCursor: page.at(-1)?.id ?? null,
+  };
+}
diff --git a/src/common/types.ts b/src/common/types.ts
index 0ed84247..eb9dac4a 100644
--- a/src/common/types.ts
+++ b/src/common/types.ts
@@ -1,7 +1,7 @@
-import type { GetIssuesQuery } from "../gql/graphql.js";
+import type { FilteredSearchIssuesQuery } from "../gql/graphql.js";
 
 // Pagination types
-type PageInfo = GetIssuesQuery["issues"]["pageInfo"];
+type PageInfo = FilteredSearchIssuesQuery["issues"]["pageInfo"];
 
 export interface PaginatedResult<T> {
   nodes: T[];
diff --git a/src/main.ts b/src/main.ts
index 0455281a..a0c95671 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -24,7 +24,10 @@ import {
   MILESTONES_META,
   setupMilestonesCommands,
 } from "./commands/milestones.js";
-import { PROJECTS_META, setupProjectsCommands } from "./commands/projects.js";
+import {
+  PROJECTS_META,
+  setupProjectsCommands,
+} from "./commands/projects/index.js";
 import { setupTeamsCommands, TEAMS_META } from "./commands/teams.js";
 import { setupUsersCommands, USERS_META } from "./commands/users.js";
 import { setupVersionCommands, VERSION_META } from "./commands/version.js";
diff --git a/src/resolvers/batch-resolve-mappers.ts b/src/resolvers/batch-resolve-mappers.ts
index e3e6c757..dda55c7f 100644
--- a/src/resolvers/batch-resolve-mappers.ts
+++ b/src/resolvers/batch-resolve-mappers.ts
@@ -4,6 +4,7 @@ import type {
   BatchResolveForCreateQuery,
   IssueLabelFilter,
 } from "../gql/graphql.js";
+import { isViewerAlias } from "./user-resolver.js";
 
 /**
  * Pure mappers shared by the batch resolvers (issue create/update and issue
@@ -38,6 +39,20 @@ export function buildLabelFilter(names: string[]): IssueLabelFilter {
   return { or: names.map((name) => ({ name: { eqIgnoreCase: name } })) };
 }
 
+/**
+ * Builds the `$assigneeQuery`/`$creatorQuery` variable for a user reference.
+ *
+ * Yields `null` — a lookup the batch query skips — for every reference the
+ * query cannot match by display name or email: an absent flag, a UUID, and the
+ * `me` alias, which names the caller rather than a value and is resolved
+ * against `viewer` by the caller instead. Sending `me` as a name would only
+ * come back empty, and {@link mapUser} would report it as an unknown user.
+ */
+export function buildUserQuery(ref: string | undefined): string | null {
+  if (!ref || isUuid(ref) || isViewerAlias(ref)) return null;
+  return ref;
+}
+
 /**
  * Two-phase user precedence, replicated purely from the `or:[displayName,email]`
  * result: an exact (case-insensitive) display-name match wins; multiple name
diff --git a/src/resolvers/issue-filter-resolver.ts b/src/resolvers/issue-filter-resolver.ts
index df7f1e7c..6c88483f 100644
--- a/src/resolvers/issue-filter-resolver.ts
+++ b/src/resolvers/issue-filter-resolver.ts
@@ -9,14 +9,17 @@ import {
 import { BatchResolveForSearchDocument } from "../gql/graphql.js";
 import {
   buildLabelFilter,
+  buildUserQuery,
   mapCycle,
   mapLabels,
   mapParent,
   mapProjectId,
   mapUser,
+  type UserNode,
 } from "./batch-resolve-mappers.js";
 import { resolveCycleId } from "./cycle-resolver.js";
 import { resolveStatusId } from "./status-resolver.js";
+import { isViewerAlias, resolveViewerId } from "./user-resolver.js";
 
 export interface SearchFilterResolutionInput {
   team?: string;
@@ -58,10 +61,11 @@ export async function resolveSearchFilterIds(
   const team = input.team;
   const teamIsUuid = team ? isUuid(team) : false;
 
-  const assigneeQuery =
-    input.assignee && !isUuid(input.assignee) ? input.assignee : null;
-  const creatorQuery =
-    input.creator && !isUuid(input.creator) ? input.creator : null;
+  const assigneeQuery = buildUserQuery(input.assignee);
+  const creatorQuery = buildUserQuery(input.creator);
+  const wantsViewer =
+    (!!input.assignee && isViewerAlias(input.assignee)) ||
+    (!!input.creator && isViewerAlias(input.creator));
   const projectName =
     input.project && !isUuid(input.project) ? input.project : null;
   const projectIdVar =
@@ -74,20 +78,29 @@ export async function resolveSearchFilterIds(
       ? parseIssueIdentifier(input.parent)
       : null;
 
-  const response = await gqlClient.request(BatchResolveForSearchDocument, {
-    teamKey: team && !teamIsUuid ? team : null,
-    teamName: team && !teamIsUuid ? team : null,
-    teamId: team && teamIsUuid ? team : null,
-    assigneeQuery,
-    creatorQuery,
-    projectName,
-    projectId: projectIdVar,
-    labelFilter: buildLabelFilter(labelNames),
-    cycleName,
-    parentTeamKey: parent?.teamKey ?? null,
-    parentIssueNumber: parent?.issueNumber ?? null,
-    milestoneName: null,
-  });
+  // The viewer lookup is awaited together with the batch request: starting it
+  // without awaiting it in the same expression would leave a rejection
+  // unhandled whenever the batch request throws first, and an unhandled
+  // rejection kills the process with a stack trace instead of the JSON error
+  // envelope. One lookup serves both flags — `--assignee me --creator me` is a
+  // perfectly ordinary "what am I working on that I filed" query.
+  const [viewerId, response] = await Promise.all([
+    wantsViewer ? resolveViewerId(gqlClient) : undefined,
+    gqlClient.request(BatchResolveForSearchDocument, {
+      teamKey: team && !teamIsUuid ? team : null,
+      teamName: team && !teamIsUuid ? team : null,
+      teamId: team && teamIsUuid ? team : null,
+      assigneeQuery,
+      creatorQuery,
+      projectName,
+      projectId: projectIdVar,
+      labelFilter: buildLabelFilter(labelNames),
+      cycleName,
+      parentTeamKey: parent?.teamKey ?? null,
+      parentIssueNumber: parent?.issueNumber ?? null,
+      milestoneName: null,
+    }),
+  ]);
 
   const resolved: SearchFilterResolution = {};
 
@@ -98,15 +111,21 @@ export async function resolveSearchFilterIds(
   }
 
   if (input.assignee) {
-    resolved.assigneeId = isUuid(input.assignee)
-      ? asUuid(input.assignee)
-      : mapUser(response.assignees.nodes, input.assignee);
+    resolved.assigneeId = pickUserId(
+      input.assignee,
+      assigneeQuery,
+      response.assignees.nodes,
+      viewerId,
+    );
   }
 
   if (input.creator) {
-    resolved.creatorId = isUuid(input.creator)
-      ? asUuid(input.creator)
-      : mapUser(response.creators.nodes, input.creator);
+    resolved.creatorId = pickUserId(
+      input.creator,
+      creatorQuery,
+      response.creators.nodes,
+      viewerId,
+    );
   }
 
   if (input.project) {
@@ -164,6 +183,25 @@ export async function resolveSearchFilterIds(
   return resolved;
 }
 
+/**
+ * Picks the id for one user-valued filter flag.
+ *
+ * `query` is non-null exactly when the batch response holds candidates to match
+ * against; otherwise the reference is a UUID that passes through, or the `me`
+ * alias, which takes the viewer id fetched alongside the batch request.
+ */
+function pickUserId(
+  raw: string,
+  query: string | null,
+  nodes: UserNode[],
+  viewerId: UUID | undefined,
+): UUID {
+  if (query) return mapUser(nodes, query);
+  if (isUuid(raw)) return asUuid(raw);
+  if (viewerId) return viewerId;
+  throw notFoundError("User", raw);
+}
+
 type SearchTeamNode = { id: string; key: string; name: string };
 
 /** Mirrors resolveTeamId: prefer key match, then name; else not-found. */
diff --git a/src/resolvers/issue-mutation-resolver.ts b/src/resolvers/issue-mutation-resolver.ts
index d1daaa10..c0a87d24 100644
--- a/src/resolvers/issue-mutation-resolver.ts
+++ b/src/resolvers/issue-mutation-resolver.ts
@@ -12,6 +12,7 @@ import {
 } from "../gql/graphql.js";
 import {
   buildLabelFilter,
+  buildUserQuery,
   mapCycle,
   mapLabels,
   mapMilestone,
@@ -22,7 +23,12 @@ import {
   type ProjectNode,
   type TeamNode,
 } from "./batch-resolve-mappers.js";
-import type { TeamEstimateContext } from "./team-resolver.js";
+import { resolveTeamId, type TeamEstimateContext } from "./team-resolver.js";
+import {
+  isViewerAlias,
+  resolveUserId,
+  resolveViewerId,
+} from "./user-resolver.js";
 
 /**
  * Batch resolver for issue create / update.
@@ -72,6 +78,9 @@ export interface ResolveCreateIssueIdsInput {
   cycle?: string;
   status?: string;
   parentTicket?: string;
+  /** User references (name, email, UUID or `me`) to subscribe on creation. */
+  subscribers?: string[];
+  delegate?: string;
   /** When true, resolve the team's estimation config for `--estimate` validation. */
   withEstimateContext?: boolean;
 }
@@ -86,6 +95,43 @@ export interface ResolvedCreateIssueIds {
   cycleId?: UUID;
   stateId?: UUID;
   parentId?: UUID;
+  subscriberIds?: UUID[];
+  delegateId?: UUID;
+}
+
+/**
+ * Resolves the user-valued references that the `BatchResolve*` queries cannot.
+ *
+ * `--subscribers` is a list and `--delegate` a second single user, neither of
+ * which the batch query's one `$assigneeQuery` variable can express. They go
+ * through `resolveUserId` in parallel instead, which keeps the name/email
+ * disambiguation identical to every other user flag and costs nothing when the
+ * flags are absent.
+ *
+ * `--assignee` normally *is* the batch query's variable, but `me` matches no
+ * display name or email, so that one spelling is diverted here too — otherwise
+ * an alias the help text and the JSON Schema both advertise would come back as
+ * `User "me" not found`.
+ */
+async function resolveIssueUserRefs(
+  client: GraphQLClient,
+  input: { subscribers?: string[]; delegate?: string; assignee?: string },
+): Promise<{ subscriberIds?: UUID[]; delegateId?: UUID; assigneeId?: UUID }> {
+  const [subscriberIds, delegateId, assigneeId] = await Promise.all([
+    input.subscribers
+      ? Promise.all(input.subscribers.map((ref) => resolveUserId(client, ref)))
+      : undefined,
+    input.delegate ? resolveUserId(client, input.delegate) : undefined,
+    input.assignee && isViewerAlias(input.assignee)
+      ? resolveViewerId(client)
+      : undefined,
+  ]);
+
+  return {
+    ...(subscriberIds && { subscriberIds }),
+    ...(delegateId && { delegateId }),
+    ...(assigneeId && { assigneeId }),
+  };
 }
 
 /**
@@ -97,8 +143,7 @@ export async function resolveCreateIssueIds(
   input: ResolveCreateIssueIdsInput,
 ): Promise<ResolvedCreateIssueIds> {
   const teamIsUuid = isUuid(input.team);
-  const assigneeQuery =
-    input.assignee && !isUuid(input.assignee) ? input.assignee : null;
+  const assigneeQuery = buildUserQuery(input.assignee);
   const projectName =
     input.project && !isUuid(input.project) ? input.project : null;
   const projectIdVar =
@@ -117,20 +162,27 @@ export async function resolveCreateIssueIds(
       ? parseIssueIdentifier(input.parentTicket)
       : null;
 
-  const response = await client.request(BatchResolveForCreateDocument, {
-    teamKey: teamIsUuid ? null : input.team,
-    teamName: teamIsUuid ? null : input.team,
-    teamId: teamIsUuid ? input.team : null,
-    assigneeQuery,
-    projectName,
-    projectId: projectIdVar,
-    labelFilter: buildLabelFilter(labelNames),
-    statusName,
-    cycleName,
-    milestoneName,
-    parentTeamKey: parent?.teamKey ?? null,
-    parentIssueNumber: parent?.issueNumber ?? null,
-  });
+  // Awaited together with the batch request: starting the user lookups without
+  // awaiting them in the same expression would leave a rejection unhandled
+  // whenever the batch request throws first, and an unhandled rejection kills
+  // the process with a stack trace instead of the JSON error envelope.
+  const [userRefs, response] = await Promise.all([
+    resolveIssueUserRefs(client, input),
+    client.request(BatchResolveForCreateDocument, {
+      teamKey: teamIsUuid ? null : input.team,
+      teamName: teamIsUuid ? null : input.team,
+      teamId: teamIsUuid ? input.team : null,
+      assigneeQuery,
+      projectName,
+      projectId: projectIdVar,
+      labelFilter: buildLabelFilter(labelNames),
+      statusName,
+      cycleName,
+      milestoneName,
+      parentTeamKey: parent?.teamKey ?? null,
+      parentIssueNumber: parent?.issueNumber ?? null,
+    }),
+  ]);
 
   // Team (required). Prefer key match, then name, then id — mirrors resolveTeamId.
   const teamNode = teamIsUuid
@@ -158,10 +210,12 @@ export async function resolveCreateIssueIds(
     };
   }
 
-  if (input.assignee) {
-    resolved.assigneeId = isUuid(input.assignee)
-      ? asUuid(input.assignee)
-      : mapUser(response.assignees.nodes, input.assignee);
+  // A `me` assignee has no name to match; it is resolved against `viewer` in
+  // userRefs and spread over `resolved` on the way out.
+  if (assigneeQuery) {
+    resolved.assigneeId = mapUser(response.assignees.nodes, assigneeQuery);
+  } else if (input.assignee && isUuid(input.assignee)) {
+    resolved.assigneeId = asUuid(input.assignee);
   }
 
   let matchedProject: ProjectNode | undefined;
@@ -209,7 +263,83 @@ export async function resolveCreateIssueIds(
       : mapParent(response.parentIssues.nodes, input.parentTicket);
   }
 
-  return resolved;
+  return { ...resolved, ...userRefs };
+}
+
+/** How many distinct reference sets resolve at once (see below for why). */
+const BATCH_CREATE_RESOLVE_CONCURRENCY = 5;
+
+/**
+ * Resolves the human identifiers for a whole batch of issues to create.
+ *
+ * Each entry still resolves through {@link resolveCreateIssueIds}, so the
+ * disambiguation and not-found semantics are identical to a single create —
+ * a batch must not quietly accept a team name that `issues create` would
+ * reject. What changes is the round-trip count: entries naming the same set of
+ * references (the usual case, where a batch shares a team and project and
+ * differs only in title) are deduplicated up front, so the cost is one
+ * `BatchResolveForCreate` per *distinct* reference set rather than per row.
+ *
+ * Field-level memoization would collapse more, but status, cycle and milestone
+ * lookups are scoped by the entry's own team and project, so a per-field cache
+ * cannot be keyed correctly without duplicating that scoping here.
+ *
+ * The distinct sets are then resolved in bounded waves rather than all at once.
+ * Deduplication helps the common batch that shares a team and project, but a
+ * heterogeneous import — the case this command exists for — has as many
+ * distinct sets as rows, and firing every `BatchResolveForCreate` (plus its
+ * user lookups) simultaneously is how a large import earns a rate-limit
+ * rejection instead of a result.
+ */
+export async function resolveBatchCreateIssueIds(
+  client: GraphQLClient,
+  entries: readonly ResolveCreateIssueIdsInput[],
+): Promise<ResolvedCreateIssueIds[]> {
+  // Deduplicate first so the concurrency window counts real requests: a batch
+  // of 100 rows sharing one reference set should still cost one wave.
+  const keys = entries.map(batchCreateCacheKey);
+  const unique = new Map<string, ResolveCreateIssueIdsInput>();
+  for (const [index, key] of keys.entries()) {
+    if (!unique.has(key)) {
+      unique.set(key, entries[index] as ResolveCreateIssueIdsInput);
+    }
+  }
+
+  const resolvedByKey = new Map<string, ResolvedCreateIssueIds>();
+  const pending = [...unique];
+
+  for (let i = 0; i < pending.length; i += BATCH_CREATE_RESOLVE_CONCURRENCY) {
+    const wave = pending.slice(i, i + BATCH_CREATE_RESOLVE_CONCURRENCY);
+    const resolved = await Promise.all(
+      wave.map(([, entry]) => resolveCreateIssueIds(client, entry)),
+    );
+    for (const [offset, [key]] of wave.entries()) {
+      resolvedByKey.set(key, resolved[offset] as ResolvedCreateIssueIds);
+    }
+  }
+
+  return keys.map((key) => resolvedByKey.get(key) as ResolvedCreateIssueIds);
+}
+
+/**
+ * Stable cache key over exactly the fields {@link resolveCreateIssueIds} reads.
+ * Title and description are absent by construction — they never reach the
+ * resolver — so two entries with the same key resolve to the same UUIDs.
+ */
+function batchCreateCacheKey(entry: ResolveCreateIssueIdsInput): string {
+  return JSON.stringify([
+    entry.team,
+    entry.assignee ?? null,
+    entry.project ?? null,
+    entry.labels ?? null,
+    entry.projectMilestone ?? null,
+    entry.cycle ?? null,
+    entry.status ?? null,
+    entry.parentTicket ?? null,
+    entry.subscribers ?? null,
+    entry.delegate ?? null,
+    entry.withEstimateContext ?? false,
+  ]);
 }
 
 function findTeamNode(nodes: TeamNode[], raw: string): TeamNode | undefined {
@@ -241,6 +371,10 @@ export interface ResolveUpdateIssueIdsInput {
   cycle?: string;
   status?: string;
   parentTicket?: string;
+  /** Destination team for a move; also rescopes status / cycle resolution. */
+  team?: string;
+  subscribers?: string[];
+  delegate?: string;
 }
 
 export interface ResolvedUpdateIssueIds {
@@ -252,6 +386,10 @@ export interface ResolvedUpdateIssueIds {
   cycleId?: UUID;
   stateId?: UUID;
   parentId?: UUID;
+  teamId?: UUID;
+  /** Resolved subscriber UUIDs (add/remove/overwrite set math stays in the command). */
+  subscriberIds?: UUID[];
+  delegateId?: UUID;
 }
 
 /**
@@ -268,8 +406,7 @@ export async function resolveUpdateIssueIds(
   input: ResolveUpdateIssueIdsInput,
   context: UpdateIssueContext,
 ): Promise<ResolvedUpdateIssueIds> {
-  const assigneeQuery =
-    input.assignee && !isUuid(input.assignee) ? input.assignee : null;
+  const assigneeQuery = buildUserQuery(input.assignee);
 
   // projectName scopes both --project resolution and milestone lookup: the new
   // project when --project is a name, else the issue's current project.
@@ -294,6 +431,23 @@ export async function resolveUpdateIssueIds(
       ? parseIssueIdentifier(input.parentTicket)
       : null;
 
+  // Both lookups are awaited in the same expression: starting one without
+  // awaiting it would leave a rejection unhandled whenever the other throws
+  // first, and an unhandled rejection kills the process with a stack trace
+  // instead of the JSON error envelope.
+  //
+  // A team move rescopes the lookups: a status or cycle named alongside
+  // `--team` belongs to the *destination* team's workflow, not the team the
+  // issue is leaving. This is the one lookup that cannot be batched with the
+  // rest, since its result is an input to them.
+  const [userRefs, destinationTeamId] = await Promise.all([
+    resolveIssueUserRefs(client, input),
+    input.team ? resolveTeamId(client, input.team) : undefined,
+  ]);
+  const scope: UpdateIssueContext = destinationTeamId
+    ? { teamId: destinationTeamId }
+    : context;
+
   const response = await client.request(BatchResolveForUpdateDocument, {
     assigneeQuery,
     projectName: projectNameVar,
@@ -301,19 +455,22 @@ export async function resolveUpdateIssueIds(
     labelFilter: buildLabelFilter(labelNames),
     statusName,
     cycleName,
-    teamKey: context.teamKey ?? null,
-    teamId: context.teamId ?? null,
+    teamKey: scope.teamKey ?? null,
+    teamId: scope.teamId ?? null,
     milestoneName,
     parentTeamKey: parent?.teamKey ?? null,
     parentIssueNumber: parent?.issueNumber ?? null,
   });
 
-  const resolved: ResolvedUpdateIssueIds = {};
+  const resolved: ResolvedUpdateIssueIds = destinationTeamId
+    ? { teamId: destinationTeamId }
+    : {};
 
-  if (input.assignee) {
-    resolved.assigneeId = isUuid(input.assignee)
-      ? asUuid(input.assignee)
-      : mapUser(response.assignees.nodes, input.assignee);
+  // As in create: `me` carries no name to match and arrives via userRefs.
+  if (assigneeQuery) {
+    resolved.assigneeId = mapUser(response.assignees.nodes, assigneeQuery);
+  } else if (input.assignee && isUuid(input.assignee)) {
+    resolved.assigneeId = asUuid(input.assignee);
   }
 
   // The projects field matches by projectNameVar/projectIdVar; the matched node
@@ -347,7 +504,7 @@ export async function resolveUpdateIssueIds(
   if (input.cycle) {
     resolved.cycleId = isUuid(input.cycle)
       ? asUuid(input.cycle)
-      : mapCycle(response.cycles.nodes, input.cycle, context.teamKey);
+      : mapCycle(response.cycles.nodes, input.cycle, scope.teamKey);
   }
 
   if (input.status) {
@@ -356,7 +513,7 @@ export async function resolveUpdateIssueIds(
       : mapStatus(
           response.statuses.nodes,
           input.status,
-          context.teamId ? `for team ${context.teamId}` : undefined,
+          scope.teamId ? `for team ${scope.teamId}` : undefined,
         );
   }
 
@@ -366,5 +523,5 @@ export async function resolveUpdateIssueIds(
       : mapParent(response.parentIssues.nodes, input.parentTicket);
   }
 
-  return resolved;
+  return { ...resolved, ...userRefs };
 }
diff --git a/src/resolvers/issue-resolver.ts b/src/resolvers/issue-resolver.ts
index aceacb1b..98812bda 100644
--- a/src/resolvers/issue-resolver.ts
+++ b/src/resolvers/issue-resolver.ts
@@ -59,6 +59,73 @@ export async function resolveIssueId(
   );
 }
 
+/** An issue reference resolved to its UUID plus the team that scopes it. */
+export interface ResolvedIssueRef {
+  ref: string;
+  id: UUID;
+  teamId: UUID;
+  teamKey: string;
+}
+
+/**
+ * Resolves a list of issue references in one request.
+ *
+ * Unlike {@link resolveIssueId} this also returns each issue's team, because
+ * the batch-update caller needs it: `issueBatchUpdate` applies a single patch
+ * to every target, so a status or cycle named by word can only be resolved
+ * when all targets share one team. UUID references are looked up rather than
+ * passed straight through for the same reason — the team is not derivable from
+ * a UUID.
+ *
+ * Duplicate references collapse to one entry, preserving first-seen order.
+ *
+ * @throws Error if any reference does not match an issue
+ */
+export async function resolveIssueRefs(
+  client: GraphQLClient,
+  refs: readonly string[],
+): Promise<ResolvedIssueRef[]> {
+  const unique = [...new Set(refs)];
+
+  if (unique.length === 0) {
+    return [];
+  }
+
+  const { issues } = await client.request(FindIssuesDocument, {
+    filter: { or: unique.map(issueLookupFilter) },
+    first: unique.length,
+  });
+
+  return unique.map((ref) => {
+    const node = issues.nodes.find((candidate) =>
+      isUuid(ref)
+        ? candidate.id === ref
+        : matchesIdentifier(candidate, parseIssueIdentifier(ref)),
+    );
+
+    if (!node) {
+      throw notFoundError("Issue", ref);
+    }
+
+    return {
+      ref,
+      id: asUuid(node.id),
+      teamId: asUuid(node.team.id),
+      teamKey: node.team.key,
+    };
+  });
+}
+
+function matchesIdentifier(
+  node: { number: number; team: { key: string } },
+  identifier: { teamKey: string; issueNumber: number },
+): boolean {
+  return (
+    node.number === identifier.issueNumber &&
+    node.team.key === identifier.teamKey
+  );
+}
+
 export async function resolveIssueEstimateContext(
   client: GraphQLClient,
   issueIdOrIdentifier: string,
diff --git a/src/resolvers/milestone-resolver.ts b/src/resolvers/milestone-resolver.ts
index 686d98c9..a78bf85b 100644
--- a/src/resolvers/milestone-resolver.ts
+++ b/src/resolvers/milestone-resolver.ts
@@ -14,6 +14,13 @@ import { resolveProjectId } from "./project-resolver.js";
  * Accepts UUID or milestone name. When multiple milestones match a name,
  * use projectNameOrId to scope the search to a specific project.
  *
+ * A project scope is authoritative: a name that project does not carry is
+ * "not found", not an invitation to search the rest of the workspace.
+ * Milestone names repeat across projects ("Beta", "Launch"), so a fallback
+ * would silently resolve to a stranger's milestone — and the callers that
+ * pass a scope (`--project`, the per-end relation flags) all mean the
+ * milestone to belong to that project.
+ *
  * ARCHITECTURAL EXCEPTION: This resolver queries milestones directly via
  * GraphQL (FindProjectMilestoneScoped / FindProjectMilestoneGlobal) because
  * the Linear API exposes no lean lookup fragment for milestones by name. All
@@ -37,7 +44,7 @@ export async function resolveMilestoneId(
     name: string;
     project?: { name: string } | null;
   };
-  let nodes: MilestoneNode[] = [];
+  let nodes: MilestoneNode[];
 
   if (projectNameOrId) {
     const projectId = await resolveProjectId(gqlClient, projectNameOrId);
@@ -46,10 +53,7 @@ export async function resolveMilestoneId(
       projectId,
     });
     nodes = (result.project?.projectMilestones?.nodes as MilestoneNode[]) || [];
-  }
-
-  // Fall back to global search if no project scope or not found
-  if (nodes.length === 0) {
+  } else {
     const globalResult = await gqlClient.request(
       FindProjectMilestoneGlobalDocument,
       { name: nameOrId },
@@ -58,7 +62,11 @@ export async function resolveMilestoneId(
   }
 
   if (nodes.length === 0) {
-    throw notFoundError("Milestone", nameOrId);
+    throw notFoundError(
+      "Milestone",
+      nameOrId,
+      projectNameOrId ? `in project "${projectNameOrId}"` : undefined,
+    );
   }
 
   if (nodes.length > 1) {
diff --git a/src/resolvers/project-relation-resolver.ts b/src/resolvers/project-relation-resolver.ts
new file mode 100644
index 00000000..308d9c28
--- /dev/null
+++ b/src/resolvers/project-relation-resolver.ts
@@ -0,0 +1,146 @@
+import type { GraphQLClient } from "../client/graphql-client.js";
+import { firstOrThrow } from "../common/array.js";
+import { multipleMatchesError, notFoundError } from "../common/errors.js";
+import { asUuid, isUuid, type UUID } from "../common/identifier.js";
+import {
+  GetProjectRelationsDocument,
+  type ProjectRelationCoreFieldsFragment,
+} from "../gql/graphql.js";
+
+/**
+ * Rows read from each direction of a project's dependencies. Neither
+ * connection accepts a filter, so the whole page is fetched and matched
+ * client-side; 100 covers any realistic project while keeping the read well
+ * inside Linear's complexity budget.
+ */
+const PROJECT_RELATION_PAGE_SIZE = 100;
+
+/** A resolved relation, plus which way round it is stored. */
+export interface ResolvedProjectRelation {
+  id: UUID;
+  /**
+   * True when the relation was found through `inverseRelations`, i.e. the
+   * project named first is the relation's `relatedProject` and the second is
+   * its `project`. Callers that write per-end fields must swap the two ends.
+   */
+  inverted: boolean;
+}
+
+/**
+ * One line of the candidate list shown when a project pair carries several
+ * relations. Names both ends in the relation's own direction, since that is
+ * how `relations list` prints them, and includes the milestone anchors —
+ * without them two relations of the same type look identical.
+ */
+function describeRelation(node: ProjectRelationCoreFieldsFragment): string {
+  const from = node.projectMilestone
+    ? `${node.project.name}/${node.projectMilestone.name}`
+    : node.project.name;
+  const to = node.relatedProjectMilestone
+    ? `${node.relatedProject.name}/${node.relatedProjectMilestone.name}`
+    : node.relatedProject.name;
+  return `${from} ${node.type} ${to} (${node.id})`;
+}
+
+/**
+ * Resolves a project relation to its UUID.
+ *
+ * Accepts a UUID (returned as-is) or, given both endpoints, finds the
+ * relation between them. Relation IDs never appear in a project read, so
+ * without the pair lookup the only way to name a relation for `update` or
+ * `remove` would be to run `relations list` first and copy an opaque UUID.
+ *
+ * ARCHITECTURAL EXCEPTION: Linear exposes no lean lookup for project
+ * relations. The `projectRelations` root connection accepts no filter
+ * argument at all, so it cannot be narrowed to a project; the only scoped
+ * view is the pair of connections hanging off `Project`. This resolver
+ * therefore reads the same `GetProjectRelations` document the service uses.
+ * Both directions are searched because "the relation between A and B" is one
+ * relation regardless of which project declared it — but the direction that
+ * matched is reported back, because the relation's own fields (`anchorType`,
+ * `projectMilestoneId`) are anchored to its `project`, not to whichever
+ * endpoint the caller happened to type first.
+ *
+ * @throws Error if no relation links the two projects, or if more than one does
+ */
+export async function resolveProjectRelation(
+  client: GraphQLClient,
+  relationOrProjectId: string,
+  relatedProjectId?: UUID,
+): Promise<ResolvedProjectRelation> {
+  if (isUuid(relationOrProjectId) && relatedProjectId === undefined) {
+    return { id: asUuid(relationOrProjectId), inverted: false };
+  }
+
+  if (relatedProjectId === undefined) {
+    throw notFoundError("Project relation", relationOrProjectId);
+  }
+
+  const projectId = asUuid(relationOrProjectId);
+  const result = await client.request(GetProjectRelationsDocument, {
+    projectId,
+    first: PROJECT_RELATION_PAGE_SIZE,
+  });
+
+  if (!result.project) {
+    throw notFoundError("Project", projectId);
+  }
+
+  const matches: {
+    node: ProjectRelationCoreFieldsFragment;
+    inverted: boolean;
+  }[] = [
+    ...result.project.relations.nodes
+      .filter((node) => node.relatedProject.id === relatedProjectId)
+      .map((node) => ({ node, inverted: false })),
+    ...result.project.inverseRelations.nodes
+      .filter((node) => node.project.id === relatedProjectId)
+      .map((node) => ({ node, inverted: true })),
+  ];
+
+  // One pair of projects can carry several relations — different types, or the
+  // same type anchored to different milestones — and they may point either way
+  // round. Picking one would silently update or remove an arbitrary link, so
+  // list them and make the caller name the UUID instead.
+  if (matches.length > 1) {
+    throw multipleMatchesError(
+      "project relation",
+      `between ${projectId} and ${relatedProjectId}`,
+      matches.map((match) => describeRelation(match.node)),
+      "address the relation by UUID",
+    );
+  }
+
+  // Both connections are bounded, and neither accepts a filter
+  // that could narrow them to the counterpart. Past that bound the page tells
+  // us nothing about the rest: no match here may still be a match there, and a
+  // single match here may have a twin there that would have made the pair
+  // ambiguous. Either way the safe answer is to refuse, so this runs before
+  // the single-match return rather than only on zero matches.
+  if (
+    result.project.relations.pageInfo.hasNextPage ||
+    result.project.inverseRelations.pageInfo.hasNextPage
+  ) {
+    throw new Error(
+      `Project "${projectId}" has more than ${PROJECT_RELATION_PAGE_SIZE} ` +
+        `dependencies in one direction, so its links to "${relatedProjectId}" ` +
+        "cannot be listed in full. Find the relation with `projects relations " +
+        "list` and address it by UUID.",
+    );
+  }
+
+  if (matches.length === 0) {
+    throw notFoundError(
+      "Project relation",
+      `between ${projectId} and ${relatedProjectId}`,
+    );
+  }
+
+  const match = firstOrThrow(matches, () =>
+    notFoundError(
+      "Project relation",
+      `between ${projectId} and ${relatedProjectId}`,
+    ),
+  );
+  return { id: asUuid(match.node.id), inverted: match.inverted };
+}
diff --git a/src/resolvers/project-status-resolver.ts b/src/resolvers/project-status-resolver.ts
index a998280b..5185a6f2 100644
--- a/src/resolvers/project-status-resolver.ts
+++ b/src/resolvers/project-status-resolver.ts
@@ -1,35 +1,85 @@
 import type { GraphQLClient } from "../client/graphql-client.js";
-import { notFoundError } from "../common/errors.js";
+import { firstOrThrow } from "../common/array.js";
+import { multipleMatchesError, notFoundError } from "../common/errors.js";
 import { asUuid, isUuid, type UUID } from "../common/identifier.js";
 import { GetProjectStatusesDocument } from "../gql/graphql.js";
 
+/**
+ * How many statuses one lookup reads.
+ *
+ * Stated here rather than left to the query default so the bound and the
+ * message that reports hitting it cannot drift apart.
+ */
+const PROJECT_STATUS_PAGE_SIZE = 250;
+
 /**
  * Resolves project status name to UUID.
  *
  * Accepts UUID (returned as-is) or a status name (case-insensitive match).
  *
- * projectStatuses has no server-side name filter, so this fetches the full
- * (small, fixed) set and matches client-side.
+ * projectStatuses has no server-side name filter, so this fetches the list
+ * and matches client-side. The list is bounded, and a workspace that outgrows
+ * the bound gets a refusal rather than an answer drawn from a partial page.
  *
  * @param client - GraphQL client for querying project statuses
  * @param nameOrId - Status name or UUID
+ * @param options.includeArchived - Search archived statuses too. Needed by
+ *   `projects statuses unarchive`, where the status being named is by
+ *   definition not in the default set.
  * @returns Status UUID
- * @throws Error if status name not found
+ * @throws Error if status name not found, if several statuses share it, or if
+ *   the workspace holds more statuses than one page can carry
  */
 export async function resolveProjectStatusId(
   client: GraphQLClient,
   nameOrId: string,
+  options: { includeArchived?: boolean } = {},
 ): Promise<UUID> {
   if (isUuid(nameOrId)) return asUuid(nameOrId);
 
-  const result = await client.request(GetProjectStatusesDocument);
-  const match = result.projectStatuses.nodes.find(
+  const result = await client.request(GetProjectStatusesDocument, {
+    includeArchived: options.includeArchived ?? false,
+    first: PROJECT_STATUS_PAGE_SIZE,
+  });
+  const matches = result.projectStatuses.nodes.filter(
     (s) => s.name.toLowerCase() === nameOrId.toLowerCase(),
   );
 
-  if (!match) {
+  // Names are only unique among live statuses: archiving one frees its name
+  // for a replacement. With includeArchived the old and the new are both in
+  // the list, and nothing in a name tells them apart, so say which is which
+  // rather than let list order decide what gets updated or unarchived.
+  if (matches.length > 1) {
+    throw multipleMatchesError(
+      "project status",
+      nameOrId,
+      matches.map(
+        (s) => `${s.name}${s.archivedAt ? " (archived)" : ""} (${s.id})`,
+      ),
+      "address the status by UUID",
+    );
+  }
+
+  // The connection is bounded and takes no name filter, so past the bound the
+  // page says nothing about the rest: an unmatched name may live on the next
+  // page, and a lone match may have an archived twin there that would have
+  // made the name ambiguous. Both readings are wrong in a way the caller
+  // cannot see, so refuse before either the not-found or the single-match
+  // return.
+  if (result.projectStatuses.pageInfo.hasNextPage) {
+    throw new Error(
+      `The workspace has more than ${PROJECT_STATUS_PAGE_SIZE} project ` +
+        `statuses, so "${nameOrId}" cannot be matched against the full list. ` +
+        "Find the status with `projects statuses list` and address it by UUID.",
+    );
+  }
+
+  if (matches.length === 0) {
     throw notFoundError("Project status", nameOrId);
   }
 
+  const match = firstOrThrow(matches, () =>
+    notFoundError("Project status", nameOrId),
+  );
   return asUuid(match.id);
 }
diff --git a/src/resolvers/user-resolver.ts b/src/resolvers/user-resolver.ts
index d051099d..40b38b5e 100644
--- a/src/resolvers/user-resolver.ts
+++ b/src/resolvers/user-resolver.ts
@@ -1,14 +1,51 @@
 import type { GraphQLClient } from "../client/graphql-client.js";
 import { multipleMatchesError, notFoundError } from "../common/errors.js";
 import { asUuid, isUuid, type UUID } from "../common/identifier.js";
-import { FindUsersDocument } from "../gql/graphql.js";
+import { FindUsersDocument, GetViewerDocument } from "../gql/graphql.js";
 
+/** Spellings of "the authenticated user" accepted wherever a user is expected. */
+const VIEWER_ALIASES: ReadonlySet<string> = new Set(["me", "@me"]);
+
+/**
+ * True when a user reference names the caller rather than a lookup value.
+ *
+ * Exported for the batch resolvers: they resolve most user references through
+ * a name/email GraphQL filter, and `me` matches neither, so they have to divert
+ * it to {@link resolveViewerId} before building the query.
+ */
+export function isViewerAlias(nameOrEmailOrId: string): boolean {
+  return VIEWER_ALIASES.has(nameOrEmailOrId.toLowerCase());
+}
+
+/**
+ * Resolves the authenticated user's UUID.
+ *
+ * ARCHITECTURAL EXCEPTION: this resolver queries `viewer` directly rather than
+ * going through a lean filter-based lookup. There is no filter that selects
+ * "the caller" — `viewer` is the only way to ask — and the query is already as
+ * lean as it gets (three scalars on a single node).
+ */
+export async function resolveViewerId(client: GraphQLClient): Promise<UUID> {
+  const { viewer } = await client.request(GetViewerDocument);
+  return asUuid(viewer.id);
+}
+
+/**
+ * Resolves a user reference to a UUID.
+ *
+ * Accepts a UUID, a display name, an email address, or `me`/`@me` for the
+ * authenticated user.
+ */
 export async function resolveUserId(
   client: GraphQLClient,
   nameOrEmailOrId: string,
 ): Promise<UUID> {
   if (isUuid(nameOrEmailOrId)) return asUuid(nameOrEmailOrId);
 
+  if (isViewerAlias(nameOrEmailOrId)) {
+    return resolveViewerId(client);
+  }
+
   // Try by display name first (case-insensitive)
   const { users: byName } = await client.request(FindUsersDocument, {
     filter: { displayName: { eqIgnoreCase: nameOrEmailOrId } },
diff --git a/src/services/activity-service.ts b/src/services/activity-service.ts
index f8787733..d6c6239c 100644
--- a/src/services/activity-service.ts
+++ b/src/services/activity-service.ts
@@ -1,5 +1,10 @@
 import type { GraphQLClient } from "../client/graphql-client.js";
 import { asUuid, type UUID } from "../common/identifier.js";
+import {
+  compareTimelineEntries,
+  paginateTimeline,
+  type TimelineEntry,
+} from "../common/timeline.js";
 import { collectConnection } from "../common/types.js";
 import {
   GetIssueActivityRefDocument,
@@ -306,53 +311,12 @@ async function fetchCommentThreadItems(
   return buildCommentThreadItems(roots, candidates);
 }
 
-interface TimelineEntry {
-  createdAt: string;
-  id: string;
-  item: ActivityItem;
-}
-
-function toTimelineEntry(item: ActivityItem): TimelineEntry {
+function toTimelineEntry(item: ActivityItem): TimelineEntry<ActivityItem> {
   return item.type === "history"
     ? { createdAt: item.createdAt, id: item.id, item }
     : { createdAt: item.root.createdAt, id: item.root.id, item };
 }
 
-function compareTimelineEntries(a: TimelineEntry, b: TimelineEntry): number {
-  const byCreatedAt = a.createdAt.localeCompare(b.createdAt);
-  return byCreatedAt !== 0 ? byCreatedAt : a.id.localeCompare(b.id);
-}
-
-interface TimelinePage {
-  nodes: ActivityItem[];
-  hasNextPage: boolean;
-  endCursor: string | null;
-}
-
-/** Slice a sorted timeline using an opaque id cursor (mirrors reply pagination). */
-function paginateTimeline(
-  entries: readonly TimelineEntry[],
-  limit: number,
-  after?: string,
-): TimelinePage {
-  const startIndex =
-    after === undefined
-      ? 0
-      : entries.findIndex((entry) => entry.id === after) + 1;
-
-  if (after !== undefined && startIndex === 0) {
-    throw new Error(`Activity cursor "${after}" not found`);
-  }
-
-  const page = entries.slice(startIndex, startIndex + limit);
-
-  return {
-    nodes: page.map((entry) => entry.item),
-    hasNextPage: startIndex + limit < entries.length,
-    endCursor: page.at(-1)?.id ?? null,
-  };
-}
-
 /**
  * Build a chronological activity timeline for an issue: comment threads (root +
  * nested replies) merged with issue history events, sorted ascending by
diff --git a/src/services/attachment-service.ts b/src/services/attachment-service.ts
index 435f03cb..886b3a90 100644
--- a/src/services/attachment-service.ts
+++ b/src/services/attachment-service.ts
@@ -9,6 +9,8 @@ import {
   type AttachmentCreateInput,
   type AttachmentCreateMutation,
   AttachmentDeleteDocument,
+  AttachmentExternalSyncDisableDocument,
+  type AttachmentExternalSyncDisableMutation,
   type AttachmentFilter,
   ListAttachmentsDocument,
   type ListAttachmentsQuery,
@@ -19,6 +21,9 @@ export type AttachmentListItem =
   ListAttachmentsQuery["issue"]["attachments"]["nodes"][0];
 export type CreatedAttachment =
   AttachmentCreateMutation["attachmentCreate"]["attachment"];
+export type ExternalSyncDisabledIssue = NonNullable<
+  AttachmentExternalSyncDisableMutation["issueExternalSyncDisable"]["issue"]
+>;
 
 // Service-owned input type (UUIDs pre-resolved by the command).
 export type CreateAttachmentInput = BrandUuidFields<
@@ -89,6 +94,28 @@ export async function deleteAttachment(
   return { id: result.attachmentDelete.entityId, success: true };
 }
 
+/**
+ * Stops syncing the issue with the external resource behind an attachment.
+ *
+ * The mutation is `issueExternalSyncDisable`, but it is keyed by attachment
+ * rather than issue, which is why it belongs here and not on the issue
+ * service: one issue can carry several synced attachments.
+ */
+export async function disableExternalSync(
+  client: GraphQLClient,
+  attachmentId: UUID,
+): Promise<ExternalSyncDisabledIssue> {
+  const result = await client.request(AttachmentExternalSyncDisableDocument, {
+    attachmentId,
+  });
+
+  return requireMutationEntity(
+    result.issueExternalSyncDisable,
+    "issue",
+    `Failed to disable external sync for attachment "${attachmentId}"`,
+  );
+}
+
 export async function listAttachments(
   client: GraphQLClient,
   issueId: UUID,
diff --git a/src/services/discussion-service.ts b/src/services/discussion-service.ts
index a04a87b1..4b8ebba6 100644
--- a/src/services/discussion-service.ts
+++ b/src/services/discussion-service.ts
@@ -445,6 +445,45 @@ export async function fetchAllIssueDiscussionReplyCandidatesWithReactions(
   );
 }
 
+/**
+ * The project counterparts of {@link fetchAllIssueDiscussionReplyCandidates},
+ * used by the project activity timeline for the same reason: it resolves the
+ * project up front and has no thread context to derive the entity from.
+ */
+export async function fetchAllProjectDiscussionReplyCandidates(
+  client: GraphQLClient,
+  projectId: UUID,
+): Promise<DiscussionCommentFieldsFragment[]> {
+  const nodes = await collectConnection(async (after) => {
+    const result = await client.request(
+      ListProjectDiscussionReplyCandidatesDocument,
+      { projectId, first: DISCUSSION_REPLY_FETCH_LIMIT, after },
+    );
+
+    return result.comments;
+  });
+
+  return nodes.sort(compareDiscussionCommentsChronologically);
+}
+
+export async function fetchAllProjectDiscussionReplyCandidatesWithReactions(
+  client: GraphQLClient,
+  projectId: UUID,
+): Promise<DiscussionThreadWithReactions[]> {
+  const nodes = await collectConnection(async (after) => {
+    const result = await client.request(
+      ListProjectDiscussionReplyCandidatesWithReactionsDocument,
+      { projectId, first: DISCUSSION_REPLY_FETCH_LIMIT, after },
+    );
+
+    return result.comments;
+  });
+
+  return normalizeDiscussionCommentsReactions(
+    nodes.sort(compareDiscussionCommentsChronologically),
+  );
+}
+
 /**
  * Index reply candidates by their `parentId`, with each sibling list sorted
  * chronologically. Building this once lets callers extract many threads'
diff --git a/src/services/initiative-update-service.ts b/src/services/initiative-update-service.ts
index fd2aa4f4..8c09c9fd 100644
--- a/src/services/initiative-update-service.ts
+++ b/src/services/initiative-update-service.ts
@@ -11,7 +11,6 @@ import {
   GetInitiativeUpdateDocument,
   type GetInitiativeUpdateQuery,
   type InitiativeUpdateCreateInput,
-  type InitiativeUpdateHealthType,
   type InitiativeUpdateUpdateInput,
   ListInitiativeUpdatesDocument,
   type ListInitiativeUpdatesQuery,
@@ -57,22 +56,6 @@ export type UpdateInitiativeUpdateInput = Pick<
   "body" | "health"
 >;
 
-export function parseHealth(
-  value?: string,
-): InitiativeUpdateHealthType | undefined {
-  if (!value) return undefined;
-
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "ontrack") return "onTrack";
-  if (normalized === "atrisk") return "atRisk";
-  if (normalized === "offtrack") return "offTrack";
-
-  throw invalidParameterError(
-    "--health",
-    'must be one of: "onTrack", "atRisk", "offTrack"',
-  );
-}
-
 export async function listInitiativeUpdates(
   client: GraphQLClient,
   options: InitiativeUpdateListOptions,
diff --git a/src/services/issue-filter.ts b/src/services/issue-filter.ts
index c61c0810..f110ce58 100644
--- a/src/services/issue-filter.ts
+++ b/src/services/issue-filter.ts
@@ -63,6 +63,17 @@ export function buildIssueFilter(
   if (options.updatedBefore) {
     fragments.push({ updatedAt: { lt: options.updatedBefore } });
   }
+  if (options.unassigned) {
+    fragments.push({ assignee: { null: true } });
+  }
+  if (options.stateType) {
+    fragments.push({ state: { type: { eq: options.stateType } } });
+  }
+  if (options.subscriberId) {
+    fragments.push({
+      subscribers: { some: { id: { eq: options.subscriberId } } },
+    });
+  }
   if (options.hasBlockers !== undefined) {
     fragments.push({ hasBlockedByRelations: { eq: options.hasBlockers } });
   }
diff --git a/src/services/issue-service.ts b/src/services/issue-service.ts
index 11dca0f4..a6238fe2 100644
--- a/src/services/issue-service.ts
+++ b/src/services/issue-service.ts
@@ -1,14 +1,22 @@
 import type { GraphQLClient } from "../client/graphql-client.js";
 import { firstOrThrow } from "../common/array.js";
+import { notFoundError } from "../common/errors.js";
 import type { BrandUuidFields, UUID } from "../common/identifier.js";
-import { requireMutationEntity } from "../common/mutation-payload.js";
+import {
+  requireMutationEntity,
+  requireMutationSuccess,
+} from "../common/mutation-payload.js";
 import type { PaginatedResult, PaginationOptions } from "../common/types.js";
 import {
   ArchiveIssueDocument,
+  BatchCreateIssuesDocument,
+  type BatchCreateIssuesMutation,
+  BatchUpdateIssuesDocument,
   CreateIssueDocument,
   type CreateIssueMutation,
   DeleteIssueDocument,
   FilteredSearchIssuesDocument,
+  type FilteredSearchIssuesQuery,
   GetIssueByIdDocument,
   GetIssueByIdentifierDocument,
   type GetIssueByIdentifierQuery,
@@ -25,22 +33,27 @@ import {
   type GetIssueByIdWithCommentsQuery,
   GetIssueByIdWithReactionsDocument,
   type GetIssueByIdWithReactionsQuery,
-  GetIssuesDocument,
-  type GetIssuesQuery,
   type IssueCreateInput,
   type IssueFilter,
   type IssueUpdateInput,
+  IssueVcsBranchSearchDocument,
+  type PaginationOrderBy,
+  RemindOnIssueDocument,
   SearchIssuesDocument,
   type SearchIssuesQuery,
   type SearchIssuesQueryVariables,
+  ShareIssueDocument,
+  SubscribeToIssueDocument,
   UnarchiveIssueDocument,
+  UnshareIssueDocument,
+  UnsubscribeFromIssueDocument,
   UpdateIssueDocument,
   type UpdateIssueMutation,
 } from "../gql/graphql.js";
 import { normalizeReactions } from "./reaction-service.js";
 
 // Issue projection types
-export type IssueListItem = GetIssuesQuery["issues"]["nodes"][0];
+export type IssueListItem = FilteredSearchIssuesQuery["issues"]["nodes"][0];
 export type IssueDetail = NonNullable<GetIssueByIdQuery["issue"]>;
 export type IssueByIdentifier = GetIssueByIdentifierQuery["issues"]["nodes"][0];
 export type IssueDetailWithComments = NonNullable<
@@ -78,6 +91,9 @@ export type CreatedIssue = NonNullable<
 export type UpdatedIssue = NonNullable<
   UpdateIssueMutation["issueUpdate"]["issue"]
 >;
+/** An issue as returned by the batch mutations (no comment payload). */
+export type BatchIssue =
+  BatchCreateIssuesMutation["issueBatchCreate"]["issues"][0];
 
 // Service-owned input types (UUIDs pre-resolved by the command).
 export type CreateIssueInput = BrandUuidFields<
@@ -96,6 +112,8 @@ export type CreateIssueInput = BrandUuidFields<
     | "stateId"
     | "parentId"
     | "dueDate"
+    | "subscriberIds"
+    | "delegateId"
   >,
   | "teamId"
   | "assigneeId"
@@ -105,6 +123,8 @@ export type CreateIssueInput = BrandUuidFields<
   | "cycleId"
   | "stateId"
   | "parentId"
+  | "subscriberIds"
+  | "delegateId"
 >;
 export type UpdateIssueInput = BrandUuidFields<
   Pick<
@@ -121,6 +141,11 @@ export type UpdateIssueInput = BrandUuidFields<
     | "projectMilestoneId"
     | "cycleId"
     | "dueDate"
+    | "teamId"
+    | "subscriberIds"
+    | "delegateId"
+    | "snoozedUntilAt"
+    | "trashed"
   >,
   | "stateId"
   | "assigneeId"
@@ -129,8 +154,22 @@ export type UpdateIssueInput = BrandUuidFields<
   | "parentId"
   | "projectMilestoneId"
   | "cycleId"
+  | "teamId"
+  | "subscriberIds"
+  | "delegateId"
 >;
 
+/**
+ * Pagination plus the read-scope knobs shared by `listIssues` and
+ * `searchIssues`. Archived issues are excluded unless asked for, matching the
+ * Linear API default and the historical CLI behavior.
+ */
+export interface IssueReadOptions extends PaginationOptions {
+  includeArchived?: boolean;
+  /** Defaults to `updatedAt` — most-recently-touched first. */
+  orderBy?: PaginationOrderBy;
+}
+
 const NON_COMPLETED_ISSUES_FILTER: IssueFilter = {
   state: { type: { neq: "completed" } },
 };
@@ -147,7 +186,26 @@ function hasExplicitStateFilter(filter: IssueFilter): boolean {
   return filter.or?.some(hasExplicitStateFilter) ?? false;
 }
 
-function buildListIssuesFilter(filter: IssueFilter): IssueFilter {
+/**
+ * Applies the implicit "hide completed work" narrowing that `issues list`
+ * has always had, unless the caller has already said something about state.
+ *
+ * `includeArchived` counts as saying something: archived issues are nearly
+ * always completed or canceled, so keeping the default clause would make
+ * `--include-archived` hide the very issues it was passed to surface.
+ */
+function buildListIssuesFilter(
+  filter: IssueFilter | undefined,
+  includeArchived: boolean,
+): IssueFilter | undefined {
+  if (includeArchived) {
+    return filter;
+  }
+
+  if (!filter) {
+    return NON_COMPLETED_ISSUES_FILTER;
+  }
+
   if (hasExplicitStateFilter(filter)) {
     return filter;
   }
@@ -268,28 +326,25 @@ function normalizeIssueReactions<
 
 export async function listIssues(
   client: GraphQLClient,
-  options: PaginationOptions = {},
+  options: IssueReadOptions = {},
   filter?: IssueFilter,
 ): Promise<PaginatedResult<IssueListItem>> {
-  const { limit = 25, after } = options;
-
-  if (filter) {
-    const result = await client.request(FilteredSearchIssuesDocument, {
-      first: limit,
-      after,
-      filter: buildListIssuesFilter(filter),
-      orderBy: "updatedAt",
-    });
-    return {
-      nodes: result.issues?.nodes ?? [],
-      pageInfo: result.issues.pageInfo,
-    };
-  }
-
-  const result = await client.request(GetIssuesDocument, {
+  const {
+    limit = 25,
+    after,
+    includeArchived = false,
+    orderBy = "updatedAt",
+  } = options;
+
+  // One query for both the filtered and the unfiltered path: the default
+  // state narrowing lives in buildListIssuesFilter, so a query that hardcoded
+  // it could not honor `--include-archived`.
+  const result = await client.request(FilteredSearchIssuesDocument, {
     first: limit,
     after,
-    orderBy: "updatedAt",
+    filter: buildListIssuesFilter(filter, includeArchived),
+    orderBy,
+    includeArchived,
   });
   return {
     nodes: result.issues?.nodes ?? [],
@@ -433,14 +488,15 @@ export async function getIssueByIdentifierWithAttachments(
 export async function searchIssues(
   client: GraphQLClient,
   term: string,
-  options: PaginationOptions = {},
+  options: IssueReadOptions = {},
   filter?: IssueFilter,
 ): Promise<PaginatedResult<IssueSearchResult>> {
-  const { limit = 25, after } = options;
+  const { limit = 25, after, includeArchived = false } = options;
   const variables: SearchIssuesQueryVariables = {
     term,
     first: limit,
     after,
+    includeArchived,
     ...(filter && { filter }),
   };
   const result = await client.request(SearchIssuesDocument, variables);
@@ -450,6 +506,28 @@ export async function searchIssues(
   };
 }
 
+/**
+ * Finds the issue a VCS branch belongs to.
+ *
+ * The reverse of the `branchName` field on a read payload.
+ *
+ * @throws Error if no issue owns the branch
+ */
+export async function findIssueByBranch(
+  client: GraphQLClient,
+  branchName: string,
+): Promise<IssueDetail> {
+  const result = await client.request(IssueVcsBranchSearchDocument, {
+    branchName,
+  });
+
+  if (!result.issueVcsBranchSearch) {
+    throw notFoundError("Issue for branch", branchName);
+  }
+
+  return result.issueVcsBranchSearch;
+}
+
 export async function createIssue(
   client: GraphQLClient,
   input: CreateIssueInput,
@@ -480,6 +558,34 @@ export async function updateIssue(
   );
 }
 
+/**
+ * Restores an issue from the trash.
+ *
+ * `issues delete` maps to `issueDelete`, which trashes rather than destroys;
+ * `trashed: false` is the only way back, and `issueUnarchive` does not cover it
+ * — archiving and trashing are separate states.
+ */
+export async function restoreIssue(
+  client: GraphQLClient,
+  id: UUID,
+): Promise<UpdatedIssue> {
+  return updateIssue(client, id, { trashed: false });
+}
+
+/**
+ * Snoozes an issue until an instant, or wakes it with `null`.
+ *
+ * `snoozedById` is left to the API, which attributes the snooze to the
+ * authenticated user.
+ */
+export async function snoozeIssue(
+  client: GraphQLClient,
+  id: UUID,
+  snoozedUntilAt: string | null,
+): Promise<UpdatedIssue> {
+  return updateIssue(client, id, { snoozedUntilAt });
+}
+
 export async function archiveIssue(
   client: GraphQLClient,
   id: UUID,
@@ -506,6 +612,139 @@ export async function unarchiveIssue(
   );
 }
 
+/**
+ * Creates many issues in one `issueBatchCreate` transaction.
+ *
+ * Ordering of the returned issues follows the API response, which need not
+ * match the input order — callers should key off `identifier`/`title` rather
+ * than position.
+ */
+export async function batchCreateIssues(
+  client: GraphQLClient,
+  inputs: readonly CreateIssueInput[],
+): Promise<BatchIssue[]> {
+  const issues: IssueCreateInput[] = [...inputs];
+  const result = await client.request(BatchCreateIssuesDocument, {
+    input: { issues },
+  });
+
+  requireMutationSuccess(
+    result.issueBatchCreate,
+    `Failed to create ${inputs.length} issues`,
+  );
+
+  return result.issueBatchCreate.issues;
+}
+
+/** Applies one patch to every issue in an explicit UUID list. */
+export async function batchUpdateIssues(
+  client: GraphQLClient,
+  ids: readonly UUID[],
+  input: UpdateIssueInput,
+): Promise<BatchIssue[]> {
+  const gqlInput: IssueUpdateInput = input;
+  const result = await client.request(BatchUpdateIssuesDocument, {
+    ids: [...ids],
+    input: gqlInput,
+  });
+
+  requireMutationSuccess(
+    result.issueBatchUpdate,
+    `Failed to update ${ids.length} issues`,
+  );
+
+  return result.issueBatchUpdate.issues;
+}
+
+/**
+ * Adds a user to an issue's subscriber list.
+ *
+ * `issueSubscribe` also accepts `userEmail`, but the CLI resolves user
+ * references to UUIDs in the resolver layer, so only `userId` is used.
+ */
+export async function subscribeToIssue(
+  client: GraphQLClient,
+  id: UUID,
+  userId: UUID,
+): Promise<UpdatedIssue> {
+  const result = await client.request(SubscribeToIssueDocument, { id, userId });
+
+  return requireMutationEntity(
+    result.issueSubscribe,
+    "issue",
+    `Failed to subscribe user "${userId}" to issue "${id}"`,
+  );
+}
+
+export async function unsubscribeFromIssue(
+  client: GraphQLClient,
+  id: UUID,
+  userId: UUID,
+): Promise<UpdatedIssue> {
+  const result = await client.request(UnsubscribeFromIssueDocument, {
+    id,
+    userId,
+  });
+
+  return requireMutationEntity(
+    result.issueUnsubscribe,
+    "issue",
+    `Failed to unsubscribe user "${userId}" from issue "${id}"`,
+  );
+}
+
+/**
+ * Grants a user access to an issue they cannot otherwise see.
+ *
+ * Note this is an access grant, not a link generator — the issue's permalink
+ * is the `url` field on any read payload.
+ */
+export async function shareIssue(
+  client: GraphQLClient,
+  id: UUID,
+  userId: UUID,
+): Promise<UpdatedIssue> {
+  const result = await client.request(ShareIssueDocument, { id, userId });
+
+  return requireMutationEntity(
+    result.issueShare,
+    "issue",
+    `Failed to share issue "${id}" with user "${userId}"`,
+  );
+}
+
+export async function unshareIssue(
+  client: GraphQLClient,
+  id: UUID,
+  userId: UUID,
+): Promise<UpdatedIssue> {
+  const result = await client.request(UnshareIssueDocument, { id, userId });
+
+  return requireMutationEntity(
+    result.issueUnshare,
+    "issue",
+    `Failed to unshare issue "${id}" from user "${userId}"`,
+  );
+}
+
+/** Schedules a reminder for the authenticated user at an ISO-8601 instant. */
+export async function remindOnIssue(
+  client: GraphQLClient,
+  id: UUID,
+  reminderAt: string,
+): Promise<UpdatedIssue> {
+  const result = await client.request(RemindOnIssueDocument, {
+    id,
+    reminderAt,
+  });
+
+  return requireMutationEntity(
+    result.issueReminder,
+    "issue",
+    `Failed to set a reminder on issue "${id}"`,
+  );
+}
+
 export async function deleteIssue(
   client: GraphQLClient,
   id: UUID,
diff --git a/src/services/label-service.ts b/src/services/label-service.ts
index b1a5c251..4f11620b 100644
--- a/src/services/label-service.ts
+++ b/src/services/label-service.ts
@@ -4,14 +4,22 @@ import { requireMutationSuccess } from "../common/mutation-payload.js";
 import type { PaginatedResult, PaginationOptions } from "../common/types.js";
 import {
   CreateIssueLabelDocument,
+  CreateProjectLabelDocument,
   DeleteIssueLabelDocument,
+  DeleteProjectLabelDocument,
   GetIssueLabelDocument,
   GetLabelsDocument,
+  GetProjectLabelDocument,
   GetProjectLabelsDocument,
   type IssueLabelCreateInput,
   type IssueLabelFilter,
   type IssueLabelUpdateInput,
+  RestoreIssueLabelDocument,
+  RestoreProjectLabelDocument,
+  RetireIssueLabelDocument,
+  RetireProjectLabelDocument,
   UpdateIssueLabelDocument,
+  UpdateProjectLabelDocument,
 } from "../gql/graphql.js";
 
 export type LabelType = "issue" | "project";
@@ -23,6 +31,11 @@ export interface Label {
   color: string;
   description?: string;
   type: LabelType;
+  /** True when the label is a container for child labels rather than a tag. */
+  isGroup: boolean;
+  /** Set while the label is retired: still readable, not applicable. */
+  retiredAt?: string;
+  parent?: { id: string; name: string };
 }
 
 export interface DeleteLabelResult {
@@ -34,50 +47,96 @@ export interface ListLabelOptions extends PaginationOptions {
   scope?: LabelScope;
 }
 
-// Service-owned input types (UUIDs pre-resolved by the command).
+/**
+ * Service-owned input types (UUIDs pre-resolved by the command).
+ *
+ * `IssueLabelCreateInput` and `ProjectLabelCreateInput` declare the same
+ * fields, so one input type covers both. `ProjectLabelCreateInput.teamId` is
+ * marked `[Internal]` and scopes the label to a team when set; the CLI creates
+ * project labels at workspace scope only, so the project path drops it.
+ */
 export type CreateLabelInput = BrandUuidFields<
-  Pick<IssueLabelCreateInput, "name" | "teamId" | "color" | "description">,
-  "teamId"
+  Pick<
+    IssueLabelCreateInput,
+    "name" | "teamId" | "color" | "description" | "parentId" | "isGroup"
+  >,
+  "teamId" | "parentId"
 >;
-export type UpdateLabelInput = Pick<
-  IssueLabelUpdateInput,
-  "name" | "color" | "description"
+export type UpdateLabelInput = BrandUuidFields<
+  Pick<
+    IssueLabelUpdateInput,
+    "name" | "color" | "description" | "parentId" | "isGroup"
+  >,
+  "parentId"
 >;
 
-function mapIssueLabel(label: {
+/** The shape both `IssueLabel` and `ProjectLabel` fragments select. */
+interface LabelNode {
   id: string;
   name: string;
   color: string;
   description?: string | null;
-}): Label {
+  isGroup: boolean;
+  retiredAt?: string | null;
+  parent?: { id: string; name: string } | null;
+}
+
+function mapLabel(label: LabelNode, type: LabelType): Label {
   return {
     id: label.id,
     name: label.name,
     color: label.color,
-    type: "issue",
+    type,
+    isGroup: label.isGroup,
     ...(label.description != null ? { description: label.description } : {}),
+    ...(label.retiredAt != null ? { retiredAt: label.retiredAt } : {}),
+    ...(label.parent != null ? { parent: label.parent } : {}),
   };
 }
 
 export async function getLabel(
   client: GraphQLClient,
   id: UUID,
+  type: LabelType = "issue",
 ): Promise<Label> {
-  const result = await client.request(GetIssueLabelDocument, {
-    id,
-  });
+  if (type === "project") {
+    const result = await client.request(GetProjectLabelDocument, { id });
+
+    if (!result.projectLabel) {
+      throw new Error(`Project label with ID "${id}" not found`);
+    }
+
+    return mapLabel(result.projectLabel, "project");
+  }
+
+  const result = await client.request(GetIssueLabelDocument, { id });
 
   if (!result.issueLabel) {
     throw new Error(`Label with ID "${id}" not found`);
   }
 
-  return mapIssueLabel(result.issueLabel);
+  return mapLabel(result.issueLabel, "issue");
 }
 
 export async function createLabel(
   client: GraphQLClient,
   input: CreateLabelInput,
+  type: LabelType = "issue",
 ): Promise<Label> {
+  if (type === "project") {
+    const { teamId: _workspaceScopedOnly, ...projectInput } = input;
+    const result = await client.request(CreateProjectLabelDocument, {
+      input: projectInput,
+    });
+
+    requireMutationSuccess(
+      result.projectLabelCreate,
+      `Failed to create project label "${input.name}"`,
+    );
+
+    return mapLabel(result.projectLabelCreate.projectLabel, "project");
+  }
+
   const gqlInput: IssueLabelCreateInput = input;
   const result = await client.request(CreateIssueLabelDocument, {
     input: gqlInput,
@@ -88,14 +147,29 @@ export async function createLabel(
     `Failed to create label "${input.name}"`,
   );
 
-  return mapIssueLabel(result.issueLabelCreate.issueLabel);
+  return mapLabel(result.issueLabelCreate.issueLabel, "issue");
 }
 
 export async function updateLabel(
   client: GraphQLClient,
   id: UUID,
   input: UpdateLabelInput,
+  type: LabelType = "issue",
 ): Promise<Label> {
+  if (type === "project") {
+    const result = await client.request(UpdateProjectLabelDocument, {
+      id,
+      input,
+    });
+
+    requireMutationSuccess(
+      result.projectLabelUpdate,
+      `Failed to update project label "${id}"`,
+    );
+
+    return mapLabel(result.projectLabelUpdate.projectLabel, "project");
+  }
+
   const gqlInput: IssueLabelUpdateInput = input;
   const result = await client.request(UpdateIssueLabelDocument, {
     id,
@@ -107,13 +181,25 @@ export async function updateLabel(
     `Failed to update label "${id}"`,
   );
 
-  return mapIssueLabel(result.issueLabelUpdate.issueLabel);
+  return mapLabel(result.issueLabelUpdate.issueLabel, "issue");
 }
 
 export async function deleteLabel(
   client: GraphQLClient,
   id: UUID,
+  type: LabelType = "issue",
 ): Promise<DeleteLabelResult> {
+  if (type === "project") {
+    const result = await client.request(DeleteProjectLabelDocument, { id });
+
+    requireMutationSuccess(
+      result.projectLabelDelete,
+      `Failed to delete project label "${id}"`,
+    );
+
+    return { id: result.projectLabelDelete.entityId, success: true };
+  }
+
   const result = await client.request(DeleteIssueLabelDocument, { id });
 
   requireMutationSuccess(
@@ -127,6 +213,62 @@ export async function deleteLabel(
   };
 }
 
+/**
+ * Retires a label: it stays on whatever already carries it, but cannot be
+ * applied to anything new. The reversible alternative to deleting.
+ */
+export async function retireLabel(
+  client: GraphQLClient,
+  id: UUID,
+  type: LabelType = "issue",
+): Promise<Label> {
+  if (type === "project") {
+    const result = await client.request(RetireProjectLabelDocument, { id });
+
+    requireMutationSuccess(
+      result.projectLabelRetire,
+      `Failed to retire project label "${id}"`,
+    );
+
+    return mapLabel(result.projectLabelRetire.projectLabel, "project");
+  }
+
+  const result = await client.request(RetireIssueLabelDocument, { id });
+
+  requireMutationSuccess(
+    result.issueLabelRetire,
+    `Failed to retire label "${id}"`,
+  );
+
+  return mapLabel(result.issueLabelRetire.issueLabel, "issue");
+}
+
+export async function restoreLabel(
+  client: GraphQLClient,
+  id: UUID,
+  type: LabelType = "issue",
+): Promise<Label> {
+  if (type === "project") {
+    const result = await client.request(RestoreProjectLabelDocument, { id });
+
+    requireMutationSuccess(
+      result.projectLabelRestore,
+      `Failed to restore project label "${id}"`,
+    );
+
+    return mapLabel(result.projectLabelRestore.projectLabel, "project");
+  }
+
+  const result = await client.request(RestoreIssueLabelDocument, { id });
+
+  requireMutationSuccess(
+    result.issueLabelRestore,
+    `Failed to restore label "${id}"`,
+  );
+
+  return mapLabel(result.issueLabelRestore.issueLabel, "issue");
+}
+
 function buildIssueLabelFilter(
   teamId?: UUID,
   scope?: LabelScope,
@@ -161,7 +303,7 @@ export async function listLabels(
   });
 
   return {
-    nodes: result.issueLabels.nodes.map((label) => mapIssueLabel(label)),
+    nodes: result.issueLabels.nodes.map((label) => mapLabel(label, "issue")),
     pageInfo: result.issueLabels.pageInfo,
   };
 }
@@ -178,16 +320,8 @@ export async function listProjectLabels(
   });
 
   return {
-    nodes: result.projectLabels.nodes.map(
-      (label): Label => ({
-        id: label.id,
-        name: label.name,
-        color: label.color,
-        type: "project",
-        ...(label.description != null
-          ? { description: label.description }
-          : {}),
-      }),
+    nodes: result.projectLabels.nodes.map((label) =>
+      mapLabel(label, "project"),
     ),
     pageInfo: result.projectLabels.pageInfo,
   };
diff --git a/src/services/project-activity-service.ts b/src/services/project-activity-service.ts
new file mode 100644
index 00000000..5775bde8
--- /dev/null
+++ b/src/services/project-activity-service.ts
@@ -0,0 +1,273 @@
+import type { GraphQLClient } from "../client/graphql-client.js";
+import { asUuid, type UUID } from "../common/identifier.js";
+import {
+  compareTimelineEntries,
+  paginateTimeline,
+  type TimelineEntry,
+} from "../common/timeline.js";
+import { collectConnection } from "../common/types.js";
+import {
+  GetProjectActivityRefDocument,
+  ListProjectActivityHistoryDocument,
+  ListProjectActivityUpdatesDocument,
+  ListProjectDiscussionRootsDocument,
+  ListProjectDiscussionRootsWithReactionsDocument,
+  type ProjectUpdateCoreFieldsFragment,
+} from "../gql/graphql.js";
+import {
+  buildThreadRepliesIndex,
+  collectThreadReplies,
+  type DiscussionThread,
+  type DiscussionThreadWithReactions,
+  fetchAllProjectDiscussionReplyCandidates,
+  fetchAllProjectDiscussionReplyCandidatesWithReactions,
+  normalizeDiscussionCommentsReactions,
+} from "./discussion-service.js";
+
+/** Page size used when exhausting a connection to build the merged timeline. */
+const TIMELINE_FETCH_LIMIT = 250;
+/** Default number of top-level timeline items returned per page. */
+const DEFAULT_ACTIVITY_LIMIT = 50;
+
+/**
+ * A project history event.
+ *
+ * `entries` is passed through verbatim. `ProjectHistory.entries` is an
+ * opaque `JSONObject!`, not the ~40 typed `from*`/`to*` fields
+ * `IssueHistory` carries, so there is nothing to normalize into the
+ * `changes[]` union `issues activity` produces. `ProjectHistory` also has
+ * no actor field, so there is no `actor` here either.
+ */
+interface ProjectActivityHistoryItem {
+  type: "history";
+  id: string;
+  createdAt: string;
+  entries: unknown;
+}
+
+interface ProjectActivityUpdateItem {
+  type: "update";
+  id: string;
+  createdAt: string;
+  update: ProjectUpdateCoreFieldsFragment;
+}
+
+interface ProjectActivityCommentThreadItem<
+  TComment extends DiscussionThread | DiscussionThreadWithReactions,
+> {
+  type: "commentThread";
+  root: TComment;
+  replies: TComment[];
+}
+
+type ProjectActivityItem =
+  | ProjectActivityHistoryItem
+  | ProjectActivityUpdateItem
+  | ProjectActivityCommentThreadItem<DiscussionThread>
+  | ProjectActivityCommentThreadItem<DiscussionThreadWithReactions>;
+
+export interface ProjectActivityResult {
+  project: { id: string; name: string };
+  activity: ProjectActivityItem[];
+  pageInfo: { hasNextPage: boolean; endCursor: string | null };
+}
+
+export interface ProjectActivityOptions {
+  limit?: number;
+  after?: string;
+  /** Drop history and status updates, leaving only discussion threads. */
+  commentsOnly?: boolean;
+  withReactions?: boolean;
+}
+
+async function fetchAllProjectDiscussionRoots(
+  client: GraphQLClient,
+  projectId: UUID,
+): Promise<DiscussionThread[]> {
+  return collectConnection(async (after) => {
+    const result = await client.request(ListProjectDiscussionRootsDocument, {
+      projectId,
+      first: TIMELINE_FETCH_LIMIT,
+      after,
+    });
+
+    if (!result.project) {
+      throw new Error(`Project with ID "${projectId}" not found`);
+    }
+
+    return result.project.comments;
+  });
+}
+
+async function fetchAllProjectDiscussionRootsWithReactions(
+  client: GraphQLClient,
+  projectId: UUID,
+): Promise<DiscussionThreadWithReactions[]> {
+  const nodes = await collectConnection(async (after) => {
+    const result = await client.request(
+      ListProjectDiscussionRootsWithReactionsDocument,
+      { projectId, first: TIMELINE_FETCH_LIMIT, after },
+    );
+
+    if (!result.project) {
+      throw new Error(`Project with ID "${projectId}" not found`);
+    }
+
+    return result.project.comments;
+  });
+
+  return normalizeDiscussionCommentsReactions(nodes);
+}
+
+async function fetchAllProjectHistory(
+  client: GraphQLClient,
+  projectId: UUID,
+): Promise<ProjectActivityHistoryItem[]> {
+  const nodes = await collectConnection(async (after) => {
+    const result = await client.request(ListProjectActivityHistoryDocument, {
+      id: projectId,
+      first: TIMELINE_FETCH_LIMIT,
+      after,
+    });
+
+    if (!result.project) {
+      throw new Error(`Project with ID "${projectId}" not found`);
+    }
+
+    return result.project.history;
+  });
+
+  return nodes.map((node) => ({
+    type: "history" as const,
+    id: node.id,
+    createdAt: node.createdAt,
+    entries: node.entries,
+  }));
+}
+
+async function fetchAllProjectUpdates(
+  client: GraphQLClient,
+  projectId: UUID,
+): Promise<ProjectActivityUpdateItem[]> {
+  const nodes = await collectConnection(async (after) => {
+    const result = await client.request(ListProjectActivityUpdatesDocument, {
+      projectId,
+      first: TIMELINE_FETCH_LIMIT,
+      after,
+    });
+
+    return result.projectUpdates;
+  });
+
+  return nodes.map((node) => ({
+    type: "update" as const,
+    id: node.id,
+    createdAt: node.createdAt,
+    update: node,
+  }));
+}
+
+/** Assemble comment-thread timeline items from root threads and reply candidates. */
+function buildCommentThreadItems<
+  TComment extends DiscussionThread | DiscussionThreadWithReactions,
+>(
+  roots: readonly TComment[],
+  candidates: readonly TComment[],
+): ProjectActivityCommentThreadItem<TComment>[] {
+  const childrenByParentId = buildThreadRepliesIndex(candidates);
+  return roots.map((root) => ({
+    type: "commentThread" as const,
+    root,
+    replies: collectThreadReplies(childrenByParentId, asUuid(root.id)),
+  }));
+}
+
+/**
+ * Fetch a project's comment threads. Roots and reply candidates are
+ * independent connections, so they are exhausted concurrently.
+ */
+async function fetchCommentThreadItems(
+  client: GraphQLClient,
+  projectId: UUID,
+  withReactions: boolean,
+): Promise<ProjectActivityItem[]> {
+  if (withReactions) {
+    const [roots, candidates] = await Promise.all([
+      fetchAllProjectDiscussionRootsWithReactions(client, projectId),
+      fetchAllProjectDiscussionReplyCandidatesWithReactions(client, projectId),
+    ]);
+    return buildCommentThreadItems(roots, candidates);
+  }
+
+  const [roots, candidates] = await Promise.all([
+    fetchAllProjectDiscussionRoots(client, projectId),
+    fetchAllProjectDiscussionReplyCandidates(client, projectId),
+  ]);
+  return buildCommentThreadItems(roots, candidates);
+}
+
+function toTimelineEntry(
+  item: ProjectActivityItem,
+): TimelineEntry<ProjectActivityItem> {
+  return item.type === "commentThread"
+    ? { createdAt: item.root.createdAt, id: item.root.id, item }
+    : { createdAt: item.createdAt, id: item.id, item };
+}
+
+/**
+ * Build a chronological activity timeline for a project: comment threads
+ * (root + nested replies), history events, and status updates, sorted
+ * ascending by creation time and paginated with an opaque id cursor.
+ *
+ * The envelope and flags match `issues activity`, but the item shape does
+ * not. History items carry Linear's opaque `entries` object rather than the
+ * normalized `changes[]` union — see {@link ProjectActivityHistoryItem}.
+ *
+ * The timeline is materialized in full on every call before it is sliced.
+ * The three connections are independent (Linear exposes no unified activity
+ * connection) and reply nesting needs all reply candidates regardless of the
+ * requested page. As a stateless CLI there is no cross-invocation cache, so
+ * each `--after` page re-fetches everything.
+ */
+export async function getProjectActivity(
+  client: GraphQLClient,
+  projectId: UUID,
+  options: ProjectActivityOptions = {},
+): Promise<ProjectActivityResult> {
+  const {
+    limit = DEFAULT_ACTIVITY_LIMIT,
+    after,
+    commentsOnly = false,
+    withReactions = false,
+  } = options;
+
+  const ref = await client.request(GetProjectActivityRefDocument, {
+    id: projectId,
+  });
+
+  if (!ref.project) {
+    throw new Error(`Project with ID "${projectId}" not found`);
+  }
+
+  const [threadItems, historyItems, updateItems] = await Promise.all([
+    fetchCommentThreadItems(client, projectId, withReactions),
+    commentsOnly
+      ? Promise.resolve<ProjectActivityHistoryItem[]>([])
+      : fetchAllProjectHistory(client, projectId),
+    commentsOnly
+      ? Promise.resolve<ProjectActivityUpdateItem[]>([])
+      : fetchAllProjectUpdates(client, projectId),
+  ]);
+
+  const entries = [...threadItems, ...historyItems, ...updateItems]
+    .map(toTimelineEntry)
+    .sort(compareTimelineEntries);
+
+  const page = paginateTimeline(entries, limit, after);
+
+  return {
+    project: { id: ref.project.id, name: ref.project.name },
+    activity: page.nodes,
+    pageInfo: { hasNextPage: page.hasNextPage, endCursor: page.endCursor },
+  };
+}
diff --git a/src/services/project-relation-service.ts b/src/services/project-relation-service.ts
new file mode 100644
index 00000000..4b5c4b9f
--- /dev/null
+++ b/src/services/project-relation-service.ts
@@ -0,0 +1,207 @@
+import type { GraphQLClient } from "../client/graphql-client.js";
+import { notFoundError } from "../common/errors.js";
+import type { UUID } from "../common/identifier.js";
+import {
+  requireMutationEntity,
+  requireMutationSuccess,
+} from "../common/mutation-payload.js";
+import type { PaginatedResult, PaginationOptions } from "../common/types.js";
+import {
+  CreateProjectRelationDocument,
+  type CreateProjectRelationMutation,
+  DeleteProjectRelationDocument,
+  GetProjectRelationDocument,
+  GetProjectRelationsDocument,
+  type GetProjectRelationsQuery,
+  ListAllProjectRelationsDocument,
+  type ProjectRelationCoreFieldsFragment,
+  UpdateProjectRelationDocument,
+  type UpdateProjectRelationMutation,
+} from "../gql/graphql.js";
+
+/**
+ * The literal Linear stores in `ProjectRelation.type`.
+ *
+ * The schema declares it as a bare `String!` with no enum, unlike
+ * `IssueRelationType`. Every relation observed on a live workspace carried
+ * `"dependency"`, and Linear's UI exposes no other kind of project link, so
+ * the CLI writes that one value rather than offering a flag whose accepted
+ * range nobody can enumerate.
+ */
+const PROJECT_RELATION_TYPE = "dependency";
+
+/**
+ * Rows read from each direction of a project's dependencies.
+ *
+ * Neither connection accepts a cursor the CLI could surface — `relations list`
+ * reports `truncated` instead — so this bound is the whole read. 100 covers
+ * any realistic project while keeping the query inside Linear's complexity
+ * budget.
+ */
+const PROJECT_RELATION_PAGE_SIZE = 100;
+
+/**
+ * Which end of a project a relation attaches to.
+ *
+ * Also untyped `String!` in the schema. `"start"` and `"end"` are the values
+ * observed live; they describe a point in time, not project-versus-milestone.
+ * A milestone is selected separately, through `projectMilestoneId`.
+ */
+export type ProjectRelationAnchor = "start" | "end";
+
+export const PROJECT_RELATION_ANCHORS = [
+  "start",
+  "end",
+] as const satisfies readonly ProjectRelationAnchor[];
+
+type ProjectRelation = ProjectRelationCoreFieldsFragment;
+export type CreatedProjectRelation = NonNullable<
+  CreateProjectRelationMutation["projectRelationCreate"]["projectRelation"]
+>;
+export type UpdatedProjectRelation = NonNullable<
+  UpdateProjectRelationMutation["projectRelationUpdate"]["projectRelation"]
+>;
+
+type ProjectRelationsProject = NonNullable<GetProjectRelationsQuery["project"]>;
+
+export interface ProjectRelationsResult {
+  project: { id: string; name: string };
+  /** Dependencies this project declares. */
+  relations: ProjectRelation[];
+  /** Dependencies other projects declare on this one. */
+  inverseRelations: ProjectRelation[];
+  /** True when either connection was cut off at `PROJECT_RELATION_PAGE_SIZE`. */
+  truncated: boolean;
+}
+
+export interface CreateProjectRelationInput {
+  projectId: UUID;
+  relatedProjectId: UUID;
+  anchorType: ProjectRelationAnchor;
+  relatedAnchorType: ProjectRelationAnchor;
+  projectMilestoneId?: UUID;
+  relatedProjectMilestoneId?: UUID;
+}
+
+export interface UpdateProjectRelationInput {
+  anchorType?: ProjectRelationAnchor;
+  relatedAnchorType?: ProjectRelationAnchor;
+  /** `null` detaches the relation from its milestone. */
+  projectMilestoneId?: UUID | null;
+  relatedProjectMilestoneId?: UUID | null;
+}
+
+async function fetchProjectRelations(
+  client: GraphQLClient,
+  projectId: UUID,
+): Promise<ProjectRelationsProject> {
+  const result = await client.request(GetProjectRelationsDocument, {
+    projectId,
+    first: PROJECT_RELATION_PAGE_SIZE,
+  });
+
+  if (!result.project) {
+    throw notFoundError("Project", projectId);
+  }
+
+  return result.project;
+}
+
+export async function listProjectRelations(
+  client: GraphQLClient,
+  projectId: UUID,
+): Promise<ProjectRelationsResult> {
+  const project = await fetchProjectRelations(client, projectId);
+
+  return {
+    project: { id: project.id, name: project.name },
+    relations: project.relations.nodes,
+    inverseRelations: project.inverseRelations.nodes,
+    truncated:
+      project.relations.pageInfo.hasNextPage ||
+      project.inverseRelations.pageInfo.hasNextPage,
+  };
+}
+
+export async function getProjectRelation(
+  client: GraphQLClient,
+  id: UUID,
+): Promise<ProjectRelation> {
+  const result = await client.request(GetProjectRelationDocument, { id });
+
+  if (!result.projectRelation) {
+    throw notFoundError("Project relation", id);
+  }
+
+  return result.projectRelation;
+}
+
+/**
+ * Every dependency in the workspace.
+ *
+ * The root connection accepts no filter, so this cannot be narrowed to one
+ * project — {@link listProjectRelations} covers that. Useful when the
+ * question is "what depends on what" rather than "what does this depend on".
+ */
+export async function listAllProjectRelations(
+  client: GraphQLClient,
+  options: PaginationOptions = {},
+): Promise<PaginatedResult<ProjectRelation>> {
+  const { limit = 50, after } = options;
+
+  const result = await client.request(ListAllProjectRelationsDocument, {
+    first: limit,
+    after,
+  });
+
+  return {
+    nodes: result.projectRelations.nodes,
+    pageInfo: result.projectRelations.pageInfo,
+  };
+}
+
+export async function createProjectRelation(
+  client: GraphQLClient,
+  input: CreateProjectRelationInput,
+): Promise<CreatedProjectRelation> {
+  const result = await client.request(CreateProjectRelationDocument, {
+    input: { ...input, type: PROJECT_RELATION_TYPE },
+  });
+
+  return requireMutationEntity(
+    result.projectRelationCreate,
+    "projectRelation",
+    `Failed to relate project "${input.projectId}" to "${input.relatedProjectId}"`,
+  );
+}
+
+export async function updateProjectRelation(
+  client: GraphQLClient,
+  id: UUID,
+  input: UpdateProjectRelationInput,
+): Promise<UpdatedProjectRelation> {
+  const result = await client.request(UpdateProjectRelationDocument, {
+    id,
+    input,
+  });
+
+  return requireMutationEntity(
+    result.projectRelationUpdate,
+    "projectRelation",
+    `Failed to update project relation "${id}"`,
+  );
+}
+
+export async function deleteProjectRelation(
+  client: GraphQLClient,
+  id: UUID,
+): Promise<{ id: string; success: true }> {
+  const result = await client.request(DeleteProjectRelationDocument, { id });
+
+  requireMutationSuccess(
+    result.projectRelationDelete,
+    `Failed to delete project relation "${id}"`,
+  );
+
+  return { id: result.projectRelationDelete.entityId, success: true };
+}
diff --git a/src/services/project-service.ts b/src/services/project-service.ts
index 4482d3c2..7ac3469c 100644
--- a/src/services/project-service.ts
+++ b/src/services/project-service.ts
@@ -1,27 +1,28 @@
 import type { GraphQLClient } from "../client/graphql-client.js";
-import {
-  asUuid,
-  type BrandUuidFields,
-  type UUID,
-} from "../common/identifier.js";
+import type { BrandUuidFields, UUID } from "../common/identifier.js";
 import {
   requireMutationEntity,
   requireMutationSuccess,
 } from "../common/mutation-payload.js";
 import type { PaginatedResult, PaginationOptions } from "../common/types.js";
 import {
-  ArchiveProjectDocument,
-  type ArchiveProjectMutation,
+  AddProjectLabelDocument,
+  type AddProjectLabelMutation,
   CreateProjectDocument,
   type CreateProjectMutation,
   DeleteProjectDocument,
+  DisableProjectExternalSyncDocument,
+  type DisableProjectExternalSyncMutation,
+  type ExternalSyncService,
   GetProjectDocument,
-  GetProjectLabelIdsDocument,
   type GetProjectQuery,
   GetProjectsDocument,
   type GetProjectsQuery,
   type ProjectCreateInput,
   type ProjectUpdateInput,
+  RemoveProjectLabelDocument,
+  SearchProjectsDocument,
+  type SearchProjectsQuery,
   UnarchiveProjectDocument,
   type UnarchiveProjectMutation,
   UpdateProjectDocument,
@@ -37,12 +38,17 @@ export type CreatedProject = NonNullable<
 export type UpdatedProject = NonNullable<
   UpdateProjectMutation["projectUpdate"]["project"]
 >;
-export type ArchivedProject = NonNullable<
-  ArchiveProjectMutation["projectArchive"]["entity"]
->;
 export type UnarchivedProject = NonNullable<
   UnarchiveProjectMutation["projectUnarchive"]["entity"]
 >;
+export type ProjectSearchResult =
+  SearchProjectsQuery["searchProjects"]["nodes"][0];
+export type LabelledProject = NonNullable<
+  AddProjectLabelMutation["projectAddLabel"]["project"]
+>;
+export type SyncDisabledProject = NonNullable<
+  DisableProjectExternalSyncMutation["projectExternalSyncDisable"]["project"]
+>;
 export type DeletedProject = {
   id: string;
   success: true;
@@ -92,6 +98,11 @@ export interface ProjectListOptions extends PaginationOptions {
   includeArchived?: boolean;
 }
 
+export interface ProjectSearchOptions extends ProjectListOptions {
+  /** Narrows the search to projects owned by one team. */
+  teamId?: UUID;
+}
+
 export interface ProjectDetailOptions {
   milestonesFirst?: number;
   issuesFirst?: number;
@@ -125,6 +136,34 @@ export async function listProjects(
   };
 }
 
+/**
+ * Full-text search across projects.
+ *
+ * Results come back relevance-ordered from the API, so there is no
+ * `orderBy` knob — supplying one would discard the ranking that makes the
+ * search worth running. Mirrors `searchIssues`.
+ */
+export async function searchProjects(
+  client: GraphQLClient,
+  term: string,
+  options: ProjectSearchOptions = {},
+): Promise<PaginatedResult<ProjectSearchResult>> {
+  const { limit = 25, after, includeArchived = false, teamId } = options;
+
+  const result = await client.request(SearchProjectsDocument, {
+    term,
+    first: limit,
+    after,
+    includeArchived,
+    teamId,
+  });
+
+  return {
+    nodes: result.searchProjects.nodes,
+    pageInfo: result.searchProjects.pageInfo,
+  };
+}
+
 export async function getProject(
   client: GraphQLClient,
   id: UUID,
@@ -149,28 +188,6 @@ export async function getProject(
   return result.project;
 }
 
-export async function getProjectLabelIds(
-  client: GraphQLClient,
-  id: UUID,
-): Promise<UUID[]> {
-  const result = await client.request(GetProjectLabelIdsDocument, { id });
-
-  if (!result.project) {
-    throw new Error(`Project with ID "${id}" not found`);
-  }
-
-  // labelIds is a full-replacement input on projectUpdate; merging from a
-  // truncated read would silently delete every label past the page limit.
-  if (result.project.labels.pageInfo.hasNextPage) {
-    throw new Error(
-      `Project with ID "${id}" has more labels than a single read can ` +
-        "return; refusing to modify labels from a truncated label set",
-    );
-  }
-
-  return result.project.labels.nodes.map((label) => asUuid(label.id));
-}
-
 export async function createProject(
   client: GraphQLClient,
   input: CreateProjectInput,
@@ -205,19 +222,54 @@ export async function updateProject(
   );
 }
 
-export async function archiveProject(
+/**
+ * Adds or removes labels one at a time.
+ *
+ * `projectAddLabel`/`projectRemoveLabel` are incremental, so unlike the
+ * full-replacement `labelIds` input they need no read of the project's
+ * current labels and cannot drop labels this call never saw. Each mutation
+ * takes a single label, so a multi-label request is a sequence; it runs in
+ * order rather than concurrently, which leaves a comprehensible prefix
+ * applied if one of them fails.
+ *
+ * Returns the project as of the last mutation.
+ */
+export async function applyProjectLabels(
   client: GraphQLClient,
   id: UUID,
-): Promise<ArchivedProject> {
-  const result = await client.request(ArchiveProjectDocument, { id });
+  labelIds: UUID[],
+  mode: "add" | "remove",
+): Promise<LabelledProject> {
+  let project: LabelledProject | undefined;
 
-  return requireMutationEntity(
-    result.projectArchive,
-    "entity",
-    `Failed to archive project "${id}"`,
-  );
+  for (const labelId of labelIds) {
+    const payload =
+      mode === "add"
+        ? (await client.request(AddProjectLabelDocument, { id, labelId }))
+            .projectAddLabel
+        : (await client.request(RemoveProjectLabelDocument, { id, labelId }))
+            .projectRemoveLabel;
+
+    project = requireMutationEntity(
+      payload,
+      "project",
+      `Failed to ${mode} label "${labelId}" on project "${id}"`,
+    );
+  }
+
+  if (!project) {
+    throw new Error(`No labels given to ${mode} on project "${id}"`);
+  }
+
+  return project;
 }
 
+/**
+ * Restores a project from the trash.
+ *
+ * Linear has one put-away state for projects, so this is the inverse of
+ * {@link deleteProject} — there is no separate archived state to restore from.
+ */
 export async function unarchiveProject(
   client: GraphQLClient,
   id: UUID,
@@ -231,6 +283,32 @@ export async function unarchiveProject(
   );
 }
 
+/**
+ * Stops one external tracker from pushing updates into the project.
+ *
+ * The link itself survives; only the sync stops. Mirrors the attachment
+ * equivalent.
+ */
+export async function disableProjectExternalSync(
+  client: GraphQLClient,
+  projectId: UUID,
+  syncSource: ExternalSyncService,
+): Promise<SyncDisabledProject> {
+  const result = await client.request(DisableProjectExternalSyncDocument, {
+    projectId,
+    syncSource,
+  });
+
+  return requireMutationEntity(
+    result.projectExternalSyncDisable,
+    "project",
+    `Failed to disable ${syncSource} sync on project "${projectId}"`,
+  );
+}
+
+/**
+ * Trashes a project. Reversible via {@link unarchiveProject}.
+ */
 export async function deleteProject(
   client: GraphQLClient,
   id: UUID,
diff --git a/src/services/project-status-service.ts b/src/services/project-status-service.ts
new file mode 100644
index 00000000..658c28ac
--- /dev/null
+++ b/src/services/project-status-service.ts
@@ -0,0 +1,246 @@
+import type { GraphQLClient } from "../client/graphql-client.js";
+import { invalidParameterError } from "../common/errors.js";
+import type { UUID } from "../common/identifier.js";
+import { requireMutationEntity } from "../common/mutation-payload.js";
+import {
+  ArchiveProjectStatusDocument,
+  type ArchiveProjectStatusMutation,
+  CreateProjectStatusDocument,
+  type CreateProjectStatusMutation,
+  GetProjectStatusDocument,
+  GetProjectStatusProjectCountDocument,
+  type GetProjectStatusProjectCountQuery,
+  type GetProjectStatusQuery,
+  ListProjectStatusesDocument,
+  type ListProjectStatusesQuery,
+  type ProjectStatusCreateInput,
+  type ProjectStatusUpdateInput,
+  ReassignProjectStatusDocument,
+  UnarchiveProjectStatusDocument,
+  type UnarchiveProjectStatusMutation,
+  UpdateProjectStatusDocument,
+  type UpdateProjectStatusMutation,
+} from "../gql/graphql.js";
+
+/**
+ * How many statuses one page of the flow carries.
+ *
+ * Raises the API's default of 50, which a workspace with a long archive can
+ * pass. Stated here rather than left to the query default so the bound and
+ * the message that reports hitting it cannot drift apart.
+ */
+const PROJECT_STATUS_PAGE_SIZE = 250;
+
+// Project status projection types
+type ProjectStatusListItem =
+  ListProjectStatusesQuery["projectStatuses"]["nodes"][0];
+export type ProjectStatusDetail = NonNullable<
+  GetProjectStatusQuery["projectStatus"]
+> & {
+  projectCount: GetProjectStatusProjectCountQuery["projectStatusProjectCount"];
+};
+export type CreatedProjectStatus = NonNullable<
+  CreateProjectStatusMutation["projectStatusCreate"]["status"]
+>;
+export type UpdatedProjectStatus = NonNullable<
+  UpdateProjectStatusMutation["projectStatusUpdate"]["status"]
+>;
+export type ArchivedProjectStatus = NonNullable<
+  ArchiveProjectStatusMutation["projectStatusArchive"]["entity"]
+>;
+export type UnarchivedProjectStatus = NonNullable<
+  UnarchiveProjectStatusMutation["projectStatusUnarchive"]["entity"]
+>;
+
+// Service-owned input types. Project statuses carry no UUID references,
+// so these are the codegen inputs unchanged apart from `position`.
+export type CreateProjectStatusInput = Omit<
+  ProjectStatusCreateInput,
+  "id" | "position"
+> & {
+  /** Omitted places the status last in the workspace flow. */
+  position?: number;
+};
+export type UpdateProjectStatusInput = ProjectStatusUpdateInput;
+
+export interface ProjectStatusListResult {
+  nodes: ProjectStatusListItem[];
+  /** True when the workspace holds more statuses than one page carries. */
+  truncated: boolean;
+}
+
+export async function listProjectStatuses(
+  client: GraphQLClient,
+  includeArchived = false,
+): Promise<ProjectStatusListResult> {
+  const result = await client.request(ListProjectStatusesDocument, {
+    includeArchived,
+    first: PROJECT_STATUS_PAGE_SIZE,
+  });
+
+  return {
+    nodes: result.projectStatuses.nodes,
+    truncated: result.projectStatuses.pageInfo.hasNextPage,
+  };
+}
+
+/**
+ * Reads one status together with how many projects sit in it.
+ *
+ * The count is what decides whether {@link archiveProjectStatus} will be
+ * refused, so returning the status without it would leave callers making a
+ * second call they cannot know they need.
+ */
+export async function getProjectStatus(
+  client: GraphQLClient,
+  id: UUID,
+): Promise<ProjectStatusDetail> {
+  const [statusResult, countResult] = await Promise.all([
+    client.request(GetProjectStatusDocument, { id }),
+    client.request(GetProjectStatusProjectCountDocument, { id }),
+  ]);
+
+  if (!statusResult.projectStatus) {
+    throw new Error(`Project status with ID "${id}" not found`);
+  }
+
+  return {
+    ...statusResult.projectStatus,
+    projectCount: countResult.projectStatusProjectCount,
+  };
+}
+
+/**
+ * Appends a status to the end of the workspace flow.
+ *
+ * `position` is required by the API but rarely what a caller has in mind, so
+ * an omitted position reads the current flow and takes the next slot.
+ *
+ * Archived statuses are counted: they keep their position and can be
+ * unarchived at any time, so skipping them would hand the new status a
+ * position that an archived one already holds.
+ *
+ * A truncated page defeats that reasoning for the same reason — the statuses
+ * it left out are exactly the ones whose positions would collide — so it is
+ * refused rather than turned into a position that looks free and is not.
+ */
+async function nextProjectStatusPosition(
+  client: GraphQLClient,
+): Promise<number> {
+  const { nodes, truncated } = await listProjectStatuses(client, true);
+
+  if (truncated) {
+    throw new Error(
+      `The workspace has more than ${PROJECT_STATUS_PAGE_SIZE} project ` +
+        "statuses, so the end of the flow cannot be found. Pass an explicit " +
+        "`--position` to place the new status.",
+    );
+  }
+
+  const highest = nodes.reduce(
+    (max, status) => Math.max(max, status.position),
+    0,
+  );
+
+  return highest + 1;
+}
+
+export async function createProjectStatus(
+  client: GraphQLClient,
+  input: CreateProjectStatusInput,
+): Promise<CreatedProjectStatus> {
+  const { position, ...rest } = input;
+  const gqlInput: ProjectStatusCreateInput = {
+    ...rest,
+    position: position ?? (await nextProjectStatusPosition(client)),
+  };
+
+  const result = await client.request(CreateProjectStatusDocument, {
+    input: gqlInput,
+  });
+
+  return requireMutationEntity(
+    result.projectStatusCreate,
+    "status",
+    `Failed to create project status "${input.name}"`,
+  );
+}
+
+export async function updateProjectStatus(
+  client: GraphQLClient,
+  id: UUID,
+  input: UpdateProjectStatusInput,
+): Promise<UpdatedProjectStatus> {
+  const hasAtLeastOneField = Object.values(input).some(
+    (value) => value !== undefined,
+  );
+
+  if (!hasAtLeastOneField) {
+    throw invalidParameterError(
+      "update options",
+      "at least one update field must be provided",
+    );
+  }
+
+  const result = await client.request(UpdateProjectStatusDocument, {
+    id,
+    input,
+  });
+
+  return requireMutationEntity(
+    result.projectStatusUpdate,
+    "status",
+    `Failed to update project status "${id}"`,
+  );
+}
+
+/**
+ * Moves every project off one status and onto another.
+ *
+ * Exposed only through `projects statuses archive --reassign-to`, because
+ * Linear marks the mutation `[INTERNAL]` and reassignment on its own is not
+ * a task anyone sets out to do.
+ */
+export async function reassignProjectStatus(
+  client: GraphQLClient,
+  originalProjectStatusId: UUID,
+  newProjectStatusId: UUID,
+): Promise<void> {
+  const result = await client.request(ReassignProjectStatusDocument, {
+    originalProjectStatusId,
+    newProjectStatusId,
+  });
+
+  if (!result.projectReassignStatus.success) {
+    throw new Error(
+      `Failed to reassign projects from status "${originalProjectStatusId}" ` +
+        `to "${newProjectStatusId}"`,
+    );
+  }
+}
+
+export async function archiveProjectStatus(
+  client: GraphQLClient,
+  id: UUID,
+): Promise<ArchivedProjectStatus> {
+  const result = await client.request(ArchiveProjectStatusDocument, { id });
+
+  return requireMutationEntity(
+    result.projectStatusArchive,
+    "entity",
+    `Failed to archive project status "${id}"`,
+  );
+}
+
+export async function unarchiveProjectStatus(
+  client: GraphQLClient,
+  id: UUID,
+): Promise<UnarchivedProjectStatus> {
+  const result = await client.request(UnarchiveProjectStatusDocument, { id });
+
+  return requireMutationEntity(
+    result.projectStatusUnarchive,
+    "entity",
+    `Failed to unarchive project status "${id}"`,
+  );
+}
diff --git a/src/services/project-update-service.ts b/src/services/project-update-service.ts
new file mode 100644
index 00000000..4605a8e0
--- /dev/null
+++ b/src/services/project-update-service.ts
@@ -0,0 +1,193 @@
+import type { GraphQLClient } from "../client/graphql-client.js";
+import { invalidParameterError } from "../common/errors.js";
+import type { BrandUuidFields, UUID } from "../common/identifier.js";
+import { requireMutationEntity } from "../common/mutation-payload.js";
+import type { PaginatedResult } from "../common/types.js";
+import {
+  ArchiveProjectUpdateDocument,
+  type ArchiveProjectUpdateMutation,
+  CreateProjectUpdateDocument,
+  type CreateProjectUpdateMutation,
+  CreateProjectUpdateReminderDocument,
+  EditProjectUpdateDocument,
+  type EditProjectUpdateMutation,
+  GetProjectUpdateDocument,
+  type GetProjectUpdateQuery,
+  ListProjectUpdatesDocument,
+  type ListProjectUpdatesQuery,
+  type ProjectUpdateCreateInput,
+  type ProjectUpdateUpdateInput,
+  UnarchiveProjectUpdateDocument,
+  type UnarchiveProjectUpdateMutation,
+} from "../gql/graphql.js";
+
+// Project update projection types
+export type ProjectUpdateListItem =
+  ListProjectUpdatesQuery["projectUpdates"]["nodes"][0];
+export type ProjectUpdateDetail = NonNullable<
+  GetProjectUpdateQuery["projectUpdate"]
+>;
+export type CreatedProjectUpdate = NonNullable<
+  CreateProjectUpdateMutation["projectUpdateCreate"]["projectUpdate"]
+>;
+export type EditedProjectUpdate = NonNullable<
+  EditProjectUpdateMutation["projectUpdateUpdate"]["projectUpdate"]
+>;
+export type ArchivedProjectUpdate = NonNullable<
+  ArchiveProjectUpdateMutation["projectUpdateArchive"]["entity"]
+>;
+export type UnarchivedProjectUpdate = NonNullable<
+  UnarchiveProjectUpdateMutation["projectUpdateUnarchive"]["entity"]
+>;
+export type ProjectUpdateReminder = {
+  projectId: string;
+  success: true;
+};
+
+export interface ProjectUpdateListOptions {
+  projectId: UUID;
+  limit?: number;
+  after?: string;
+  includeArchived?: boolean;
+}
+
+// Service-owned input types (UUIDs pre-resolved by the command).
+export type CreateProjectUpdateInput = BrandUuidFields<
+  Pick<
+    ProjectUpdateCreateInput,
+    "projectId" | "body" | "health" | "isDiffHidden"
+  >,
+  "projectId"
+>;
+export type EditProjectUpdateInput = Pick<
+  ProjectUpdateUpdateInput,
+  "body" | "health"
+>;
+
+export async function listProjectUpdates(
+  client: GraphQLClient,
+  options: ProjectUpdateListOptions,
+): Promise<PaginatedResult<ProjectUpdateListItem>> {
+  const { projectId, limit = 50, after, includeArchived = false } = options;
+
+  const result = await client.request(ListProjectUpdatesDocument, {
+    projectId,
+    first: limit,
+    after,
+    includeArchived,
+  });
+
+  return {
+    nodes: result.projectUpdates.nodes,
+    pageInfo: result.projectUpdates.pageInfo,
+  };
+}
+
+export async function getProjectUpdate(
+  client: GraphQLClient,
+  id: UUID,
+): Promise<ProjectUpdateDetail> {
+  const result = await client.request(GetProjectUpdateDocument, { id });
+
+  if (!result.projectUpdate) {
+    throw new Error(`Project update with ID "${id}" not found`);
+  }
+
+  return result.projectUpdate;
+}
+
+export async function createProjectUpdate(
+  client: GraphQLClient,
+  input: CreateProjectUpdateInput,
+): Promise<CreatedProjectUpdate> {
+  const gqlInput: ProjectUpdateCreateInput = input;
+  const result = await client.request(CreateProjectUpdateDocument, {
+    input: gqlInput,
+  });
+
+  return requireMutationEntity(
+    result.projectUpdateCreate,
+    "projectUpdate",
+    "Failed to create project update",
+  );
+}
+
+export async function editProjectUpdate(
+  client: GraphQLClient,
+  id: UUID,
+  input: EditProjectUpdateInput,
+): Promise<EditedProjectUpdate> {
+  const hasAtLeastOneField = Object.values(input).some(
+    (value) => value !== undefined,
+  );
+
+  if (!hasAtLeastOneField) {
+    throw invalidParameterError(
+      "update options",
+      "at least one update field must be provided",
+    );
+  }
+
+  const gqlInput: ProjectUpdateUpdateInput = input;
+  const result = await client.request(EditProjectUpdateDocument, {
+    id,
+    input: gqlInput,
+  });
+
+  return requireMutationEntity(
+    result.projectUpdateUpdate,
+    "projectUpdate",
+    `Failed to update project update "${id}"`,
+  );
+}
+
+export async function archiveProjectUpdate(
+  client: GraphQLClient,
+  id: UUID,
+): Promise<ArchivedProjectUpdate> {
+  const result = await client.request(ArchiveProjectUpdateDocument, { id });
+
+  return requireMutationEntity(
+    result.projectUpdateArchive,
+    "entity",
+    `Failed to archive project update "${id}"`,
+  );
+}
+
+export async function unarchiveProjectUpdate(
+  client: GraphQLClient,
+  id: UUID,
+): Promise<UnarchivedProjectUpdate> {
+  const result = await client.request(UnarchiveProjectUpdateDocument, { id });
+
+  return requireMutationEntity(
+    result.projectUpdateUnarchive,
+    "entity",
+    `Failed to unarchive project update "${id}"`,
+  );
+}
+
+/**
+ * Asks Linear to notify someone that the project is due an update.
+ *
+ * The payload carries no entity, so the project is echoed back to keep the
+ * JSON self-describing rather than returning a bare `{ success: true }`.
+ */
+export async function remindProjectUpdate(
+  client: GraphQLClient,
+  projectId: UUID,
+  userId?: UUID,
+): Promise<ProjectUpdateReminder> {
+  const result = await client.request(CreateProjectUpdateReminderDocument, {
+    projectId,
+    userId,
+  });
+
+  if (!result.createProjectUpdateReminder.success) {
+    throw new Error(
+      `Failed to create an update reminder for project "${projectId}"`,
+    );
+  }
+
+  return { projectId, success: true };
+}
diff --git a/tests/types/semantic-release-plugins.d.ts b/tests/types/semantic-release-plugins.d.ts
new file mode 100644
index 00000000..e5e60465
--- /dev/null
+++ b/tests/types/semantic-release-plugins.d.ts
@@ -0,0 +1,12 @@
+/**
+ * Minimal ambient types for the semantic-release plugins exercised by the
+ * release tests. The upstream packages ship no declarations, and we only call
+ * a single entry point, so a hand-written surface is cheaper (and clearer)
+ * than pulling in a full third-party type dependency.
+ */
+declare module "@semantic-release/release-notes-generator" {
+  export function generateNotes(
+    pluginConfig: Record<string, unknown>,
+    context: Record<string, unknown>,
+  ): Promise<string>;
+}
diff --git a/tests/unit/commands/issues-batch-schema.test.ts b/tests/unit/commands/issues-batch-schema.test.ts
new file mode 100644
index 00000000..b812d139
--- /dev/null
+++ b/tests/unit/commands/issues-batch-schema.test.ts
@@ -0,0 +1,139 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import {
+  CLEARABLE_PATCH_KEYS,
+  KNOWN_ENTRY_KEYS,
+  KNOWN_PATCH_KEYS,
+  parseBatchCreateEntries,
+  parseBatchUpdateDocument,
+} from "../../../src/commands/issues-batch.js";
+
+/**
+ * The published schemas are the contract callers write their batch documents
+ * against, so they have to stay in step with the parsers that actually accept
+ * them. Nothing at runtime reads a schema — these tests are the only thing
+ * standing between a new field and a schema that silently rejects it.
+ */
+
+const schemaPath = (name: string): string =>
+  fileURLToPath(new URL(`../../../schemas/${name}`, import.meta.url));
+
+const SCHEMA_PATH = schemaPath("issues-batch-create.schema.json");
+
+interface BatchCreateSchema {
+  $defs: {
+    entry: {
+      properties: Record<string, unknown>;
+      required: string[];
+      additionalProperties: boolean;
+      dependentRequired: Record<string, string[]>;
+    };
+  };
+  examples: unknown[];
+}
+
+const schema = JSON.parse(
+  readFileSync(SCHEMA_PATH, "utf8"),
+) as BatchCreateSchema;
+const entry = schema.$defs.entry;
+
+describe("issues-batch-create.schema.json", () => {
+  it("describes exactly the keys the parser accepts", () => {
+    expect(Object.keys(entry.properties).sort()).toEqual(
+      [...KNOWN_ENTRY_KEYS].sort(),
+    );
+  });
+
+  it("rejects unknown keys, as the parser does", () => {
+    expect(entry.additionalProperties).toBe(false);
+  });
+
+  it("requires the same fields the parser requires", () => {
+    expect(entry.required.sort()).toEqual(["team", "title"]);
+  });
+
+  it("ties projectMilestone to project, as the parser does", () => {
+    expect(entry.dependentRequired).toEqual({ projectMilestone: ["project"] });
+  });
+
+  it("only documents examples the parser accepts", () => {
+    for (const example of schema.examples) {
+      expect(() =>
+        parseBatchCreateEntries(JSON.stringify(example)),
+      ).not.toThrow();
+    }
+  });
+});
+
+interface SchemaBranch {
+  type?: string;
+  $ref?: string;
+}
+
+interface BatchUpdateSchema {
+  required: string[];
+  additionalProperties: boolean;
+  $defs: {
+    patch: {
+      properties: Record<string, SchemaBranch & { oneOf?: SchemaBranch[] }>;
+      additionalProperties: boolean;
+      minProperties: number;
+    };
+  };
+  examples: unknown[];
+}
+
+const updateSchema = JSON.parse(
+  readFileSync(schemaPath("issues-batch-update.schema.json"), "utf8"),
+) as BatchUpdateSchema;
+const patch = updateSchema.$defs.patch;
+
+/**
+ * A property is clearable when the schema lets `null` through — either as an
+ * inline `oneOf` branch or via the shared `nullableString` definition.
+ */
+const acceptsNull = (name: string): boolean => {
+  const property = updateSchema.$defs.patch.properties[name];
+  const branches = [property, ...(property?.oneOf ?? [])];
+
+  return branches.some(
+    (branch) =>
+      branch?.type === "null" || branch?.$ref === "#/$defs/nullableString",
+  );
+};
+
+describe("issues-batch-update.schema.json", () => {
+  it("describes exactly the patch keys the parser accepts", () => {
+    expect(Object.keys(patch.properties).sort()).toEqual(
+      [...KNOWN_PATCH_KEYS].sort(),
+    );
+  });
+
+  it("rejects unknown keys at both levels, as the parser does", () => {
+    expect(updateSchema.additionalProperties).toBe(false);
+    expect(patch.additionalProperties).toBe(false);
+  });
+
+  it("requires the targets and a patch that changes something", () => {
+    expect(updateSchema.required.sort()).toEqual(["issues", "patch"]);
+    expect(patch.minProperties).toBe(1);
+  });
+
+  it("allows null on exactly the fields the parser lets you clear", () => {
+    // A schema that accepted null on a non-clearable field would wave through a
+    // document the CLI then rejects; one that refused null on a clearable field
+    // would flag a document that works.
+    expect(Object.keys(patch.properties).filter(acceptsNull).sort()).toEqual(
+      [...CLEARABLE_PATCH_KEYS].sort(),
+    );
+  });
+
+  it("only documents examples the parser accepts", () => {
+    for (const example of updateSchema.examples) {
+      expect(() =>
+        parseBatchUpdateDocument(JSON.stringify(example)),
+      ).not.toThrow();
+    }
+  });
+});
diff --git a/tests/unit/commands/issues-batch.test.ts b/tests/unit/commands/issues-batch.test.ts
new file mode 100644
index 00000000..f98d0668
--- /dev/null
+++ b/tests/unit/commands/issues-batch.test.ts
@@ -0,0 +1,489 @@
+import { describe, expect, it, vi } from "vitest";
+import type { GraphQLClient } from "../../../src/client/graphql-client.js";
+import {
+  buildBatchUpdateContext,
+  buildBatchUpdateInput,
+  parseBatchCreateEntries,
+  parseBatchUpdateDocument,
+  validateBatchUpdateEstimate,
+} from "../../../src/commands/issues-batch.js";
+import { asUuid } from "../../../src/common/identifier.js";
+import type { ResolvedIssueRef } from "../../../src/resolvers/issue-resolver.js";
+
+describe("parseBatchCreateEntries", () => {
+  it("accepts the single-issue flag names as keys", () => {
+    const entries = parseBatchCreateEntries(
+      JSON.stringify([
+        {
+          title: "Fix login",
+          team: "ENG",
+          assignee: "alice",
+          priority: 2,
+          estimate: 3,
+          project: "Auth",
+          projectMilestone: "Beta",
+          labels: ["bug", "urgent"],
+          cycle: "Cycle 4",
+          status: "Todo",
+          parentTicket: "ENG-1",
+          description: "body",
+          dueDate: "2026-09-01",
+          subscribers: ["bob"],
+          delegate: "carol",
+        },
+      ]),
+    );
+
+    expect(entries).toEqual([
+      {
+        title: "Fix login",
+        team: "ENG",
+        assignee: "alice",
+        priority: 2,
+        estimate: 3,
+        project: "Auth",
+        projectMilestone: "Beta",
+        labels: ["bug", "urgent"],
+        cycle: "Cycle 4",
+        status: "Todo",
+        parentTicket: "ENG-1",
+        description: "body",
+        dueDate: "2026-09-01",
+        subscribers: ["bob"],
+        delegate: "carol",
+      },
+    ]);
+  });
+
+  it("accepts labels and subscribers in the comma-separated flag form", () => {
+    const [entry] = parseBatchCreateEntries(
+      JSON.stringify([
+        {
+          title: "T",
+          team: "ENG",
+          labels: "bug, urgent",
+          subscribers: "bob, carol",
+        },
+      ]),
+    );
+
+    expect(entry?.labels).toEqual(["bug", "urgent"]);
+    expect(entry?.subscribers).toEqual(["bob", "carol"]);
+  });
+
+  it("locates the entry when a comma-separated list has empty segments", () => {
+    // parseCommaSeparated speaks in flags: on its own it reports a bare
+    // "comma-separated list", which in a hundred-entry document says nothing
+    // about where to look.
+    expect(() =>
+      parseBatchCreateEntries(
+        JSON.stringify([
+          { title: "A", team: "ENG" },
+          { title: "B", team: "ENG", labels: "a,,b" },
+        ]),
+      ),
+    ).toThrow(/batch document entry 1: has "labels" with empty segments/);
+  });
+
+  it("names the offending key when a list is not a list of strings", () => {
+    expect(() =>
+      parseBatchCreateEntries(
+        JSON.stringify([{ title: "T", team: "ENG", subscribers: [1] }]),
+      ),
+    ).toThrow(/entry 0: has "subscribers" that is not a non-empty array/);
+  });
+
+  it("rejects an unknown key rather than dropping it", () => {
+    // A typo that silently created the whole batch without the assignee would
+    // be much harder to unpick than a rejected command.
+    expect(() =>
+      parseBatchCreateEntries(
+        JSON.stringify([{ title: "T", team: "ENG", assingee: "alice" }]),
+      ),
+    ).toThrow(/entry 0: has unknown key "assingee"/);
+  });
+
+  it("requires title and team on every entry, naming the entry", () => {
+    expect(() =>
+      parseBatchCreateEntries(
+        JSON.stringify([{ title: "T", team: "ENG" }, { title: "U" }]),
+      ),
+    ).toThrow(/entry 1: requires a non-empty string "team"/);
+  });
+
+  it("requires a project alongside a milestone", () => {
+    expect(() =>
+      parseBatchCreateEntries(
+        JSON.stringify([{ title: "T", team: "ENG", projectMilestone: "Beta" }]),
+      ),
+    ).toThrow(/entry 0: has projectMilestone without project/);
+  });
+
+  it("validates due dates with the same parser as the flag", () => {
+    expect(() =>
+      parseBatchCreateEntries(
+        JSON.stringify([{ title: "T", team: "ENG", dueDate: "01-09-2026" }]),
+      ),
+    ).toThrow(/Invalid due date format/);
+  });
+
+  it("rejects an out-of-range priority", () => {
+    expect(() =>
+      parseBatchCreateEntries(
+        JSON.stringify([{ title: "T", team: "ENG", priority: 9 }]),
+      ),
+    ).toThrow(/entry 0: has "priority" outside the allowed range/);
+  });
+
+  it("rejects documents that are not a non-empty array of objects", () => {
+    expect(() => parseBatchCreateEntries("not json")).toThrow(
+      /is not valid JSON/,
+    );
+    expect(() => parseBatchCreateEntries('{"title":"T"}')).toThrow(
+      /must be a JSON array of issue objects/,
+    );
+    expect(() => parseBatchCreateEntries("[]")).toThrow(/must not be empty/);
+    expect(() => parseBatchCreateEntries("[1]")).toThrow(
+      /entry 0: must be an object/,
+    );
+  });
+});
+
+describe("parseBatchUpdateDocument", () => {
+  it("reads the targets and the patch, mirroring the update flags", () => {
+    expect(
+      parseBatchUpdateDocument(
+        JSON.stringify({
+          issues: ["ENG-1", "ENG-2"],
+          patch: {
+            title: "New title",
+            description: "body",
+            status: "In Progress",
+            priority: 2,
+            estimate: 3,
+            assignee: "alice",
+            project: "Auth",
+            projectMilestone: "Beta",
+            labels: ["bug", "urgent"],
+            parentTicket: "ENG-9",
+            cycle: "current",
+            dueDate: "2026-09-01",
+          },
+        }),
+      ),
+    ).toEqual({
+      issues: ["ENG-1", "ENG-2"],
+      patch: {
+        title: "New title",
+        description: "body",
+        status: "In Progress",
+        priority: 2,
+        estimate: 3,
+        assignee: "alice",
+        project: "Auth",
+        projectMilestone: "Beta",
+        labels: ["bug", "urgent"],
+        parentTicket: "ENG-9",
+        cycle: "current",
+        dueDate: "2026-09-01",
+      },
+    });
+  });
+
+  it("reads null as the clear that the --clear-* flags express", () => {
+    const { patch } = parseBatchUpdateDocument(
+      JSON.stringify({
+        issues: "ENG-1,ENG-2",
+        patch: {
+          assignee: null,
+          project: null,
+          labels: null,
+          parentTicket: null,
+          projectMilestone: null,
+          cycle: null,
+          estimate: null,
+          dueDate: null,
+        },
+      }),
+    );
+
+    expect(patch).toEqual({
+      assignee: null,
+      project: null,
+      labels: null,
+      parentTicket: null,
+      projectMilestone: null,
+      cycle: null,
+      estimate: null,
+      dueDate: null,
+    });
+  });
+
+  it("refuses to clear a field that has no clear flag", () => {
+    // Linear has no empty state for a title, so a null there is a mistake the
+    // caller wants to hear about rather than a no-op applied to every issue.
+    expect(() =>
+      parseBatchUpdateDocument(
+        JSON.stringify({ issues: ["ENG-1"], patch: { title: null } }),
+      ),
+    ).toThrow(/patch: cannot clear "title" with null/);
+  });
+
+  it("rejects an unknown patch key rather than dropping it", () => {
+    expect(() =>
+      parseBatchUpdateDocument(
+        JSON.stringify({ issues: ["ENG-1"], patch: { assingee: "alice" } }),
+      ),
+    ).toThrow(/patch: has unknown key "assingee"/);
+  });
+
+  it("requires a project alongside a milestone", () => {
+    expect(() =>
+      parseBatchUpdateDocument(
+        JSON.stringify({
+          issues: ["ENG-1"],
+          patch: { projectMilestone: "Beta" },
+        }),
+      ),
+    ).toThrow(/patch: has projectMilestone without project/);
+
+    // Clearing the project takes the milestone with it, so naming both is a
+    // contradiction rather than a shorthand.
+    expect(() =>
+      parseBatchUpdateDocument(
+        JSON.stringify({
+          issues: ["ENG-1"],
+          patch: { project: null, projectMilestone: "Beta" },
+        }),
+      ),
+    ).toThrow(/patch: has projectMilestone without project/);
+  });
+
+  it("rejects a patch with nothing to change", () => {
+    expect(() =>
+      parseBatchUpdateDocument(
+        JSON.stringify({ issues: ["ENG-1"], patch: {} }),
+      ),
+    ).toThrow(/patch: needs at least one field to change/);
+  });
+
+  it("validates due dates and priorities as the flags do", () => {
+    expect(() =>
+      parseBatchUpdateDocument(
+        JSON.stringify({ issues: ["ENG-1"], patch: { dueDate: "01-09-2026" } }),
+      ),
+    ).toThrow(/Invalid due date format/);
+
+    expect(() =>
+      parseBatchUpdateDocument(
+        JSON.stringify({ issues: ["ENG-1"], patch: { priority: 9 } }),
+      ),
+    ).toThrow(/patch: has "priority" outside the allowed range/);
+  });
+
+  it("rejects documents that are not an issues/patch object", () => {
+    expect(() => parseBatchUpdateDocument("not json")).toThrow(
+      /is not valid JSON/,
+    );
+    expect(() => parseBatchUpdateDocument("[]")).toThrow(
+      /must be a JSON object with "issues" and "patch"/,
+    );
+    expect(() =>
+      parseBatchUpdateDocument(JSON.stringify({ patch: { title: "T" } })),
+    ).toThrow(/requires "issues"/);
+    expect(() =>
+      parseBatchUpdateDocument(JSON.stringify({ issues: ["ENG-1"] })),
+    ).toThrow(/requires "patch" as an object/);
+    expect(() =>
+      parseBatchUpdateDocument(
+        JSON.stringify({ issues: ["ENG-1"], patch: {}, extra: 1 }),
+      ),
+    ).toThrow(/batch document: has unknown key "extra"/);
+    expect(() =>
+      parseBatchUpdateDocument(
+        JSON.stringify({ issues: [], patch: { title: "T" } }),
+      ),
+    ).toThrow(/has "issues" that is not a non-empty array/);
+  });
+});
+
+describe("buildBatchUpdateContext", () => {
+  const target = (teamKey: string): ResolvedIssueRef => ({
+    ref: `${teamKey}-1`,
+    id: asUuid("11111111-1111-4111-8111-111111111111"),
+    teamId: asUuid("22222222-2222-4222-8222-222222222222"),
+    teamKey,
+  });
+
+  it("scopes lookups to the only team when all targets share one", () => {
+    const context = buildBatchUpdateContext([target("ENG"), target("ENG")], {
+      status: "Todo",
+    });
+
+    expect(context).toEqual({
+      teamId: asUuid("22222222-2222-4222-8222-222222222222"),
+      teamKey: "ENG",
+    });
+  });
+
+  it("rejects a named status or cycle spanning teams", () => {
+    for (const patch of [{ status: "Todo" }, { cycle: "Cycle 4" }]) {
+      expect(() =>
+        buildBatchUpdateContext([target("ENG"), target("OPS")], patch),
+      ).toThrow(/cannot be resolved by name across teams ENG, OPS/);
+    }
+  });
+
+  it("rejects named labels spanning teams", () => {
+    // Labels can be team-scoped, so two teams may each own a "bug"; the name
+    // lookup takes the first hit and half the batch gets the wrong label.
+    expect(() =>
+      buildBatchUpdateContext([target("ENG"), target("OPS")], {
+        labels: ["bug"],
+      }),
+    ).toThrow(/labels: cannot be resolved by name across teams ENG, OPS/);
+  });
+
+  it("rejects a label list that mixes a UUID with a name", () => {
+    expect(() =>
+      buildBatchUpdateContext([target("ENG"), target("OPS")], {
+        labels: ["66666666-6666-4666-8666-666666666666", "bug"],
+      }),
+    ).toThrow(/labels/);
+  });
+
+  it("lets a UUID status, cycle or label through as the documented escape hatch", () => {
+    // The error message advises passing a UUID; a UUID needs no team to
+    // resolve against, so the guard must not reject it as well.
+    const context = buildBatchUpdateContext([target("ENG"), target("OPS")], {
+      status: "33333333-3333-4333-8333-333333333333",
+      cycle: "44444444-4444-4444-8444-444444444444",
+      labels: [
+        "66666666-6666-4666-8666-666666666666",
+        "77777777-7777-4777-8777-777777777777",
+      ],
+    });
+
+    expect(context).toEqual({});
+  });
+});
+
+describe("validateBatchUpdateEstimate", () => {
+  const ENG_TEAM = "22222222-2222-4222-8222-222222222222";
+  const OPS_TEAM = "55555555-5555-4555-8555-555555555555";
+
+  const target = (teamKey: string, teamId: string): ResolvedIssueRef => ({
+    ref: `${teamKey}-1`,
+    id: asUuid("11111111-1111-4111-8111-111111111111"),
+    teamId: asUuid(teamId),
+    teamKey,
+  });
+
+  const teamResponse = (
+    id: string,
+    key: string,
+    issueEstimationType: string,
+  ) => ({
+    teams: {
+      nodes: [
+        {
+          id,
+          key,
+          name: key,
+          issueEstimationType,
+          issueEstimationExtended: false,
+          issueEstimationAllowZero: false,
+        },
+      ],
+    },
+  });
+
+  it("rejects an estimate outside the team's scale before sending anything", async () => {
+    const request = vi
+      .fn()
+      .mockResolvedValue(teamResponse(ENG_TEAM, "ENG", "fibonacci"));
+    const client = { request } as unknown as GraphQLClient;
+
+    await expect(
+      validateBatchUpdateEstimate(client, [target("ENG", ENG_TEAM)], {
+        estimate: 7,
+      }),
+    ).rejects.toThrow(/must be one of \[1, 2, 3, 5, 8\] for team "ENG"/);
+  });
+
+  it("accepts an estimate that is on the scale", async () => {
+    const request = vi
+      .fn()
+      .mockResolvedValue(teamResponse(ENG_TEAM, "ENG", "fibonacci"));
+    const client = { request } as unknown as GraphQLClient;
+
+    await expect(
+      validateBatchUpdateEstimate(client, [target("ENG", ENG_TEAM)], {
+        estimate: 5,
+      }),
+    ).resolves.toBeUndefined();
+  });
+
+  it("checks every team the batch spans, not just the first", async () => {
+    // One patch applies the same estimate to all targets, so an estimate that
+    // is valid on one team's scale and not another's must still be rejected.
+    const request = vi
+      .fn()
+      .mockResolvedValueOnce(teamResponse(ENG_TEAM, "ENG", "fibonacci"))
+      .mockResolvedValueOnce(teamResponse(OPS_TEAM, "OPS", "linear"));
+    const client = { request } as unknown as GraphQLClient;
+
+    await expect(
+      validateBatchUpdateEstimate(
+        client,
+        [target("ENG", ENG_TEAM), target("OPS", OPS_TEAM)],
+        { estimate: 8 },
+      ),
+    ).rejects.toThrow(/for team "OPS"/);
+  });
+
+  it("looks each distinct team up once and skips the lookup entirely without --estimate", async () => {
+    const request = vi
+      .fn()
+      .mockResolvedValue(teamResponse(ENG_TEAM, "ENG", "fibonacci"));
+    const client = { request } as unknown as GraphQLClient;
+
+    await validateBatchUpdateEstimate(
+      client,
+      [target("ENG", ENG_TEAM), target("ENG", ENG_TEAM)],
+      { estimate: 3 },
+    );
+    expect(request).toHaveBeenCalledTimes(1);
+
+    await validateBatchUpdateEstimate(client, [target("ENG", ENG_TEAM)], {
+      title: "no estimate here",
+    });
+    expect(request).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("buildBatchUpdateInput", () => {
+  const CYCLE = asUuid("66666666-6666-4666-8666-666666666666");
+  const MILESTONE = asUuid("77777777-7777-4777-8777-777777777777");
+
+  it("detaches the cycle when the patch clears it", () => {
+    expect(buildBatchUpdateInput({ cycle: null }, {})).toEqual({
+      cycleId: null,
+    });
+  });
+
+  it("detaches the milestone when the patch clears it", () => {
+    expect(buildBatchUpdateInput({ projectMilestone: null }, {})).toEqual({
+      projectMilestoneId: null,
+    });
+  });
+
+  it("still sets a cycle or milestone when the patch names one", () => {
+    expect(
+      buildBatchUpdateInput(
+        { cycle: "Cycle 4", projectMilestone: "Beta" },
+        { cycleId: CYCLE, projectMilestoneId: MILESTONE },
+      ),
+    ).toEqual({ cycleId: CYCLE, projectMilestoneId: MILESTONE });
+  });
+});
diff --git a/tests/unit/commands/issues.test.ts b/tests/unit/commands/issues.test.ts
index a160b6e3..530f9151 100644
--- a/tests/unit/commands/issues.test.ts
+++ b/tests/unit/commands/issues.test.ts
@@ -45,6 +45,17 @@ vi.mock("../../../src/resolvers/issue-resolver.js", () => ({
   }),
 }));
 
+vi.mock("../../../src/resolvers/team-resolver.js", () => ({
+  resolveTeamEstimateContext: vi.fn().mockResolvedValue({
+    teamId: "destination-team-uuid",
+    teamKey: "OPS",
+    teamName: "Operations",
+    issueEstimationType: "fibonacci",
+    issueEstimationExtended: false,
+    issueEstimationAllowZero: false,
+  }),
+}));
+
 vi.mock("../../../src/services/issue-service.js", () => ({
   archiveIssue: vi.fn().mockResolvedValue({ id: "resolved-issue-uuid" }),
   createIssue: vi.fn().mockResolvedValue({ id: "new-issue-id" }),
@@ -188,6 +199,7 @@ import {
   resolveIssueEstimateContext,
   resolveIssueId,
 } from "../../../src/resolvers/issue-resolver.js";
+import { resolveTeamEstimateContext } from "../../../src/resolvers/team-resolver.js";
 import {
   createDiscussionCommentReaction,
   deleteDiscussionComment,
@@ -775,6 +787,72 @@ describe("issues update --estimate", () => {
     expect(process.exit).toHaveBeenCalledWith(1);
   });
 
+  it("validates against the destination team when --team moves the issue", async () => {
+    // 8 is off the current team's linear scale but on the destination's
+    // fibonacci one, and the estimate lands on the destination.
+    const program = createProgram();
+    await program.parseAsync([
+      "node",
+      "test",
+      "issues",
+      "update",
+      "ENG-42",
+      "--team",
+      "OPS",
+      "--estimate",
+      "8",
+    ]);
+
+    expect(resolveTeamEstimateContext).toHaveBeenCalledWith(
+      expect.anything(),
+      "OPS",
+    );
+    expect(resolveIssueEstimateContext).not.toHaveBeenCalled();
+    expect(updateIssue).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-issue-uuid",
+      expect.objectContaining({ estimate: 8 }),
+    );
+  });
+
+  it("rejects an estimate off the destination team's scale", async () => {
+    const program = createProgram();
+    await program.parseAsync([
+      "node",
+      "test",
+      "issues",
+      "update",
+      "ENG-42",
+      "--team",
+      "OPS",
+      "--estimate",
+      "4",
+    ]);
+
+    const error = JSON.parse(
+      vi.mocked(console.error).mock.calls[0]?.[0] as string,
+    ) as { error: string };
+    expect(error.error).toBe(
+      'Invalid --estimate: must be one of [1, 2, 3, 5, 8] for team "OPS" (fibonacci)',
+    );
+    expect(updateIssue).not.toHaveBeenCalled();
+  });
+
+  it("skips the destination lookup when --team is absent", async () => {
+    const program = createProgram();
+    await program.parseAsync([
+      "node",
+      "test",
+      "issues",
+      "update",
+      "ENG-42",
+      "--estimate",
+      "3",
+    ]);
+
+    expect(resolveTeamEstimateContext).not.toHaveBeenCalled();
+  });
+
   it("skips scale validation when --clear-estimate is used", async () => {
     const program = createProgram();
     await program.parseAsync([
diff --git a/tests/unit/commands/labels.test.ts b/tests/unit/commands/labels.test.ts
index d383fcdc..c0d92e2a 100644
--- a/tests/unit/commands/labels.test.ts
+++ b/tests/unit/commands/labels.test.ts
@@ -25,6 +25,12 @@ vi.mock("../../../src/resolvers/label-resolver.js", () => ({
   resolveLabelId: vi.fn().mockResolvedValue("resolved-label-uuid"),
 }));
 
+vi.mock("../../../src/resolvers/project-resolver.js", () => ({
+  resolveProjectLabelId: vi
+    .fn()
+    .mockResolvedValue("resolved-project-label-uuid"),
+}));
+
 vi.mock("../../../src/services/label-service.js", () => ({
   createLabel: vi.fn().mockResolvedValue({
     id: "lbl-new",
@@ -52,6 +58,17 @@ vi.mock("../../../src/services/label-service.js", () => ({
     nodes: [{ id: "lbl-1", name: "Bug", color: "#ff0000", type: "issue" }],
     pageInfo: { hasNextPage: false, endCursor: null },
   }),
+  retireLabel: vi.fn().mockResolvedValue({
+    id: "resolved-label-uuid",
+    name: "branch:unmerged",
+    retiredAt: "2026-08-10T00:00:00.000Z",
+    type: "issue",
+  }),
+  restoreLabel: vi.fn().mockResolvedValue({
+    id: "resolved-label-uuid",
+    name: "branch:unmerged",
+    type: "issue",
+  }),
   listProjectLabels: vi.fn().mockResolvedValue({
     nodes: [
       {
@@ -68,6 +85,7 @@ vi.mock("../../../src/services/label-service.js", () => ({
 import { setupLabelsCommands } from "../../../src/commands/labels.js";
 import { outputSuccess } from "../../../src/common/output.js";
 import { resolveLabelId } from "../../../src/resolvers/label-resolver.js";
+import { resolveProjectLabelId } from "../../../src/resolvers/project-resolver.js";
 import { resolveTeamId } from "../../../src/resolvers/team-resolver.js";
 import {
   createLabel,
@@ -75,6 +93,8 @@ import {
   getLabel,
   listLabels,
   listProjectLabels,
+  restoreLabel,
+  retireLabel,
   updateLabel,
 } from "../../../src/services/label-service.js";
 
@@ -259,9 +279,11 @@ describe("labels create", () => {
     ]);
 
     expect(resolveTeamId).not.toHaveBeenCalled();
-    expect(createLabel).toHaveBeenCalledWith(expect.anything(), {
-      name: "branch:unmerged",
-    });
+    expect(createLabel).toHaveBeenCalledWith(
+      expect.anything(),
+      { name: "branch:unmerged" },
+      "issue",
+    );
     expect(outputSuccess).toHaveBeenCalledWith({
       id: "lbl-new",
       name: "branch:unmerged",
@@ -288,12 +310,16 @@ describe("labels create", () => {
     ]);
 
     expect(resolveTeamId).toHaveBeenCalledWith(expect.anything(), "DBL");
-    expect(createLabel).toHaveBeenCalledWith(expect.anything(), {
-      name: "branch:unmerged",
-      teamId: "resolved-team-uuid",
-      color: "#B45309",
-      description: "Created from DBL branch workflow",
-    });
+    expect(createLabel).toHaveBeenCalledWith(
+      expect.anything(),
+      {
+        name: "branch:unmerged",
+        teamId: "resolved-team-uuid",
+        color: "#B45309",
+        description: "Created from DBL branch workflow",
+      },
+      "issue",
+    );
   });
 });
 
@@ -323,6 +349,7 @@ describe("labels read", () => {
     expect(getLabel).toHaveBeenCalledWith(
       expect.anything(),
       "resolved-label-uuid",
+      "issue",
     );
   });
 });
@@ -364,6 +391,7 @@ describe("labels update", () => {
         color: "#1D4ED8",
         description: "Updated from DBL branch workflow",
       },
+      "issue",
     );
   });
 
@@ -383,10 +411,88 @@ describe("labels update", () => {
     expect(updateLabel).toHaveBeenCalledWith(
       expect.anything(),
       "resolved-label-uuid",
-      {
-        description: "",
-      },
+      { description: "" },
+      "issue",
+    );
+  });
+
+  it("lifts a label out of its group with --clear-parent", async () => {
+    const program = createProgram();
+
+    await program.parseAsync([
+      "node",
+      "test",
+      "labels",
+      "update",
+      "branch:merged",
+      "--clear-parent",
+    ]);
+
+    expect(updateLabel).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-label-uuid",
+      { parentId: null },
+      "issue",
+    );
+  });
+
+  it("turns a group back into a plain label with --not-group", async () => {
+    const program = createProgram();
+
+    await program.parseAsync([
+      "node",
+      "test",
+      "labels",
+      "update",
+      "branch",
+      "--not-group",
+    ]);
+
+    expect(updateLabel).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-label-uuid",
+      { isGroup: false },
+      "issue",
+    );
+  });
+
+  it("refuses --parent together with --clear-parent", async () => {
+    const program = createProgram();
+
+    await program.parseAsync([
+      "node",
+      "test",
+      "labels",
+      "update",
+      "branch:merged",
+      "--parent",
+      "branch",
+      "--clear-parent",
+    ]);
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("cannot be combined with --clear-parent"),
     );
+    expect(updateLabel).not.toHaveBeenCalled();
+  });
+
+  it("refuses --group together with --not-group", async () => {
+    const program = createProgram();
+
+    await program.parseAsync([
+      "node",
+      "test",
+      "labels",
+      "update",
+      "branch",
+      "--group",
+      "--not-group",
+    ]);
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("cannot be combined with --not-group"),
+    );
+    expect(updateLabel).not.toHaveBeenCalled();
   });
 });
 
@@ -415,6 +521,7 @@ describe("labels delete", () => {
     expect(deleteLabel).toHaveBeenCalledWith(
       expect.anything(),
       "resolved-label-uuid",
+      "issue",
     );
     expect(outputSuccess).toHaveBeenCalledWith({
       id: "resolved-label-uuid",
@@ -641,6 +748,29 @@ describe("labels validation", () => {
     expect(updateLabel).not.toHaveBeenCalled();
   });
 
+  it("rejects update whose only field is an empty --parent", async () => {
+    const program = createProgram();
+
+    await program.parseAsync([
+      "node",
+      "test",
+      "labels",
+      "update",
+      "branch:unmerged",
+      "--parent",
+      "",
+    ]);
+
+    const errorOutput = JSON.parse(
+      vi.mocked(console.error).mock.calls[0]?.[0] as string,
+    ) as { error: string };
+
+    expect(errorOutput.error).toBe(
+      "Invalid label update: at least one option must be provided",
+    );
+    expect(updateLabel).not.toHaveBeenCalled();
+  });
+
   it("rejects team scope without a team filter for read", async () => {
     const program = createProgram();
 
@@ -664,3 +794,165 @@ describe("labels validation", () => {
     expect(resolveLabelId).not.toHaveBeenCalled();
   });
 });
+
+describe("labels --type project", () => {
+  async function run(...argv: string[]): Promise<void> {
+    await createProgram().parseAsync(["node", "test", "labels", ...argv]);
+  }
+
+  it("creates a project label through the project resolver-free path", async () => {
+    await run("create", "Customer", "--type", "project", "--color", "#0000FF");
+
+    expect(resolveTeamId).not.toHaveBeenCalled();
+    expect(createLabel).toHaveBeenCalledWith(
+      expect.anything(),
+      { name: "Customer", color: "#0000FF" },
+      "project",
+    );
+  });
+
+  it("resolves --parent against the same label kind", async () => {
+    await run("create", "Enterprise", "--type", "project", "--parent", "Tier");
+
+    expect(resolveProjectLabelId).toHaveBeenCalledWith(
+      expect.anything(),
+      "Tier",
+    );
+    expect(resolveLabelId).not.toHaveBeenCalled();
+    expect(createLabel).toHaveBeenCalledWith(
+      expect.anything(),
+      { name: "Enterprise", parentId: "resolved-project-label-uuid" },
+      "project",
+    );
+  });
+
+  it("scopes --parent to --team when creating an issue label", async () => {
+    await run("create", "Bug", "--team", "ENG", "--parent", "Area");
+
+    expect(resolveLabelId).toHaveBeenCalledWith(expect.anything(), "Area", {
+      teamId: "resolved-team-uuid",
+    });
+  });
+
+  it("resolves --parent workspace-wide when no team is given", async () => {
+    await run("create", "Bug", "--parent", "Area");
+
+    expect(resolveLabelId).toHaveBeenCalledWith(expect.anything(), "Area", {});
+  });
+
+  it("scopes --parent the same way <label> was resolved on update", async () => {
+    await run(
+      "update",
+      "Bug",
+      "--team",
+      "ENG",
+      "--scope",
+      "team",
+      "--parent",
+      "Area",
+    );
+
+    const scoping = { teamId: "resolved-team-uuid", scope: "team" };
+    expect(resolveLabelId).toHaveBeenNthCalledWith(
+      1,
+      expect.anything(),
+      "Bug",
+      scoping,
+    );
+    expect(resolveLabelId).toHaveBeenNthCalledWith(
+      2,
+      expect.anything(),
+      "Area",
+      scoping,
+    );
+  });
+
+  it("reads a project label by name", async () => {
+    await run("read", "Customer", "--type", "project");
+
+    expect(resolveProjectLabelId).toHaveBeenCalledWith(
+      expect.anything(),
+      "Customer",
+    );
+    expect(getLabel).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-project-label-uuid",
+      "project",
+    );
+  });
+
+  it("updates a project label", async () => {
+    await run("update", "Customer", "--type", "project", "--name", "Client");
+
+    expect(updateLabel).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-project-label-uuid",
+      { name: "Client" },
+      "project",
+    );
+  });
+
+  it("deletes a project label", async () => {
+    await run("delete", "Customer", "--type", "project");
+
+    expect(deleteLabel).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-project-label-uuid",
+      "project",
+    );
+  });
+
+  it("rejects --team because project labels are workspace-scoped", async () => {
+    await run("delete", "Customer", "--type", "project", "--team", "DBL");
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("cannot be used with --type project"),
+    );
+    expect(deleteLabel).not.toHaveBeenCalled();
+  });
+
+  it("rejects --scope because project labels are always workspace-scoped", async () => {
+    await run("read", "Customer", "--type", "project", "--scope", "workspace");
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("cannot be used with --type project"),
+    );
+    expect(getLabel).not.toHaveBeenCalled();
+  });
+});
+
+describe("labels retire and restore", () => {
+  async function run(...argv: string[]): Promise<void> {
+    await createProgram().parseAsync(["node", "test", "labels", ...argv]);
+  }
+
+  it("retires an issue label by default", async () => {
+    await run("retire", "branch:unmerged");
+
+    expect(retireLabel).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-label-uuid",
+      "issue",
+    );
+  });
+
+  it("retires a project label when asked", async () => {
+    await run("retire", "Customer", "--type", "project");
+
+    expect(retireLabel).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-project-label-uuid",
+      "project",
+    );
+  });
+
+  it("restores a project label", async () => {
+    await run("restore", "Customer", "--type", "project");
+
+    expect(restoreLabel).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-project-label-uuid",
+      "project",
+    );
+  });
+});
diff --git a/tests/unit/commands/project-relations.test.ts b/tests/unit/commands/project-relations.test.ts
new file mode 100644
index 00000000..25e9897a
--- /dev/null
+++ b/tests/unit/commands/project-relations.test.ts
@@ -0,0 +1,345 @@
+import { Command } from "commander";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../../../src/common/context.js", () => ({
+  createContext: vi.fn(() => ({ gql: { request: vi.fn() } })),
+  getRootOpts: vi.fn(() => ({ apiToken: "test-token" })),
+}));
+
+vi.mock("../../../src/common/output.js", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("../../../src/common/output.js")>();
+  return { ...actual, outputSuccess: vi.fn() };
+});
+
+vi.mock("../../../src/resolvers/project-resolver.js", () => ({
+  resolveProjectId: vi
+    .fn()
+    .mockImplementation(async (_client: unknown, nameOrId: string) =>
+      nameOrId === "Downstream" ? "project-uuid-2" : "project-uuid-1",
+    ),
+  resolveProjectLabelIds: vi.fn().mockResolvedValue([]),
+}));
+
+vi.mock("../../../src/resolvers/project-relation-resolver.js", () => ({
+  resolveProjectRelation: vi
+    .fn()
+    .mockResolvedValue({ id: "relation-uuid", inverted: false }),
+}));
+
+vi.mock("../../../src/resolvers/milestone-resolver.js", () => ({
+  resolveMilestoneId: vi.fn().mockResolvedValue("milestone-uuid"),
+}));
+
+vi.mock("../../../src/services/project-relation-service.js", async () => {
+  const actual = await import(
+    "../../../src/services/project-relation-service.js"
+  );
+  return {
+    PROJECT_RELATION_ANCHORS: actual.PROJECT_RELATION_ANCHORS,
+    listProjectRelations: vi.fn().mockResolvedValue({ relations: [] }),
+    listAllProjectRelations: vi
+      .fn()
+      .mockResolvedValue({ nodes: [], pageInfo: {} }),
+    getProjectRelation: vi.fn().mockResolvedValue({
+      id: "rel-1",
+      project: { id: "project-uuid-1" },
+      relatedProject: { id: "project-uuid-2" },
+    }),
+    createProjectRelation: vi.fn().mockResolvedValue({ id: "rel-1" }),
+    updateProjectRelation: vi.fn().mockResolvedValue({ id: "rel-1" }),
+    deleteProjectRelation: vi
+      .fn()
+      .mockResolvedValue({ id: "rel-1", success: true }),
+  };
+});
+
+import { setupProjectRelationCommands } from "../../../src/commands/projects/relations.js";
+import { asUuid } from "../../../src/common/identifier.js";
+import { resolveMilestoneId } from "../../../src/resolvers/milestone-resolver.js";
+import { resolveProjectRelation } from "../../../src/resolvers/project-relation-resolver.js";
+import { resolveProjectId } from "../../../src/resolvers/project-resolver.js";
+import {
+  createProjectRelation,
+  deleteProjectRelation,
+  getProjectRelation,
+  listAllProjectRelations,
+  listProjectRelations,
+  updateProjectRelation,
+} from "../../../src/services/project-relation-service.js";
+
+async function run(...argv: string[]): Promise<void> {
+  const program = new Command();
+  program.option("--api-token <token>");
+  setupProjectRelationCommands(program.command("projects"));
+  await program.parseAsync(["node", "test", "projects", "relations", ...argv]);
+}
+
+describe("projects relations", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+  });
+
+  it("list resolves the project", async () => {
+    await run("list", "Upstream");
+
+    expect(listProjectRelations).toHaveBeenCalledWith(
+      expect.anything(),
+      "project-uuid-1",
+    );
+  });
+
+  it("list without a project pages the workspace-wide connection", async () => {
+    await run("list", "--limit", "10");
+
+    expect(listAllProjectRelations).toHaveBeenCalledWith(expect.anything(), {
+      limit: 10,
+      after: undefined,
+    });
+    expect(listProjectRelations).not.toHaveBeenCalled();
+  });
+
+  it("list rejects --limit alongside a project rather than ignoring it", async () => {
+    await run("list", "Upstream", "--limit", "200");
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("cannot be used with a project"),
+    );
+    expect(listProjectRelations).not.toHaveBeenCalled();
+  });
+
+  it("list rejects --after alongside a project rather than ignoring it", async () => {
+    await run("list", "Upstream", "--after", "cursor");
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("cannot be used with a project"),
+    );
+    expect(listProjectRelations).not.toHaveBeenCalled();
+  });
+
+  it("list still accepts a project when the limit is left at its default", async () => {
+    await run("list", "Upstream");
+
+    expect(listProjectRelations).toHaveBeenCalledWith(
+      expect.anything(),
+      "project-uuid-1",
+    );
+  });
+
+  it("read resolves the relation and returns it", async () => {
+    await run("read", "relation-uuid");
+
+    expect(getProjectRelation).toHaveBeenCalledWith(
+      expect.anything(),
+      "relation-uuid",
+    );
+  });
+
+  it("add defaults to end-to-start, the finish-before-start shape", async () => {
+    await run("add", "Upstream", "--blocks", "Downstream");
+
+    expect(createProjectRelation).toHaveBeenCalledWith(expect.anything(), {
+      projectId: "project-uuid-1",
+      relatedProjectId: "project-uuid-2",
+      anchorType: "end",
+      relatedAnchorType: "start",
+    });
+  });
+
+  it("add honours explicit anchors", async () => {
+    await run(
+      "add",
+      "Upstream",
+      "--blocks",
+      "Downstream",
+      "--from",
+      "start",
+      "--to",
+      "end",
+    );
+
+    expect(createProjectRelation).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        anchorType: "start",
+        relatedAnchorType: "end",
+      }),
+    );
+  });
+
+  it("add rejects an anchor outside the observed literals", async () => {
+    await run("add", "Upstream", "--blocks", "Downstream", "--from", "middle");
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("Invalid --from"),
+    );
+    expect(createProjectRelation).not.toHaveBeenCalled();
+  });
+
+  it("add refuses to relate a project to itself", async () => {
+    await run("add", "Upstream", "--blocks", "Upstream");
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("cannot depend on itself"),
+    );
+    expect(createProjectRelation).not.toHaveBeenCalled();
+  });
+
+  it("add scopes each milestone to the project that owns that end", async () => {
+    await run(
+      "add",
+      "Upstream",
+      "--blocks",
+      "Downstream",
+      "--from-milestone",
+      "Beta",
+      "--to-milestone",
+      "Kickoff",
+    );
+
+    expect(resolveMilestoneId).toHaveBeenCalledWith(
+      expect.anything(),
+      "Beta",
+      "project-uuid-1",
+    );
+    expect(resolveMilestoneId).toHaveBeenCalledWith(
+      expect.anything(),
+      "Kickoff",
+      "project-uuid-2",
+    );
+  });
+
+  it("update maps --clear-from-milestone to an explicit null", async () => {
+    await run("update", "relation-uuid", "--clear-from-milestone");
+
+    expect(updateProjectRelation).toHaveBeenCalledWith(
+      expect.anything(),
+      "relation-uuid",
+      { projectMilestoneId: null },
+    );
+  });
+
+  it("update refuses contradictory milestone flags", async () => {
+    await run(
+      "update",
+      "relation-uuid",
+      "--from-milestone",
+      "Beta",
+      "--clear-from-milestone",
+    );
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("cannot be combined with --clear-from-milestone"),
+    );
+    expect(updateProjectRelation).not.toHaveBeenCalled();
+  });
+
+  it("update requires at least one option", async () => {
+    await run("update", "relation-uuid");
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("at least one option must be provided"),
+    );
+    expect(updateProjectRelation).not.toHaveBeenCalled();
+  });
+
+  it("update rejects an empty update before resolving the relation", async () => {
+    await run("update", "Upstream", "--blocks", "Downstream");
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("at least one option must be provided"),
+    );
+    expect(resolveProjectId).not.toHaveBeenCalled();
+    expect(resolveProjectRelation).not.toHaveBeenCalled();
+  });
+
+  it("update swaps both ends when the relation is stored inverted", async () => {
+    vi.mocked(resolveProjectRelation).mockResolvedValueOnce({
+      id: asUuid("relation-uuid"),
+      inverted: true,
+    });
+
+    await run(
+      "update",
+      "Downstream",
+      "--blocks",
+      "Upstream",
+      "--from",
+      "start",
+      "--to-milestone",
+      "Kickoff",
+    );
+
+    // The caller named Downstream first, but the relation belongs to Upstream:
+    // Downstream's anchor is the relation's *related* end.
+    expect(resolveMilestoneId).toHaveBeenCalledWith(
+      expect.anything(),
+      "Kickoff",
+      "project-uuid-1",
+    );
+    expect(updateProjectRelation).toHaveBeenCalledWith(
+      expect.anything(),
+      "relation-uuid",
+      { relatedAnchorType: "start", projectMilestoneId: "milestone-uuid" },
+    );
+  });
+
+  it("update scopes a milestone to the relation's own ends on the UUID path", async () => {
+    await run(
+      "update",
+      "relation-uuid",
+      "--from-milestone",
+      "Beta",
+      "--to-milestone",
+      "Kickoff",
+    );
+
+    expect(getProjectRelation).toHaveBeenCalledWith(
+      expect.anything(),
+      "relation-uuid",
+    );
+    expect(resolveMilestoneId).toHaveBeenCalledWith(
+      expect.anything(),
+      "Beta",
+      "project-uuid-1",
+    );
+    expect(resolveMilestoneId).toHaveBeenCalledWith(
+      expect.anything(),
+      "Kickoff",
+      "project-uuid-2",
+    );
+  });
+
+  it("update reads the ends back only when a milestone flag needs them", async () => {
+    await run("update", "relation-uuid", "--from", "start");
+
+    expect(getProjectRelation).not.toHaveBeenCalled();
+  });
+
+  it("remove takes a relation UUID directly", async () => {
+    await run("remove", "relation-uuid");
+
+    expect(resolveProjectRelation).toHaveBeenCalledWith(
+      expect.anything(),
+      "relation-uuid",
+    );
+    expect(deleteProjectRelation).toHaveBeenCalledWith(
+      expect.anything(),
+      "relation-uuid",
+    );
+  });
+
+  it("remove finds the relation from a project pair", async () => {
+    await run("remove", "Upstream", "--blocks", "Downstream");
+
+    expect(resolveProjectRelation).toHaveBeenCalledWith(
+      expect.anything(),
+      "project-uuid-1",
+      "project-uuid-2",
+    );
+    expect(deleteProjectRelation).toHaveBeenCalled();
+  });
+});
diff --git a/tests/unit/commands/project-statuses.test.ts b/tests/unit/commands/project-statuses.test.ts
new file mode 100644
index 00000000..6353c841
--- /dev/null
+++ b/tests/unit/commands/project-statuses.test.ts
@@ -0,0 +1,223 @@
+import { Command } from "commander";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../../../src/common/context.js", () => ({
+  createContext: vi.fn(() => ({ gql: { request: vi.fn() } })),
+  getRootOpts: vi.fn(() => ({ apiToken: "test-token" })),
+}));
+
+vi.mock("../../../src/common/output.js", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("../../../src/common/output.js")>();
+  return { ...actual, outputSuccess: vi.fn() };
+});
+
+vi.mock("../../../src/resolvers/project-status-resolver.js", () => ({
+  resolveProjectStatusId: vi
+    .fn()
+    .mockImplementation(async (_client: unknown, nameOrId: string) =>
+      nameOrId === "In Review" ? "status-uuid-2" : "status-uuid-1",
+    ),
+}));
+
+vi.mock("../../../src/services/project-status-service.js", () => ({
+  listProjectStatuses: vi.fn().mockResolvedValue({ nodes: [] }),
+  getProjectStatus: vi.fn().mockResolvedValue({ id: "st-1" }),
+  createProjectStatus: vi.fn().mockResolvedValue({ id: "st-new" }),
+  updateProjectStatus: vi.fn().mockResolvedValue({ id: "st-1" }),
+  reassignProjectStatus: vi.fn().mockResolvedValue(undefined),
+  archiveProjectStatus: vi.fn().mockResolvedValue({ id: "st-1" }),
+  unarchiveProjectStatus: vi.fn().mockResolvedValue({ id: "st-1" }),
+}));
+
+import { setupProjectStatusCommands } from "../../../src/commands/projects/statuses.js";
+import { resolveProjectStatusId } from "../../../src/resolvers/project-status-resolver.js";
+import {
+  archiveProjectStatus,
+  createProjectStatus,
+  listProjectStatuses,
+  reassignProjectStatus,
+  unarchiveProjectStatus,
+  updateProjectStatus,
+} from "../../../src/services/project-status-service.js";
+
+function createProgram(): Command {
+  const program = new Command();
+  program.option("--api-token <token>");
+  setupProjectStatusCommands(program.command("projects"));
+  return program;
+}
+
+async function run(...argv: string[]): Promise<void> {
+  await createProgram().parseAsync(["node", "test", "projects", ...argv]);
+}
+
+describe("projects statuses", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+  });
+
+  it("list forwards --include-archived", async () => {
+    await run("statuses", "list", "--include-archived");
+
+    expect(listProjectStatuses).toHaveBeenCalledWith(expect.anything(), true);
+  });
+
+  it("read resolves archived statuses too", async () => {
+    await run("statuses", "read", "Done");
+
+    expect(resolveProjectStatusId).toHaveBeenCalledWith(
+      expect.anything(),
+      "Done",
+      { includeArchived: true },
+    );
+  });
+
+  it("create leaves position unset so the service appends", async () => {
+    await run(
+      "statuses",
+      "create",
+      "Blocked",
+      "--type",
+      "paused",
+      "--color",
+      "#B45309",
+    );
+
+    expect(createProjectStatus).toHaveBeenCalledWith(expect.anything(), {
+      name: "Blocked",
+      type: "paused",
+      color: "#B45309",
+    });
+  });
+
+  it("create rejects a type outside the enum", async () => {
+    await run(
+      "statuses",
+      "create",
+      "Blocked",
+      "--type",
+      "stalled",
+      "--color",
+      "#B45309",
+    );
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("Invalid --type"),
+    );
+    expect(createProjectStatus).not.toHaveBeenCalled();
+  });
+
+  it("create rejects a position with trailing junk", async () => {
+    await run(
+      "statuses",
+      "create",
+      "Blocked",
+      "--type",
+      "paused",
+      "--color",
+      "#B45309",
+      "--position",
+      "1O",
+    );
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("Invalid --position"),
+    );
+    expect(createProjectStatus).not.toHaveBeenCalled();
+  });
+
+  it("update maps --not-indefinite to false", async () => {
+    await run("statuses", "update", "Done", "--not-indefinite");
+
+    expect(updateProjectStatus).toHaveBeenCalledWith(
+      expect.anything(),
+      "status-uuid-1",
+      { indefinite: false },
+    );
+  });
+
+  it("update refuses contradictory indefinite flags", async () => {
+    await run("statuses", "update", "Done", "--indefinite", "--not-indefinite");
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("cannot be combined with --not-indefinite"),
+    );
+    expect(updateProjectStatus).not.toHaveBeenCalled();
+  });
+
+  it("archive reassigns before archiving when --reassign-to is given", async () => {
+    await run("statuses", "archive", "Done", "--reassign-to", "In Review");
+
+    expect(reassignProjectStatus).toHaveBeenCalledWith(
+      expect.anything(),
+      "status-uuid-1",
+      "status-uuid-2",
+    );
+    expect(archiveProjectStatus).toHaveBeenCalledWith(
+      expect.anything(),
+      "status-uuid-1",
+    );
+  });
+
+  it("archive says where the projects went when it fails after reassigning", async () => {
+    vi.mocked(archiveProjectStatus).mockRejectedValueOnce(
+      new Error("Cannot archive the last status of this type"),
+    );
+
+    await run("statuses", "archive", "Done", "--reassign-to", "In Review");
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('In Review\\" and were not moved back'),
+    );
+  });
+
+  it("archive reports a plain failure when nothing was reassigned", async () => {
+    vi.mocked(archiveProjectStatus).mockRejectedValueOnce(
+      new Error("Cannot archive the last status of this type"),
+    );
+
+    await run("statuses", "archive", "Done");
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.not.stringContaining("were not moved back"),
+    );
+  });
+
+  it("archive refuses to reassign a status onto itself", async () => {
+    await run("statuses", "archive", "Done", "--reassign-to", "Done");
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("must name a different status"),
+    );
+    expect(reassignProjectStatus).not.toHaveBeenCalled();
+    expect(archiveProjectStatus).not.toHaveBeenCalled();
+  });
+
+  it("archive skips reassignment when the flag is absent", async () => {
+    await run("statuses", "archive", "Done");
+
+    expect(reassignProjectStatus).not.toHaveBeenCalled();
+    expect(archiveProjectStatus).toHaveBeenCalledWith(
+      expect.anything(),
+      "status-uuid-1",
+    );
+  });
+
+  it("unarchive resolves archived statuses", async () => {
+    await run("statuses", "unarchive", "Done");
+
+    expect(resolveProjectStatusId).toHaveBeenCalledWith(
+      expect.anything(),
+      "Done",
+      { includeArchived: true },
+    );
+    expect(unarchiveProjectStatus).toHaveBeenCalledWith(
+      expect.anything(),
+      "status-uuid-1",
+    );
+  });
+});
diff --git a/tests/unit/commands/project-updates.test.ts b/tests/unit/commands/project-updates.test.ts
new file mode 100644
index 00000000..9dd79f73
--- /dev/null
+++ b/tests/unit/commands/project-updates.test.ts
@@ -0,0 +1,219 @@
+import { Command } from "commander";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../../../src/common/context.js", () => ({
+  createContext: vi.fn(() => ({ gql: { request: vi.fn() } })),
+  getRootOpts: vi.fn(() => ({ apiToken: "test-token" })),
+}));
+
+vi.mock("../../../src/common/output.js", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("../../../src/common/output.js")>();
+  return { ...actual, outputSuccess: vi.fn() };
+});
+
+vi.mock("../../../src/resolvers/project-resolver.js", () => ({
+  resolveProjectId: vi.fn().mockResolvedValue("resolved-project-uuid"),
+  resolveProjectLabelIds: vi.fn().mockResolvedValue([]),
+}));
+
+vi.mock("../../../src/resolvers/user-resolver.js", () => ({
+  resolveUserId: vi.fn().mockResolvedValue("resolved-user-uuid"),
+}));
+
+vi.mock("../../../src/services/project-update-service.js", () => ({
+  listProjectUpdates: vi.fn().mockResolvedValue({ nodes: [], pageInfo: {} }),
+  getProjectUpdate: vi.fn().mockResolvedValue({ id: "upd-1" }),
+  createProjectUpdate: vi.fn().mockResolvedValue({ id: "upd-new" }),
+  editProjectUpdate: vi.fn().mockResolvedValue({ id: "upd-1" }),
+  archiveProjectUpdate: vi.fn().mockResolvedValue({ id: "upd-1" }),
+  unarchiveProjectUpdate: vi.fn().mockResolvedValue({ id: "upd-1" }),
+  remindProjectUpdate: vi
+    .fn()
+    .mockResolvedValue({ projectId: "proj-1", success: true }),
+}));
+
+import { setupProjectUpdateCommands } from "../../../src/commands/projects/updates.js";
+import { outputSuccess } from "../../../src/common/output.js";
+import { resolveProjectId } from "../../../src/resolvers/project-resolver.js";
+import { resolveUserId } from "../../../src/resolvers/user-resolver.js";
+import {
+  archiveProjectUpdate,
+  createProjectUpdate,
+  editProjectUpdate,
+  getProjectUpdate,
+  listProjectUpdates,
+  remindProjectUpdate,
+} from "../../../src/services/project-update-service.js";
+
+function createProgram(): Command {
+  const program = new Command();
+  program.option("--api-token <token>");
+  const projects = program.command("projects");
+  setupProjectUpdateCommands(projects);
+  return program;
+}
+
+describe("projects updates", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+  });
+
+  it("list resolves the project and forwards pagination", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "updates",
+      "list",
+      "--project",
+      "My Project",
+      "--limit",
+      "10",
+      "--include-archived",
+    ]);
+
+    expect(resolveProjectId).toHaveBeenCalledWith(
+      expect.anything(),
+      "My Project",
+    );
+    expect(listProjectUpdates).toHaveBeenCalledWith(expect.anything(), {
+      projectId: "resolved-project-uuid",
+      limit: 10,
+      after: undefined,
+      includeArchived: true,
+    });
+  });
+
+  it("read passes the update ID straight through", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "updates",
+      "read",
+      "upd-1",
+    ]);
+
+    expect(getProjectUpdate).toHaveBeenCalledWith(expect.anything(), "upd-1");
+    expect(outputSuccess).toHaveBeenCalledWith({ id: "upd-1" });
+  });
+
+  it("create maps --health and --hide-diff onto the input", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "updates",
+      "create",
+      "--project",
+      "My Project",
+      "--body",
+      "Week 1",
+      "--health",
+      "atrisk",
+      "--hide-diff",
+    ]);
+
+    expect(createProjectUpdate).toHaveBeenCalledWith(expect.anything(), {
+      projectId: "resolved-project-uuid",
+      body: "Week 1",
+      health: "atRisk",
+      isDiffHidden: true,
+    });
+  });
+
+  it("create rejects an unknown health value", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "updates",
+      "create",
+      "--project",
+      "My Project",
+      "--health",
+      "sideways",
+    ]);
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("--health"),
+    );
+    expect(createProjectUpdate).not.toHaveBeenCalled();
+  });
+
+  it("update requires at least one field", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "updates",
+      "update",
+      "upd-1",
+    ]);
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("at least one option must be provided"),
+    );
+    expect(editProjectUpdate).not.toHaveBeenCalled();
+  });
+
+  it("archive passes the update ID straight through", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "updates",
+      "archive",
+      "upd-1",
+    ]);
+
+    expect(archiveProjectUpdate).toHaveBeenCalledWith(
+      expect.anything(),
+      "upd-1",
+    );
+  });
+
+  it("remind resolves the target user when one is named", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "updates",
+      "remind",
+      "--project",
+      "My Project",
+      "--user",
+      "alice",
+    ]);
+
+    expect(resolveUserId).toHaveBeenCalledWith(expect.anything(), "alice");
+    expect(remindProjectUpdate).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-project-uuid",
+      "resolved-user-uuid",
+    );
+  });
+
+  it("remind leaves the target unset when no user is named", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "updates",
+      "remind",
+      "--project",
+      "My Project",
+    ]);
+
+    expect(resolveUserId).not.toHaveBeenCalled();
+    expect(remindProjectUpdate).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-project-uuid",
+      undefined,
+    );
+  });
+});
diff --git a/tests/unit/commands/projects.test.ts b/tests/unit/commands/projects.test.ts
index 321ec669..baefac8d 100644
--- a/tests/unit/commands/projects.test.ts
+++ b/tests/unit/commands/projects.test.ts
@@ -35,16 +35,25 @@ vi.mock("../../../src/resolvers/user-resolver.js", () => ({
 }));
 
 vi.mock("../../../src/services/project-service.js", () => ({
-  archiveProject: vi.fn().mockResolvedValue({ id: "proj-1", name: "Archived" }),
   listProjects: vi.fn().mockResolvedValue({ nodes: [], pageInfo: {} }),
+  searchProjects: vi.fn().mockResolvedValue({ nodes: [], pageInfo: {} }),
+  disableProjectExternalSync: vi.fn().mockResolvedValue({ id: "proj-1" }),
   getProject: vi.fn().mockResolvedValue({ id: "proj-1" }),
-  getProjectLabelIds: vi.fn().mockResolvedValue([]),
+  applyProjectLabels: vi.fn().mockResolvedValue({ id: "proj-1" }),
   createProject: vi.fn().mockResolvedValue({ id: "proj-new" }),
   deleteProject: vi.fn().mockResolvedValue({ id: "proj-1", success: true }),
   unarchiveProject: vi.fn().mockResolvedValue({ id: "proj-1", name: "Active" }),
   updateProject: vi.fn().mockResolvedValue({ id: "proj-1" }),
 }));
 
+vi.mock("../../../src/services/project-activity-service.js", () => ({
+  getProjectActivity: vi.fn().mockResolvedValue({
+    project: { id: "proj-1", name: "Auth" },
+    activity: [],
+    pageInfo: { hasNextPage: false, endCursor: null },
+  }),
+}));
+
 vi.mock("../../../src/services/discussion-service.js", () => ({
   startProjectDiscussion: vi
     .fn()
@@ -111,7 +120,7 @@ vi.mock("../../../src/services/discussion-service.js", () => ({
     .mockResolvedValue({ id: "reaction-1", success: true }),
 }));
 
-import { setupProjectsCommands } from "../../../src/commands/projects.js";
+import { setupProjectsCommands } from "../../../src/commands/projects/index.js";
 import { outputSuccess } from "../../../src/common/output.js";
 import {
   resolveProjectId,
@@ -135,13 +144,15 @@ import {
   startProjectDiscussion,
   unresolveDiscussion,
 } from "../../../src/services/discussion-service.js";
+import { getProjectActivity } from "../../../src/services/project-activity-service.js";
 import {
-  archiveProject,
+  applyProjectLabels,
   createProject,
   deleteProject,
+  disableProjectExternalSync,
   getProject,
-  getProjectLabelIds,
   listProjects,
+  searchProjects,
   unarchiveProject,
   updateProject,
 } from "../../../src/services/project-service.js";
@@ -259,28 +270,11 @@ describe("projects lifecycle", () => {
     vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
   });
 
-  it("archive resolves project and outputs result", async () => {
+  it("does not register an archive command", () => {
     const program = createProgram();
-    await program.parseAsync([
-      "node",
-      "test",
-      "projects",
-      "archive",
-      "My Project",
-    ]);
+    const projects = program.commands.find((c) => c.name() === "projects");
 
-    expect(resolveProjectId).toHaveBeenCalledWith(
-      expect.anything(),
-      "My Project",
-    );
-    expect(archiveProject).toHaveBeenCalledWith(
-      expect.anything(),
-      "resolved-project-uuid",
-    );
-    expect(outputSuccess).toHaveBeenCalledWith({
-      id: "proj-1",
-      name: "Archived",
-    });
+    expect(projects?.commands.map((c) => c.name())).not.toContain("archive");
   });
 
   it("unarchive resolves project and outputs result", async () => {
@@ -1057,11 +1051,7 @@ describe("projects update", () => {
     );
   });
 
-  it("adds labels without dropping existing project labels", async () => {
-    vi.mocked(getProjectLabelIds).mockResolvedValueOnce([
-      "existing-label-uuid",
-    ] as Awaited<ReturnType<typeof getProjectLabelIds>>);
-
+  it("adds labels incrementally, without reading the current set", async () => {
     const program = createProgram();
     await program.parseAsync([
       "node",
@@ -1075,28 +1065,43 @@ describe("projects update", () => {
       "add",
     ]);
 
-    expect(getProjectLabelIds).toHaveBeenCalledWith(
+    expect(resolveProjectLabelIds).toHaveBeenCalledWith(expect.anything(), [
+      "Q3",
+    ]);
+    // No read-modify-write, and no labelIds on the update input at all.
+    expect(updateProject).not.toHaveBeenCalled();
+    expect(applyProjectLabels).toHaveBeenCalledWith(
       expect.anything(),
       "resolved-project-uuid",
+      ["resolved-label-uuid"],
+      "add",
     );
-    expect(resolveProjectLabelIds).toHaveBeenCalledWith(expect.anything(), [
+  });
+
+  it("removes labels incrementally", async () => {
+    const program = createProgram();
+    await program.parseAsync([
+      "node",
+      "test",
+      "projects",
+      "update",
+      "My Project",
+      "--labels",
       "Q3",
+      "--label-mode",
+      "remove",
     ]);
-    expect(updateProject).toHaveBeenCalledWith(
+
+    expect(updateProject).not.toHaveBeenCalled();
+    expect(applyProjectLabels).toHaveBeenCalledWith(
       expect.anything(),
       "resolved-project-uuid",
-      expect.objectContaining({
-        labelIds: ["existing-label-uuid", "resolved-label-uuid"],
-      }),
+      ["resolved-label-uuid"],
+      "remove",
     );
   });
 
-  it("removes selected project labels without clearing all labels", async () => {
-    vi.mocked(getProjectLabelIds).mockResolvedValueOnce([
-      "keep-label-uuid",
-      "resolved-label-uuid",
-    ] as Awaited<ReturnType<typeof getProjectLabelIds>>);
-
+  it("applies field updates and incremental labels in one invocation", async () => {
     const program = createProgram();
     await program.parseAsync([
       "node",
@@ -1104,16 +1109,41 @@ describe("projects update", () => {
       "projects",
       "update",
       "My Project",
+      "--name",
+      "Renamed",
       "--labels",
       "Q3",
       "--label-mode",
-      "remove",
+      "add",
     ]);
 
     expect(updateProject).toHaveBeenCalledWith(
       expect.anything(),
       "resolved-project-uuid",
-      expect.objectContaining({ labelIds: ["keep-label-uuid"] }),
+      expect.objectContaining({ name: "Renamed" }),
+    );
+    expect(applyProjectLabels).toHaveBeenCalled();
+    // Labels run last, so the emitted project reflects both changes.
+    expect(outputSuccess).toHaveBeenCalledWith({ id: "proj-1" });
+  });
+
+  it("still replaces the whole set without a label mode", async () => {
+    const program = createProgram();
+    await program.parseAsync([
+      "node",
+      "test",
+      "projects",
+      "update",
+      "My Project",
+      "--labels",
+      "Q3",
+    ]);
+
+    expect(applyProjectLabels).not.toHaveBeenCalled();
+    expect(updateProject).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-project-uuid",
+      expect.objectContaining({ labelIds: ["resolved-label-uuid"] }),
     );
   });
 
@@ -1155,3 +1185,148 @@ describe("projects update", () => {
     expect(updateProject).not.toHaveBeenCalled();
   });
 });
+
+describe("projects search", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+  });
+
+  it("passes the term and pagination through", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "search",
+      "auth",
+      "--limit",
+      "10",
+    ]);
+
+    expect(resolveTeamId).not.toHaveBeenCalled();
+    expect(searchProjects).toHaveBeenCalledWith(expect.anything(), "auth", {
+      limit: 10,
+      after: undefined,
+      includeArchived: false,
+    });
+  });
+
+  it("resolves --team before searching", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "search",
+      "auth",
+      "--team",
+      "ENG",
+    ]);
+
+    expect(resolveTeamId).toHaveBeenCalledWith(expect.anything(), "ENG");
+    expect(searchProjects).toHaveBeenCalledWith(
+      expect.anything(),
+      "auth",
+      expect.objectContaining({ teamId: "resolved-team-uuid" }),
+    );
+  });
+});
+
+describe("projects disable-sync", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+  });
+
+  it("resolves the project and forwards the source", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "disable-sync",
+      "My Project",
+      "--source",
+      "jira",
+    ]);
+
+    expect(disableProjectExternalSync).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-project-uuid",
+      "jira",
+    );
+  });
+
+  it("rejects a source Linear does not sync from", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "disable-sync",
+      "My Project",
+      "--source",
+      "gitlab",
+    ]);
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("Invalid --source"),
+    );
+    expect(disableProjectExternalSync).not.toHaveBeenCalled();
+  });
+});
+
+describe("projects activity", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+  });
+
+  it("resolves the project and forwards the timeline flags", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "activity",
+      "My Project",
+      "--limit",
+      "10",
+      "--comments-only",
+      "--with-reactions",
+    ]);
+
+    expect(resolveProjectId).toHaveBeenCalledWith(
+      expect.anything(),
+      "My Project",
+    );
+    expect(getProjectActivity).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-project-uuid",
+      {
+        limit: 10,
+        after: undefined,
+        commentsOnly: true,
+        withReactions: true,
+      },
+    );
+  });
+
+  it("defaults both timeline flags to false", async () => {
+    await createProgram().parseAsync([
+      "node",
+      "test",
+      "projects",
+      "activity",
+      "My Project",
+    ]);
+
+    expect(getProjectActivity).toHaveBeenCalledWith(
+      expect.anything(),
+      "resolved-project-uuid",
+      expect.objectContaining({ commentsOnly: false, withReactions: false }),
+    );
+  });
+});
diff --git a/tests/unit/common/datetime.test.ts b/tests/unit/common/datetime.test.ts
new file mode 100644
index 00000000..ff6fd8d7
--- /dev/null
+++ b/tests/unit/common/datetime.test.ts
@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import { parseDateTimeOption } from "../../../src/common/datetime.js";
+
+// Fixed reference instant so relative offsets are deterministic.
+const now = new Date("2026-08-10T12:00:00.000Z");
+
+describe("parseDateTimeOption", () => {
+  it("resolves relative offsets against the supplied instant", () => {
+    expect(parseDateTimeOption("--at", "+30m", now)).toBe(
+      "2026-08-10T12:30:00.000Z",
+    );
+    expect(parseDateTimeOption("--at", "+2h", now)).toBe(
+      "2026-08-10T14:00:00.000Z",
+    );
+    expect(parseDateTimeOption("--at", "+3d", now)).toBe(
+      "2026-08-13T12:00:00.000Z",
+    );
+    expect(parseDateTimeOption("--at", "+1w", now)).toBe(
+      "2026-08-17T12:00:00.000Z",
+    );
+  });
+
+  it("normalizes ISO-8601 input to UTC", () => {
+    expect(parseDateTimeOption("--at", "2026-08-14T09:00:00Z", now)).toBe(
+      "2026-08-14T09:00:00.000Z",
+    );
+    expect(parseDateTimeOption("--at", "2026-08-14T09:00:00+02:00", now)).toBe(
+      "2026-08-14T07:00:00.000Z",
+    );
+  });
+
+  it("reads a bare date and a zoneless date-time as UTC", () => {
+    expect(parseDateTimeOption("--until", "2026-08-20", now)).toBe(
+      "2026-08-20T00:00:00.000Z",
+    );
+    expect(parseDateTimeOption("--until", "2026-08-20T17:30", now)).toBe(
+      "2026-08-20T17:30:00.000Z",
+    );
+  });
+
+  it("keeps a written day that falls on the previous UTC day", () => {
+    // Guards the calendar check: this is valid input whose UTC day differs
+    // from the day as written.
+    expect(parseDateTimeOption("--at", "2026-08-14T01:00:00+05:00", now)).toBe(
+      "2026-08-13T20:00:00.000Z",
+    );
+  });
+
+  it("rejects a zero offset", () => {
+    expect(() => parseDateTimeOption("--at", "+0h", now)).toThrow(
+      /must be a positive offset/,
+    );
+  });
+
+  it("rejects an offset that overflows the Date range, naming the flag", () => {
+    // Without the range check this reached toISOString() and came back as a
+    // bare RangeError("Invalid time value") mentioning neither flag nor value.
+    expect(() => parseDateTimeOption("--at", "+99999999w", now)).toThrow(
+      /Invalid --at: "\+99999999w" is too far in the future/,
+    );
+  });
+
+  it("rejects a day that does not exist", () => {
+    expect(() => parseDateTimeOption("--at", "2026-02-30", now)).toThrow(
+      /is not a real date/,
+    );
+  });
+
+  it("rejects free-form input, naming the flag", () => {
+    expect(() => parseDateTimeOption("--at", "tomorrow", now)).toThrow(
+      /Invalid --at: "tomorrow" must be an ISO-8601 date/,
+    );
+    expect(() => parseDateTimeOption("--at", "-2h", now)).toThrow(
+      /must be an ISO-8601 date/,
+    );
+  });
+});
diff --git a/tests/unit/common/domain-values.test.ts b/tests/unit/common/domain-values.test.ts
index c802505f..b1fa58e8 100644
--- a/tests/unit/common/domain-values.test.ts
+++ b/tests/unit/common/domain-values.test.ts
@@ -1,5 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { parseLabelMode } from "../../../src/common/domain-values.js";
+import {
+  parseHealth,
+  parseLabelMode,
+  parseSetMode,
+} from "../../../src/common/domain-values.js";
 
 describe("parseLabelMode", () => {
   it("returns undefined when value is undefined", () => {
@@ -21,3 +25,37 @@ describe("parseLabelMode", () => {
     );
   });
 });
+
+describe("parseSetMode", () => {
+  it("names the caller's flag in the error, not a hardcoded one", () => {
+    // --subscriber-mode shares parseLabelMode's implementation; the message
+    // must still point at the flag the caller actually typed.
+    expect(() => parseSetMode("--subscriber-mode", "replace")).toThrow(
+      "Invalid --subscriber-mode: must be one of 'add', 'remove', or 'overwrite'",
+    );
+  });
+
+  it("narrows valid values and passes undefined through", () => {
+    expect(parseSetMode("--subscriber-mode", undefined)).toBeUndefined();
+    expect(parseSetMode("--subscriber-mode", "add")).toBe("add");
+  });
+});
+
+describe("parseHealth", () => {
+  it("returns undefined for an absent or empty value", () => {
+    expect(parseHealth(undefined)).toBeUndefined();
+    expect(parseHealth("")).toBeUndefined();
+  });
+
+  it("accepts any casing and returns the API spelling", () => {
+    expect(parseHealth("ontrack")).toBe("onTrack");
+    expect(parseHealth("atRisk")).toBe("atRisk");
+    expect(parseHealth("  OFFTRACK  ")).toBe("offTrack");
+  });
+
+  it("throws for an unknown health value", () => {
+    expect(() => parseHealth("sideways")).toThrow(
+      'Invalid --health: must be one of: "onTrack", "atRisk", "offTrack"',
+    );
+  });
+});
diff --git a/tests/unit/common/errors.test.ts b/tests/unit/common/errors.test.ts
index ab213464..e8104ba1 100644
--- a/tests/unit/common/errors.test.ts
+++ b/tests/unit/common/errors.test.ts
@@ -34,6 +34,18 @@ describe("multipleMatchesError", () => {
     expect(err.message).toContain("id-1, id-2");
     expect(err.message).toContain("use an ID");
   });
+
+  it("pluralizes a sibilant entity type with -es", () => {
+    const err = multipleMatchesError(
+      "project status",
+      "In Review",
+      ["id-1", "id-2"],
+      "use an ID",
+    );
+    expect(err.message).toContain(
+      'Multiple project statuses found matching "In Review"',
+    );
+  });
 });
 
 describe("invalidParameterError", () => {
diff --git a/tests/unit/common/git.test.ts b/tests/unit/common/git.test.ts
new file mode 100644
index 00000000..f272e800
--- /dev/null
+++ b/tests/unit/common/git.test.ts
@@ -0,0 +1,40 @@
+import { execFileSync } from "node:child_process";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { getCurrentBranch } from "../../../src/common/git.js";
+
+vi.mock("node:child_process", () => ({ execFileSync: vi.fn() }));
+
+const execFileSyncMock = vi.mocked(execFileSync);
+
+describe("getCurrentBranch", () => {
+  beforeEach(() => {
+    execFileSyncMock.mockReset();
+  });
+
+  it("returns the trimmed branch name", () => {
+    execFileSyncMock.mockReturnValue("feature/login\n");
+
+    expect(getCurrentBranch()).toBe("feature/login");
+    expect(execFileSyncMock).toHaveBeenCalledWith(
+      "git",
+      ["rev-parse", "--abbrev-ref", "HEAD"],
+      expect.objectContaining({ encoding: "utf8" }),
+    );
+  });
+
+  it("tells the caller to name a branch when git fails", () => {
+    execFileSyncMock.mockImplementation(() => {
+      throw new Error("not a git repository");
+    });
+
+    expect(() => getCurrentBranch()).toThrow(
+      /could not be read from git — pass a branch name explicitly/,
+    );
+  });
+
+  it("treats a detached HEAD as having no branch", () => {
+    execFileSyncMock.mockReturnValue("HEAD\n");
+
+    expect(() => getCurrentBranch()).toThrow(/detached HEAD/);
+  });
+});
diff --git a/tests/unit/common/issue-filter.test.ts b/tests/unit/common/issue-filter.test.ts
index a706f265..a5afb152 100644
--- a/tests/unit/common/issue-filter.test.ts
+++ b/tests/unit/common/issue-filter.test.ts
@@ -1,10 +1,12 @@
 import { describe, expect, it } from "vitest";
 import {
   parseCommaSeparated,
+  parseWorkflowStateType,
   validateDateRange,
   validateEstimate,
   validateFilterDependencies,
   validatePriority,
+  WORKFLOW_STATE_TYPES,
 } from "../../../src/common/issue-filter.js";
 
 describe("validatePriority", () => {
@@ -158,3 +160,17 @@ describe("parseCommaSeparated", () => {
     expect(() => parseCommaSeparated("a, ,b")).toThrow("empty");
   });
 });
+
+describe("parseWorkflowStateType", () => {
+  it("accepts every documented category", () => {
+    for (const type of WORKFLOW_STATE_TYPES) {
+      expect(parseWorkflowStateType(type)).toBe(type);
+    }
+  });
+
+  it("rejects anything else, listing the valid values", () => {
+    expect(() => parseWorkflowStateType("done")).toThrow(
+      "Invalid --state-type: must be one of triage, backlog, unstarted, started, completed, canceled",
+    );
+  });
+});
diff --git a/tests/unit/common/resolve-filters.test.ts b/tests/unit/common/resolve-filters.test.ts
index cfa372e1..0b14d2b2 100644
--- a/tests/unit/common/resolve-filters.test.ts
+++ b/tests/unit/common/resolve-filters.test.ts
@@ -4,6 +4,7 @@ import type { CommandContext } from "../../../src/common/context.js";
 import { resolveFilterOptions } from "../../../src/common/resolve-filters.js";
 import { resolveSearchFilterIds } from "../../../src/resolvers/issue-filter-resolver.js";
 import { resolveMilestoneId } from "../../../src/resolvers/milestone-resolver.js";
+import { resolveUserId } from "../../../src/resolvers/user-resolver.js";
 
 vi.mock("../../../src/resolvers/issue-filter-resolver.js", () => ({
   resolveSearchFilterIds: vi.fn().mockResolvedValue({
@@ -22,6 +23,10 @@ vi.mock("../../../src/resolvers/milestone-resolver.js", () => ({
   resolveMilestoneId: vi.fn().mockResolvedValue("milestone-uuid"),
 }));
 
+vi.mock("../../../src/resolvers/user-resolver.js", () => ({
+  resolveUserId: vi.fn().mockResolvedValue("subscriber-uuid"),
+}));
+
 function mockContext(): CommandContext {
   return {
     gql: {} as unknown as GraphQLClient,
@@ -207,3 +212,44 @@ describe("resolveFilterOptions", () => {
     expect(resolveSearchFilterIds).not.toHaveBeenCalled();
   });
 });
+
+describe("resolveFilterOptions state and subscriber flags", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("rejects --unassigned together with --assignee", async () => {
+    // The two describe the same field in contradictory ways; combining them
+    // would silently build a filter that matches nothing.
+    await expect(
+      resolveFilterOptions(mockContext(), {
+        unassigned: true,
+        assignee: "alice",
+      }),
+    ).rejects.toThrow(
+      "Invalid --unassigned: cannot be combined with --assignee",
+    );
+  });
+
+  it("validates --state-type before making any request", async () => {
+    await expect(
+      resolveFilterOptions(mockContext(), { stateType: "done" }),
+    ).rejects.toThrow(/Invalid --state-type/);
+    expect(resolveSearchFilterIds).not.toHaveBeenCalled();
+  });
+
+  it("resolves --subscriber to a user UUID", async () => {
+    const result = await resolveFilterOptions(mockContext(), {
+      subscriber: "alice",
+      stateType: "started",
+      unassigned: true,
+    });
+
+    expect(resolveUserId).toHaveBeenCalledWith(expect.anything(), "alice");
+    expect(result).toMatchObject({
+      subscriberId: "subscriber-uuid",
+      stateType: "started",
+      unassigned: true,
+    });
+  });
+});
diff --git a/tests/unit/helpers/capture-rejection.ts b/tests/unit/helpers/capture-rejection.ts
new file mode 100644
index 00000000..e2e5e223
--- /dev/null
+++ b/tests/unit/helpers/capture-rejection.ts
@@ -0,0 +1,21 @@
+import { expect } from "vitest";
+
+/**
+ * Await a call expected to reject and hand back the thrown error, so a test can
+ * assert on several parts of one message without invoking the call once per
+ * assertion.
+ *
+ * `promise.catch((caught) => caught as Error)` looks equivalent but widens the
+ * result to `Error | T` — the resolved type survives — which then fails the
+ * test type check on `error.message`. Rejecting explicitly when the promise
+ * fulfils keeps the return type honest at `Error` and turns a call that
+ * silently stopped throwing into a failure rather than a passing test.
+ */
+export async function captureRejection(
+  promise: Promise<unknown>,
+): Promise<Error> {
+  return promise.then(
+    () => expect.unreachable("expected the call to reject, but it resolved"),
+    (caught: Error) => caught,
+  );
+}
diff --git a/tests/unit/release/release-notes.test.ts b/tests/unit/release/release-notes.test.ts
new file mode 100644
index 00000000..64c073a8
--- /dev/null
+++ b/tests/unit/release/release-notes.test.ts
@@ -0,0 +1,94 @@
+import { createRequire } from "node:module";
+import { generateNotes } from "@semantic-release/release-notes-generator";
+import { describe, expect, it } from "vitest";
+
+/**
+ * Regression guard for silently empty release notes.
+ *
+ * `.releaserc.cjs` selects the `conventionalcommits` preset by bare specifier,
+ * so the preset version that actually gets loaded is whatever npm resolves
+ * from release-notes-generator's own directory. Preset v10 switched to the
+ * `@conventional-changelog/writer@2` API (function `template`/`commitPartial`),
+ * which release-notes-generator's Handlebars-based writer@8 cannot render: the
+ * heading survives, every `### <group>` section and bullet disappears, and the
+ * release still succeeds. These tests turn that silent data loss into a
+ * failing check.
+ */
+
+type PluginEntry = string | [string, Record<string, unknown>];
+
+const require = createRequire(import.meta.url);
+
+function releaseNotesPluginConfig(): Record<string, unknown> {
+  const config = require("../../../.releaserc.cjs") as {
+    plugins: PluginEntry[];
+  };
+
+  const entry = config.plugins.find(
+    (plugin): plugin is [string, Record<string, unknown>] =>
+      Array.isArray(plugin) &&
+      plugin[0] === "@semantic-release/release-notes-generator",
+  );
+
+  if (!entry) {
+    throw new Error(
+      "no @semantic-release/release-notes-generator entry in .releaserc.cjs",
+    );
+  }
+
+  return entry[1];
+}
+
+const COMMITS = [
+  {
+    hash: "1111111111111111111111111111111111111111",
+    message: "feat(issues): add activity command\n\nCloses #144",
+  },
+  {
+    hash: "2222222222222222222222222222222222222222",
+    message: "fix(labels): allow clearing label description",
+  },
+  {
+    hash: "3333333333333333333333333333333333333333",
+    message: "chore(deps): bump something unreleasable",
+  },
+];
+
+async function render(): Promise<string> {
+  return generateNotes(releaseNotesPluginConfig(), {
+    cwd: process.cwd(),
+    options: { repositoryUrl: "https://github.com/linearis-oss/linearis" },
+    lastRelease: { gitTag: "v2026.6.0", version: "2026.6.0" },
+    nextRelease: { gitTag: "v2026.7.0", version: "2026.7.0", channel: null },
+    commits: COMMITS,
+    logger: { log: () => {}, error: () => {} },
+  });
+}
+
+describe("release notes generation", () => {
+  it("renders grouped sections and bullets for releasable commits", async () => {
+    const notes = await render();
+
+    expect(notes).toContain("### Features");
+    expect(notes).toContain("### Bug Fixes");
+    expect(notes).toContain("* **issues:** add activity command");
+    expect(notes).toContain("* **labels:** allow clearing label description");
+  });
+
+  it("links commits and referenced issues", async () => {
+    const notes = await render();
+
+    expect(notes).toContain(
+      "https://github.com/linearis-oss/linearis/commit/1111111",
+    );
+    expect(notes).toContain(
+      "https://github.com/linearis-oss/linearis/issues/144",
+    );
+  });
+
+  it("omits non-deliverable commit types", async () => {
+    const notes = await render();
+
+    expect(notes).not.toContain("bump something unreleasable");
+  });
+});
diff --git a/tests/unit/resolvers/issue-filter-resolver.test.ts b/tests/unit/resolvers/issue-filter-resolver.test.ts
index a64fad32..f622eea5 100644
--- a/tests/unit/resolvers/issue-filter-resolver.test.ts
+++ b/tests/unit/resolvers/issue-filter-resolver.test.ts
@@ -53,8 +53,8 @@ type BatchNodes = {
   parentIssues?: Array<{ id: string; identifier: string }>;
 };
 
-function mockGql(nodes: BatchNodes) {
-  const request = vi.fn().mockResolvedValue({
+function buildBatchResponse(nodes: BatchNodes) {
+  return {
     teams: { nodes: nodes.teams ?? [] },
     assignees: { nodes: nodes.assignees ?? [] },
     creators: { nodes: nodes.creators ?? [] },
@@ -68,7 +68,11 @@ function mockGql(nodes: BatchNodes) {
     statuses: { nodes: nodes.statuses ?? [] },
     cycles: { nodes: nodes.cycles ?? [] },
     parentIssues: { nodes: nodes.parentIssues ?? [] },
-  });
+  };
+}
+
+function mockGql(nodes: BatchNodes) {
+  const request = vi.fn().mockResolvedValue(buildBatchResponse(nodes));
   return { client: { request } as unknown as GraphQLClient, request };
 }
 
@@ -189,4 +193,36 @@ describe("resolveSearchFilterIds", () => {
       assigneeId: "550e8400-e29b-41d4-a716-446655440000",
     });
   });
+
+  it("resolves `me` against the viewer, once for both user filters", async () => {
+    const { client, request } = mockGql({});
+    // `viewer` is the one request here that takes no variables.
+    request.mockImplementation((_document, variables) =>
+      variables === undefined
+        ? Promise.resolve({
+            viewer: {
+              id: "viewer-uuid",
+              name: "Me",
+              email: "me@example.com",
+            },
+          })
+        : Promise.resolve(buildBatchResponse({})),
+    );
+
+    const result = await resolveSearchFilterIds(client, {
+      assignee: "me",
+      creator: "@me",
+    });
+
+    expect(result).toEqual({
+      assigneeId: "viewer-uuid",
+      creatorId: "viewer-uuid",
+    });
+    expect(request).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ assigneeQuery: null, creatorQuery: null }),
+    );
+    // One viewer lookup plus the batch request — not one lookup per flag.
+    expect(request).toHaveBeenCalledTimes(2);
+  });
 });
diff --git a/tests/unit/resolvers/issue-mutation-resolver.test.ts b/tests/unit/resolvers/issue-mutation-resolver.test.ts
index 8598511b..71737fd3 100644
--- a/tests/unit/resolvers/issue-mutation-resolver.test.ts
+++ b/tests/unit/resolvers/issue-mutation-resolver.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from "vitest";
 import type { GraphQLClient } from "../../../src/client/graphql-client.js";
 import {
+  resolveBatchCreateIssueIds,
   resolveCreateIssueIds,
   resolveUpdateIssueIds,
 } from "../../../src/resolvers/issue-mutation-resolver.js";
@@ -412,3 +413,326 @@ describe("resolveUpdateIssueIds", () => {
     expect(result).toEqual({ assigneeId: UUID, projectId: UUID });
   });
 });
+
+describe("resolveBatchCreateIssueIds", () => {
+  const createResponse = (teamId: string, teamKey = "ENG") => ({
+    teams: {
+      nodes: [
+        {
+          id: teamId,
+          key: teamKey,
+          name: "Engineering",
+          issueEstimationType: "fibonacci",
+          issueEstimationExtended: false,
+          issueEstimationAllowZero: false,
+        },
+      ],
+    },
+    assignees: { nodes: [] },
+    projects: { nodes: [] },
+    labels: { nodes: [] },
+    statuses: { nodes: [] },
+    cycles: { nodes: [] },
+    parentIssues: { nodes: [] },
+  });
+
+  it("collapses entries that name the same references onto one request", async () => {
+    const request = vi.fn().mockResolvedValue(createResponse("team-uuid"));
+    const client = { request } as unknown as GraphQLClient;
+
+    const resolved = await resolveBatchCreateIssueIds(client, [
+      { team: "ENG" },
+      { team: "ENG" },
+      { team: "ENG" },
+    ]);
+
+    expect(resolved.map((ids) => ids.teamId)).toEqual([
+      "team-uuid",
+      "team-uuid",
+      "team-uuid",
+    ]);
+    expect(request).toHaveBeenCalledTimes(1);
+  });
+
+  it("resolves distinct reference sets separately, preserving input order", async () => {
+    const request = vi
+      .fn()
+      .mockResolvedValueOnce(createResponse("team-a"))
+      .mockResolvedValueOnce(createResponse("team-b", "DES"));
+    const client = { request } as unknown as GraphQLClient;
+
+    const resolved = await resolveBatchCreateIssueIds(client, [
+      { team: "ENG" },
+      { team: "DES" },
+    ]);
+
+    expect(resolved.map((ids) => ids.teamId)).toEqual(["team-a", "team-b"]);
+    expect(request).toHaveBeenCalledTimes(2);
+  });
+
+  it("propagates a not-found reference instead of skipping the entry", async () => {
+    const request = vi.fn().mockResolvedValue({
+      ...createResponse("team-uuid"),
+      teams: { nodes: [] },
+    });
+    const client = { request } as unknown as GraphQLClient;
+
+    await expect(
+      resolveBatchCreateIssueIds(client, [{ team: "NOPE" }]),
+    ).rejects.toThrow('Team "NOPE" not found');
+  });
+
+  it("bounds how many distinct reference sets are in flight at once", async () => {
+    // A heterogeneous import has one distinct set per row, so an unbounded
+    // fan-out would issue every request simultaneously and invite a
+    // rate-limit rejection.
+    let inFlight = 0;
+    let peak = 0;
+    const request = vi.fn().mockImplementation(async () => {
+      inFlight += 1;
+      peak = Math.max(peak, inFlight);
+      await Promise.resolve();
+      inFlight -= 1;
+      return createResponse("team-uuid");
+    });
+    const client = { request } as unknown as GraphQLClient;
+
+    // Distinct assignee UUIDs: they pass straight through the mappers, so
+    // each entry is its own reference set without needing 20 response shapes.
+    const entries = Array.from({ length: 20 }, (_, i) => ({
+      team: "ENG",
+      assignee: `550e8400-e29b-41d4-a716-4466554400${String(i).padStart(2, "0")}`,
+    }));
+    const resolved = await resolveBatchCreateIssueIds(client, entries);
+
+    expect(resolved).toHaveLength(20);
+    expect(request).toHaveBeenCalledTimes(20);
+    // Exactly the wave size: still concurrent, just bounded.
+    expect(peak).toBe(5);
+  });
+
+  it("keeps input order when the deduplicated sets resolve out of order", async () => {
+    const request = vi
+      .fn()
+      .mockResolvedValueOnce(createResponse("team-a"))
+      .mockResolvedValueOnce(createResponse("team-b", "DES"));
+    const client = { request } as unknown as GraphQLClient;
+
+    const resolved = await resolveBatchCreateIssueIds(client, [
+      { team: "ENG" },
+      { team: "DES" },
+      { team: "ENG" },
+    ]);
+
+    expect(resolved.map((ids) => ids.teamId)).toEqual([
+      "team-a",
+      "team-b",
+      "team-a",
+    ]);
+    expect(request).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe("resolveUpdateIssueIds team move", () => {
+  it("scopes the status lookup to the destination team, not the current one", async () => {
+    // resolveTeamId runs first (FindTeams), then the batch request.
+    const request = vi
+      .fn()
+      .mockResolvedValueOnce({
+        teams: { nodes: [{ id: "des-team", key: "DES", name: "Design" }] },
+      })
+      .mockResolvedValueOnce(
+        buildResponse({
+          statuses: [
+            {
+              id: "des-review",
+              name: "In Review",
+              team: { id: "des-team", key: "DES" },
+            },
+          ],
+        }),
+      );
+    const client = { request } as unknown as GraphQLClient;
+
+    const result = await resolveUpdateIssueIds(
+      client,
+      { team: "DES", status: "In Review" },
+      { teamId: "eng-team" as never, teamKey: "ENG" },
+    );
+
+    expect(result.teamId).toBe("des-team");
+    expect(result.stateId).toBe("des-review");
+    expect(request).toHaveBeenLastCalledWith(
+      expect.anything(),
+      expect.objectContaining({ teamId: "des-team", teamKey: null }),
+    );
+  });
+});
+
+describe("resolveUpdateIssueIds user references", () => {
+  it("resolves subscribers and delegate through the user resolver", async () => {
+    const request = vi.fn().mockImplementation((_document, variables) => {
+      const filter = (
+        variables as { filter?: Record<string, unknown> } | undefined
+      )?.filter;
+
+      if (filter && "displayName" in filter) {
+        const name = (filter as { displayName: { eqIgnoreCase: string } })
+          .displayName.eqIgnoreCase;
+        return Promise.resolve({
+          users: {
+            nodes: [{ id: `${name}-uuid`, name, email: `${name}@x.io` }],
+          },
+        });
+      }
+
+      return Promise.resolve(buildResponse({}));
+    });
+    const client = { request } as unknown as GraphQLClient;
+
+    const result = await resolveUpdateIssueIds(
+      client,
+      { subscribers: ["alice", "bob"], delegate: "carol" },
+      {},
+    );
+
+    expect(result.subscriberIds).toEqual(["alice-uuid", "bob-uuid"]);
+    expect(result.delegateId).toBe("carol-uuid");
+  });
+});
+
+describe("the `me` assignee alias", () => {
+  /**
+   * `viewer` is queried without variables; every other request in these
+   * resolvers passes some. That is enough to route the mock.
+   */
+  function mockGqlWithViewer(nodes: Nodes, viewerId = "viewer-uuid") {
+    const request = vi.fn().mockImplementation((_document, variables) =>
+      variables === undefined
+        ? Promise.resolve({
+            viewer: { id: viewerId, name: "Me", email: "me@example.com" },
+          })
+        : Promise.resolve(buildResponse(nodes)),
+    );
+    return { client: { request } as unknown as GraphQLClient, request };
+  }
+
+  it("resolves a create assignee against the viewer", async () => {
+    const { client, request } = mockGqlWithViewer({
+      teams: [{ id: "team-uuid", key: "ENG", name: "Engineering" }],
+    });
+
+    const result = await resolveCreateIssueIds(client, {
+      team: "ENG",
+      assignee: "me",
+    });
+
+    expect(result.assigneeId).toBe("viewer-uuid");
+    // "me" is not a display name — sending it as one would only come back
+    // empty and be reported as an unknown user.
+    expect(request).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ assigneeQuery: null }),
+    );
+  });
+
+  it("accepts the @me spelling and ignores case", async () => {
+    const { client } = mockGqlWithViewer({
+      teams: [{ id: "team-uuid", key: "ENG", name: "Engineering" }],
+    });
+
+    const result = await resolveCreateIssueIds(client, {
+      team: "ENG",
+      assignee: "@ME",
+    });
+
+    expect(result.assigneeId).toBe("viewer-uuid");
+  });
+
+  it("resolves an update assignee against the viewer", async () => {
+    const { client } = mockGqlWithViewer({});
+
+    const result = await resolveUpdateIssueIds(client, { assignee: "me" }, {});
+
+    expect(result.assigneeId).toBe("viewer-uuid");
+  });
+
+  it("still resolves a named assignee through the batch response", async () => {
+    const { client } = mockGqlWithViewer({
+      teams: [{ id: "team-uuid", key: "ENG", name: "Engineering" }],
+      assignees: [
+        {
+          id: "user-uuid",
+          name: "John",
+          email: "john@example.com",
+          displayName: "John Doe",
+        },
+      ],
+    });
+
+    const result = await resolveCreateIssueIds(client, {
+      team: "ENG",
+      assignee: "John Doe",
+    });
+
+    expect(result.assigneeId).toBe("user-uuid");
+  });
+});
+
+describe("user reference lookups and unhandled rejections", () => {
+  /**
+   * The user lookups run concurrently with the batch request. If one is only
+   * awaited on the success path, a failure of the other leaves its rejection
+   * unhandled — which in Node 22 tears the process down with a stack trace
+   * instead of letting handleCommand print the JSON error envelope.
+   */
+  async function collectUnhandled(
+    run: () => Promise<unknown>,
+  ): Promise<unknown[]> {
+    const unhandled: unknown[] = [];
+    const listener = (reason: unknown): void => {
+      unhandled.push(reason);
+    };
+
+    process.on("unhandledRejection", listener);
+    try {
+      await expect(run()).rejects.toThrow();
+      await new Promise((resolve) => setImmediate(resolve));
+    } finally {
+      process.off("unhandledRejection", listener);
+    }
+
+    return unhandled;
+  }
+
+  const failingClient = (): GraphQLClient =>
+    ({
+      request: vi
+        .fn()
+        .mockImplementation(() => Promise.reject(new Error("lookup failed"))),
+    }) as unknown as GraphQLClient;
+
+  it("surfaces create lookup failures without leaking a rejection", async () => {
+    const unhandled = await collectUnhandled(() =>
+      resolveCreateIssueIds(failingClient(), {
+        team: "ENG",
+        subscribers: ["alice"],
+        delegate: "carol",
+      }),
+    );
+
+    expect(unhandled).toEqual([]);
+  });
+
+  it("surfaces update lookup failures without leaking a rejection", async () => {
+    const unhandled = await collectUnhandled(() =>
+      resolveUpdateIssueIds(
+        failingClient(),
+        { team: "DES", subscribers: ["alice"], delegate: "carol" },
+        {},
+      ),
+    );
+
+    expect(unhandled).toEqual([]);
+  });
+});
diff --git a/tests/unit/resolvers/issue-resolver.test.ts b/tests/unit/resolvers/issue-resolver.test.ts
index eab3159b..a0a0fed7 100644
--- a/tests/unit/resolvers/issue-resolver.test.ts
+++ b/tests/unit/resolvers/issue-resolver.test.ts
@@ -4,6 +4,7 @@ import type { GraphQLClient } from "../../../src/client/graphql-client.js";
 import {
   resolveIssueEstimateContext,
   resolveIssueId,
+  resolveIssueRefs,
 } from "../../../src/resolvers/issue-resolver.js";
 
 type IssueNode = {
@@ -130,3 +131,91 @@ describe("resolveIssueEstimateContext", () => {
     ).rejects.toThrow('Issue "ENG-999" not found');
   });
 });
+
+describe("resolveIssueRefs", () => {
+  const nodes = [
+    {
+      id: "550e8400-e29b-41d4-a716-4466554400e1",
+      number: 1,
+      team: { id: teamId, key: "ENG" },
+    },
+    { id: "eng-2-uuid", number: 2, team: { id: teamId, key: "ENG" } },
+    { id: "des-1-uuid", number: 1, team: { id: "des-team", key: "DES" } },
+  ];
+
+  function mockRefsClient() {
+    const request = vi.fn().mockResolvedValue({ issues: { nodes } });
+    return { request, client: { request } as unknown as GraphQLClient };
+  }
+
+  it("resolves every reference in a single request", async () => {
+    const { request, client } = mockRefsClient();
+
+    const resolved = await resolveIssueRefs(client, ["ENG-1", "DES-1"]);
+
+    expect(resolved).toEqual([
+      {
+        ref: "ENG-1",
+        id: "550e8400-e29b-41d4-a716-4466554400e1",
+        teamId,
+        teamKey: "ENG",
+      },
+      { ref: "DES-1", id: "des-1-uuid", teamId: "des-team", teamKey: "DES" },
+    ]);
+    expect(request).toHaveBeenCalledTimes(1);
+    expect(request).toHaveBeenCalledWith(expect.anything(), {
+      filter: {
+        or: [
+          { number: { eq: 1 }, team: { key: { eq: "ENG" } } },
+          { number: { eq: 1 }, team: { key: { eq: "DES" } } },
+        ],
+      },
+      first: 2,
+    });
+  });
+
+  it("distinguishes the same issue number across teams", async () => {
+    const { client } = mockRefsClient();
+
+    const resolved = await resolveIssueRefs(client, ["DES-1"]);
+
+    expect(resolved[0]?.id).toBe("des-1-uuid");
+  });
+
+  it("collapses duplicate references, preserving first-seen order", async () => {
+    const { client } = mockRefsClient();
+
+    const resolved = await resolveIssueRefs(client, [
+      "ENG-2",
+      "ENG-1",
+      "ENG-2",
+    ]);
+
+    expect(resolved.map((entry) => entry.ref)).toEqual(["ENG-2", "ENG-1"]);
+  });
+
+  it("looks up UUID references too, since a UUID carries no team", async () => {
+    const { client } = mockRefsClient();
+
+    const resolved = await resolveIssueRefs(client, [
+      "550e8400-e29b-41d4-a716-4466554400e1",
+    ]);
+
+    expect(resolved[0]?.teamKey).toBe("ENG");
+  });
+
+  it("throws for a reference with no match", async () => {
+    const { client } = mockRefsClient();
+
+    await expect(resolveIssueRefs(client, ["ENG-99"])).rejects.toThrow(
+      'Issue "ENG-99" not found',
+    );
+  });
+
+  it("makes no request for an empty list", async () => {
+    const { request, client } = mockRefsClient();
+
+    await expect(resolveIssueRefs(client, [])).resolves.toEqual([]);
+    expect(request).not.toHaveBeenCalled();
+  });
+});
diff --git a/tests/unit/resolvers/milestone-resolver.test.ts b/tests/unit/resolvers/milestone-resolver.test.ts
index 12a1d394..0e3f54bc 100644
--- a/tests/unit/resolvers/milestone-resolver.test.ts
+++ b/tests/unit/resolvers/milestone-resolver.test.ts
@@ -39,10 +39,30 @@ describe("resolveMilestoneId", () => {
     const gql = mockGqlClient(
       { projects: { nodes: [{ id: "proj-uuid" }] } },
       { project: { projectMilestones: { nodes: [] } } },
-      { projectMilestones: { nodes: [] } },
     );
     await expect(
       resolveMilestoneId(gql, "Nonexistent", "My Project"),
-    ).rejects.toThrow('Milestone "Nonexistent" not found');
+    ).rejects.toThrow(
+      'Milestone "Nonexistent" in project "My Project" not found',
+    );
+  });
+
+  it("does not fall back to the workspace when scoped to a project", async () => {
+    const gql = mockGqlClient(
+      { projects: { nodes: [{ id: "proj-uuid" }] } },
+      { project: { projectMilestones: { nodes: [] } } },
+      { projectMilestones: { nodes: [{ id: "other-uuid", name: "Launch" }] } },
+    );
+    await expect(
+      resolveMilestoneId(gql, "Launch", "My Project"),
+    ).rejects.toThrow('Milestone "Launch" in project "My Project" not found');
+    expect(gql.request).toHaveBeenCalledTimes(2);
+  });
+
+  it("searches the workspace when no project scope is given", async () => {
+    const gql = mockGqlClient({
+      projectMilestones: { nodes: [{ id: "ms-uuid", name: "Launch" }] },
+    });
+    expect(await resolveMilestoneId(gql, "Launch")).toBe("ms-uuid");
   });
 });
diff --git a/tests/unit/resolvers/project-relation-resolver.test.ts b/tests/unit/resolvers/project-relation-resolver.test.ts
new file mode 100644
index 00000000..23cd1977
--- /dev/null
+++ b/tests/unit/resolvers/project-relation-resolver.test.ts
@@ -0,0 +1,188 @@
+import { describe, expect, it, vi } from "vitest";
+import type { GraphQLClient } from "../../../src/client/graphql-client.js";
+import { asUuid } from "../../../src/common/identifier.js";
+import { resolveProjectRelation } from "../../../src/resolvers/project-relation-resolver.js";
+import { captureRejection } from "../helpers/capture-rejection.js";
+
+const PROJECT_A = "550e8400-e29b-41d4-a716-446655440000";
+const PROJECT_B = "550e8400-e29b-41d4-a716-446655440001";
+const RELATION = "550e8400-e29b-41d4-a716-4466554400ff";
+const OTHER_RELATION = "550e8400-e29b-41d4-a716-4466554400fe";
+const MILESTONE = "550e8400-e29b-41d4-a716-446655440010";
+
+interface RelationPage {
+  nodes: unknown[];
+  hasNextPage?: boolean;
+}
+
+function connection({ nodes, hasNextPage = false }: RelationPage): unknown {
+  return { nodes, pageInfo: { hasNextPage } };
+}
+
+function mockGqlClient(project: unknown): GraphQLClient {
+  return {
+    request: vi.fn().mockResolvedValue({ project }),
+  } as unknown as GraphQLClient;
+}
+
+describe("resolveProjectRelation", () => {
+  it("returns a bare UUID as-is without calling the API", async () => {
+    const client = mockGqlClient(null);
+
+    await expect(resolveProjectRelation(client, RELATION)).resolves.toEqual({
+      id: RELATION,
+      inverted: false,
+    });
+    expect(client.request).not.toHaveBeenCalled();
+  });
+
+  it("finds the relation the project declares", async () => {
+    const client = mockGqlClient({
+      relations: connection({
+        nodes: [{ id: RELATION, relatedProject: { id: PROJECT_B } }],
+      }),
+      inverseRelations: connection({ nodes: [] }),
+    });
+
+    await expect(
+      resolveProjectRelation(client, PROJECT_A, asUuid(PROJECT_B)),
+    ).resolves.toEqual({ id: RELATION, inverted: false });
+  });
+
+  it("reports the inverted direction when the other project declared it", async () => {
+    const client = mockGqlClient({
+      relations: connection({ nodes: [] }),
+      inverseRelations: connection({
+        nodes: [{ id: RELATION, project: { id: PROJECT_B } }],
+      }),
+    });
+
+    await expect(
+      resolveProjectRelation(client, PROJECT_A, asUuid(PROJECT_B)),
+    ).resolves.toEqual({ id: RELATION, inverted: true });
+  });
+
+  it("lists the candidates when the pair carries several relations", async () => {
+    const client = mockGqlClient({
+      relations: connection({
+        nodes: [
+          {
+            id: RELATION,
+            type: "blocks",
+            project: { id: PROJECT_A, name: "Alpha" },
+            projectMilestone: { id: MILESTONE, name: "M1" },
+            relatedProject: { id: PROJECT_B, name: "Beta" },
+            relatedProjectMilestone: null,
+          },
+          {
+            id: OTHER_RELATION,
+            type: "blocks",
+            project: { id: PROJECT_A, name: "Alpha" },
+            projectMilestone: { id: MILESTONE, name: "M2" },
+            relatedProject: { id: PROJECT_B, name: "Beta" },
+            relatedProjectMilestone: null,
+          },
+        ],
+      }),
+      inverseRelations: connection({ nodes: [] }),
+    });
+
+    const error = await captureRejection(
+      resolveProjectRelation(client, PROJECT_A, asUuid(PROJECT_B)),
+    );
+
+    expect(error.message).toContain(
+      `Multiple project relations found matching "between ${PROJECT_A} and ${PROJECT_B}"`,
+    );
+    expect(error.message).toContain(`Alpha/M1 blocks Beta (${RELATION})`);
+    expect(error.message).toContain(`Alpha/M2 blocks Beta (${OTHER_RELATION})`);
+    expect(error.message).toContain("address the relation by UUID");
+  });
+
+  it("does not prefer the forward direction when both directions match", async () => {
+    const client = mockGqlClient({
+      relations: connection({
+        nodes: [
+          {
+            id: RELATION,
+            type: "blocks",
+            project: { id: PROJECT_A, name: "Alpha" },
+            projectMilestone: null,
+            relatedProject: { id: PROJECT_B, name: "Beta" },
+            relatedProjectMilestone: null,
+          },
+        ],
+      }),
+      inverseRelations: connection({
+        nodes: [
+          {
+            id: OTHER_RELATION,
+            type: "blocks",
+            project: { id: PROJECT_B, name: "Beta" },
+            projectMilestone: null,
+            relatedProject: { id: PROJECT_A, name: "Alpha" },
+            relatedProjectMilestone: null,
+          },
+        ],
+      }),
+    });
+
+    await expect(
+      resolveProjectRelation(client, PROJECT_A, asUuid(PROJECT_B)),
+    ).rejects.toThrow("Multiple project relations found");
+  });
+
+  it("throws when the two projects are not related", async () => {
+    const client = mockGqlClient({
+      relations: connection({ nodes: [] }),
+      inverseRelations: connection({ nodes: [] }),
+    });
+
+    await expect(
+      resolveProjectRelation(client, PROJECT_A, asUuid(PROJECT_B)),
+    ).rejects.toThrow(
+      `Project relation "between ${PROJECT_A} and ${PROJECT_B}" not found`,
+    );
+  });
+
+  it("reports the page bound rather than a false miss", async () => {
+    const client = mockGqlClient({
+      relations: connection({ nodes: [], hasNextPage: true }),
+      inverseRelations: connection({ nodes: [] }),
+    });
+
+    await expect(
+      resolveProjectRelation(client, PROJECT_A, asUuid(PROJECT_B)),
+    ).rejects.toThrow("more than 100 dependencies in one direction");
+  });
+
+  it("refuses a lone match when a duplicate could sit past the page bound", async () => {
+    const client = mockGqlClient({
+      relations: connection({
+        nodes: [{ id: RELATION, relatedProject: { id: PROJECT_B } }],
+        hasNextPage: true,
+      }),
+      inverseRelations: connection({ nodes: [] }),
+    });
+
+    await expect(
+      resolveProjectRelation(client, PROJECT_A, asUuid(PROJECT_B)),
+    ).rejects.toThrow("more than 100 dependencies in one direction");
+  });
+
+  it("throws when the project does not exist", async () => {
+    const client = mockGqlClient(null);
+
+    await expect(
+      resolveProjectRelation(client, PROJECT_A, asUuid(PROJECT_B)),
+    ).rejects.toThrow(`Project "${PROJECT_A}" not found`);
+  });
+
+  it("rejects a non-UUID relation given without a counterpart", async () => {
+    const client = mockGqlClient(null);
+
+    await expect(resolveProjectRelation(client, "not-a-uuid")).rejects.toThrow(
+      'Project relation "not-a-uuid" not found',
+    );
+  });
+});
diff --git a/tests/unit/resolvers/project-status-resolver.test.ts b/tests/unit/resolvers/project-status-resolver.test.ts
index 488580e3..a63ac289 100644
--- a/tests/unit/resolvers/project-status-resolver.test.ts
+++ b/tests/unit/resolvers/project-status-resolver.test.ts
@@ -1,11 +1,15 @@
 import { describe, expect, it, vi } from "vitest";
 import type { GraphQLClient } from "../../../src/client/graphql-client.js";
 import { resolveProjectStatusId } from "../../../src/resolvers/project-status-resolver.js";
+import { captureRejection } from "../helpers/capture-rejection.js";
 
-function mockGqlClient(nodes: Array<{ id: string; name: string }>) {
+function mockGqlClient(
+  nodes: Array<{ id: string; name: string; archivedAt?: string | null }>,
+  hasNextPage = false,
+) {
   return {
     request: vi.fn().mockResolvedValue({
-      projectStatuses: { nodes },
+      projectStatuses: { nodes, pageInfo: { hasNextPage } },
     }),
   } as unknown as GraphQLClient;
 }
@@ -33,10 +37,88 @@ describe("resolveProjectStatusId", () => {
     expect(result).toBe("status-uuid");
   });
 
+  it("excludes archived statuses unless asked", async () => {
+    const client = mockGqlClient([{ id: "status-uuid", name: "Started" }]);
+    await resolveProjectStatusId(client, "Started");
+
+    expect(client.request).toHaveBeenCalledWith(expect.anything(), {
+      includeArchived: false,
+      first: 250,
+    });
+  });
+
+  it("searches archived statuses when asked", async () => {
+    const client = mockGqlClient([{ id: "status-uuid", name: "Retired" }]);
+    const result = await resolveProjectStatusId(client, "Retired", {
+      includeArchived: true,
+    });
+
+    expect(result).toBe("status-uuid");
+    expect(client.request).toHaveBeenCalledWith(expect.anything(), {
+      includeArchived: true,
+      first: 250,
+    });
+  });
+
+  it("refuses to choose between an archived and a live status of the same name", async () => {
+    const client = mockGqlClient([
+      { id: "old-uuid", name: "In Review", archivedAt: "2026-01-01T00:00:00Z" },
+      { id: "new-uuid", name: "In Review", archivedAt: null },
+    ]);
+
+    const error = await captureRejection(
+      resolveProjectStatusId(client, "In Review", { includeArchived: true }),
+    );
+
+    expect(error.message).toContain(
+      'Multiple project statuses found matching "In Review"',
+    );
+    expect(error.message).toContain("In Review (archived) (old-uuid)");
+    expect(error.message).toContain("In Review (new-uuid)");
+    expect(error.message).toContain("address the status by UUID");
+  });
+
   it("throws when status not found", async () => {
     const client = mockGqlClient([]);
     await expect(resolveProjectStatusId(client, "Nonexistent")).rejects.toThrow(
       'Project status "Nonexistent" not found',
     );
   });
+
+  it("refuses a miss past the page bound instead of reporting it missing", async () => {
+    const client = mockGqlClient([{ id: "other-uuid", name: "Started" }], true);
+
+    await expect(resolveProjectStatusId(client, "Retired")).rejects.toThrow(
+      "more than 250 project statuses",
+    );
+  });
+
+  it("refuses a lone match past the page bound", async () => {
+    const client = mockGqlClient(
+      [{ id: "status-uuid", name: "Started" }],
+      true,
+    );
+
+    await expect(resolveProjectStatusId(client, "Started")).rejects.toThrow(
+      "more than 250 project statuses",
+    );
+  });
+
+  it("still names an ambiguity found past the page bound", async () => {
+    const client = mockGqlClient(
+      [
+        {
+          id: "old-uuid",
+          name: "In Review",
+          archivedAt: "2026-01-01T00:00:00Z",
+        },
+        { id: "new-uuid", name: "In Review", archivedAt: null },
+      ],
+      true,
+    );
+
+    await expect(
+      resolveProjectStatusId(client, "In Review", { includeArchived: true }),
+    ).rejects.toThrow('Multiple project statuses found matching "In Review"');
+  });
 });
diff --git a/tests/unit/resolvers/user-resolver.test.ts b/tests/unit/resolvers/user-resolver.test.ts
index d794ec7c..ba602b21 100644
--- a/tests/unit/resolvers/user-resolver.test.ts
+++ b/tests/unit/resolvers/user-resolver.test.ts
@@ -1,7 +1,11 @@
 // tests/unit/resolvers/user-resolver.test.ts
 import { describe, expect, it, vi } from "vitest";
 import type { GraphQLClient } from "../../../src/client/graphql-client.js";
-import { resolveUserId } from "../../../src/resolvers/user-resolver.js";
+import { GetViewerDocument } from "../../../src/gql/graphql.js";
+import {
+  resolveUserId,
+  resolveViewerId,
+} from "../../../src/resolvers/user-resolver.js";
 
 interface MockUser {
   id: string;
@@ -77,3 +81,30 @@ describe("resolveUserId", () => {
     );
   });
 });
+
+describe("resolveViewerId", () => {
+  it("returns the authenticated user's UUID", async () => {
+    const request = vi
+      .fn()
+      .mockResolvedValue({ viewer: { id: "viewer-uuid" } });
+    const client = { request } as unknown as GraphQLClient;
+
+    await expect(resolveViewerId(client)).resolves.toBe("viewer-uuid");
+    expect(request).toHaveBeenCalledWith(GetViewerDocument);
+  });
+});
+
+describe("resolveUserId viewer aliases", () => {
+  it.each(["me", "@me", "ME"])(
+    "resolves %s to the viewer without a user lookup",
+    async (alias) => {
+      const request = vi
+        .fn()
+        .mockResolvedValue({ viewer: { id: "viewer-uuid" } });
+      const client = { request } as unknown as GraphQLClient;
+
+      await expect(resolveUserId(client, alias)).resolves.toBe("viewer-uuid");
+      expect(request).toHaveBeenCalledExactlyOnceWith(GetViewerDocument);
+    },
+  );
+});
diff --git a/tests/unit/services/attachment-service.test.ts b/tests/unit/services/attachment-service.test.ts
index 386af314..d40c209b 100644
--- a/tests/unit/services/attachment-service.test.ts
+++ b/tests/unit/services/attachment-service.test.ts
@@ -3,9 +3,11 @@
 import { describe, expect, it, vi } from "vitest";
 import type { GraphQLClient } from "../../../src/client/graphql-client.js";
 import { asUuid } from "../../../src/common/identifier.js";
+import { AttachmentExternalSyncDisableDocument } from "../../../src/gql/graphql.js";
 import {
   createAttachment,
   deleteAttachment,
+  disableExternalSync,
   listAttachments,
 } from "../../../src/services/attachment-service.js";
 
@@ -114,3 +116,31 @@ describe("listAttachments", () => {
     );
   });
 });
+
+describe("disableExternalSync", () => {
+  it("returns the affected issue", async () => {
+    const client = mockGqlClient({
+      issueExternalSyncDisable: { success: true, issue: { id: "issue-1" } },
+    });
+
+    await expect(
+      disableExternalSync(client, asUuid("attachment-1")),
+    ).resolves.toEqual({ id: "issue-1" });
+    expect(client.request).toHaveBeenCalledWith(
+      AttachmentExternalSyncDisableDocument,
+      { attachmentId: "attachment-1" },
+    );
+  });
+
+  it("names the attachment when the mutation fails", async () => {
+    const client = mockGqlClient({
+      issueExternalSyncDisable: { success: false, issue: null },
+    });
+
+    await expect(
+      disableExternalSync(client, asUuid("attachment-1")),
+    ).rejects.toThrow(
+      'Failed to disable external sync for attachment "attachment-1"',
+    );
+  });
+});
diff --git a/tests/unit/services/issue-filter.test.ts b/tests/unit/services/issue-filter.test.ts
index 1f8b0bd2..e8879e26 100644
--- a/tests/unit/services/issue-filter.test.ts
+++ b/tests/unit/services/issue-filter.test.ts
@@ -184,3 +184,23 @@ describe("buildIssueFilter", () => {
     });
   });
 });
+
+describe("buildIssueFilter state, assignee and subscriber scoping", () => {
+  it("maps --unassigned to a null assignee", () => {
+    expect(buildIssueFilter({ unassigned: true })).toEqual({
+      and: [{ assignee: { null: true } }],
+    });
+  });
+
+  it("maps --state-type to the state category", () => {
+    expect(buildIssueFilter({ stateType: "started" })).toEqual({
+      and: [{ state: { type: { eq: "started" } } }],
+    });
+  });
+
+  it("maps --subscriber to a subscribers.some clause", () => {
+    expect(buildIssueFilter({ subscriberId: "user-1" })).toEqual({
+      and: [{ subscribers: { some: { id: { eq: "user-1" } } } }],
+    });
+  });
+});
diff --git a/tests/unit/services/issue-service.test.ts b/tests/unit/services/issue-service.test.ts
index 9ef206e5..37c3f706 100644
--- a/tests/unit/services/issue-service.test.ts
+++ b/tests/unit/services/issue-service.test.ts
@@ -1,11 +1,19 @@
-import { type DocumentNode, type FragmentDefinitionNode, Kind } from "graphql";
+import {
+  type DocumentNode,
+  type FragmentDefinitionNode,
+  Kind,
+  print,
+} from "graphql";
 import { describe, expect, it, vi } from "vitest";
 import type { GraphQLClient } from "../../../src/client/graphql-client.js";
 import { asUuid } from "../../../src/common/identifier.js";
 import {
   ArchiveIssueDocument,
+  BatchCreateIssuesDocument,
+  BatchUpdateIssuesDocument,
   DeleteIssueDocument,
   FilteredSearchIssuesDocument,
+  FindIssuesDocument,
   GetIssueByIdDocument,
   GetIssueByIdentifierDocument,
   GetIssueByIdentifierWithAttachmentsDocument,
@@ -14,14 +22,23 @@ import {
   GetIssueByIdWithAttachmentsDocument,
   GetIssueByIdWithCommentsDocument,
   GetIssueByIdWithReactionsDocument,
-  GetIssuesDocument,
+  IssueVcsBranchSearchDocument,
+  RemindOnIssueDocument,
   SearchIssuesDocument,
+  ShareIssueDocument,
+  SubscribeToIssueDocument,
   UnarchiveIssueDocument,
+  UnshareIssueDocument,
+  UnsubscribeFromIssueDocument,
+  UpdateIssueDocument,
 } from "../../../src/gql/graphql.js";
 import {
   archiveIssue,
+  batchCreateIssues,
+  batchUpdateIssues,
   createIssue,
   deleteIssue,
+  findIssueByBranch,
   getIssue,
   getIssueByIdentifier,
   getIssueByIdentifierWithAttachments,
@@ -33,8 +50,15 @@ import {
   getIssueWithCommentThreads,
   getIssueWithReactions,
   listIssues,
+  remindOnIssue,
+  restoreIssue,
   searchIssues,
+  shareIssue,
+  snoozeIssue,
+  subscribeToIssue,
   unarchiveIssue,
+  unshareIssue,
+  unsubscribeFromIssue,
   updateIssue,
 } from "../../../src/services/issue-service.js";
 
@@ -105,7 +129,146 @@ describe("attachment issue read documents", () => {
   });
 });
 
+describe("issue read payload", () => {
+  const scalarNames = (document: DocumentNode, fragment: string): string[] =>
+    getFragment(document, fragment)
+      .selectionSet.selections.filter(
+        (selection) => selection.kind === Kind.FIELD,
+      )
+      .map((selection) => selection.name.value);
+
+  it("exposes the issue url and lifecycle timestamps on list and search", () => {
+    const expected = [
+      "url",
+      "startedAt",
+      "completedAt",
+      "canceledAt",
+      "archivedAt",
+      "snoozedUntilAt",
+      "trashed",
+      "creator",
+      "delegate",
+    ];
+
+    expect(
+      scalarNames(FilteredSearchIssuesDocument, "CompleteIssueFields"),
+    ).toEqual(expect.arrayContaining(expected));
+    expect(
+      scalarNames(SearchIssuesDocument, "CompleteIssueSearchFields"),
+    ).toEqual(expect.arrayContaining(expected));
+  });
+
+  it("keeps subscribers and sharedAccess off the list fragment", () => {
+    // They belong to single-issue reads only — see IssueDetailOnlyFields.
+    const listFields = scalarNames(
+      FilteredSearchIssuesDocument,
+      "CompleteIssueFields",
+    );
+    expect(listFields).not.toContain("subscribers");
+    expect(listFields).not.toContain("sharedAccess");
+
+    expect(print(GetIssueByIdDocument)).toContain("IssueDetailOnlyFields");
+    expect(print(GetIssueByIdWithCommentsDocument)).toContain(
+      "IssueDetailOnlyFields",
+    );
+    expect(print(FilteredSearchIssuesDocument)).not.toContain(
+      "IssueDetailOnlyFields",
+    );
+  });
+});
+
+describe("archived issue reachability", () => {
+  it("resolves identifiers against archived issues too", () => {
+    // resolveIssueId / the identifier read path go through these documents; if
+    // they stop including archived issues, `issues unarchive ENG-42` breaks.
+    const documents = [
+      FindIssuesDocument,
+      GetIssueByIdentifierDocument,
+      GetIssueByIdentifierWithCommentsDocument,
+      GetIssueByIdentifierWithReactionsDocument,
+      GetIssueByIdentifierWithAttachmentsDocument,
+    ];
+
+    for (const document of documents) {
+      expect(print(document)).toContain("includeArchived: true");
+    }
+  });
+
+  it("keeps list and search opt-in rather than always-archived", () => {
+    for (const document of [
+      FilteredSearchIssuesDocument,
+      SearchIssuesDocument,
+    ]) {
+      expect(print(document)).toContain("$includeArchived: Boolean = false");
+    }
+  });
+});
+
 describe("listIssues", () => {
+  it("forwards includeArchived on both the filtered and unfiltered paths", async () => {
+    for (const filter of [undefined, { priority: { eq: 1 } }]) {
+      const client = mockGqlClient({
+        issues: {
+          nodes: [],
+          pageInfo: { hasNextPage: false, endCursor: null },
+        },
+      });
+      await listIssues(client, { limit: 10, includeArchived: true }, filter);
+      expect(client.request).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({ includeArchived: true }),
+      );
+    }
+  });
+
+  it("keeps updatedAt ordering by default and honours an override", async () => {
+    for (const [options, expected] of [
+      [{ limit: 10 }, "updatedAt"],
+      [{ limit: 10, orderBy: "createdAt" as const }, "createdAt"],
+    ] as const) {
+      const client = mockGqlClient({
+        issues: {
+          nodes: [],
+          pageInfo: { hasNextPage: false, endCursor: null },
+        },
+      });
+      await listIssues(client, options);
+      expect(client.request).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({ orderBy: expected }),
+      );
+    }
+  });
+
+  it("still excludes completed issues by default when a filter is given", async () => {
+    // Regression guard: parameterizing orderBy must not drop the implicit
+    // non-completed clause.
+    const client = mockGqlClient({
+      issues: {
+        nodes: [],
+        pageInfo: { hasNextPage: false, endCursor: null },
+      },
+    });
+
+    await listIssues(
+      client,
+      { limit: 10, orderBy: "createdAt" },
+      { priority: { eq: 1 } },
+    );
+
+    expect(client.request).toHaveBeenCalledWith(
+      FilteredSearchIssuesDocument,
+      expect.objectContaining({
+        filter: {
+          and: [
+            { state: { type: { neq: "completed" } } },
+            { priority: { eq: 1 } },
+          ],
+        },
+      }),
+    );
+  });
+
   it("returns issues from query", async () => {
     const client = mockGqlClient({
       issues: {
@@ -145,7 +308,9 @@ describe("listIssues", () => {
     expect(client.request).toHaveBeenCalledWith(expect.anything(), {
       first: 25,
       after: undefined,
+      filter: { state: { type: { neq: "completed" } } },
       orderBy: "updatedAt",
+      includeArchived: false,
     });
   });
 
@@ -160,7 +325,9 @@ describe("listIssues", () => {
     expect(client.request).toHaveBeenCalledWith(expect.anything(), {
       first: 5,
       after: "cursor1",
+      filter: { state: { type: { neq: "completed" } } },
       orderBy: "updatedAt",
+      includeArchived: false,
     });
   });
 
@@ -198,6 +365,7 @@ describe("listIssues", () => {
         ],
       },
       orderBy: "updatedAt",
+      includeArchived: false,
     });
   });
 
@@ -222,10 +390,11 @@ describe("listIssues", () => {
       after: undefined,
       filter,
       orderBy: "updatedAt",
+      includeArchived: false,
     });
   });
 
-  it("uses GetIssues query when no filter provided (no regression)", async () => {
+  it("applies the non-completed default on the unfiltered path too", async () => {
     const client = mockGqlClient({
       issues: {
         nodes: [],
@@ -233,12 +402,37 @@ describe("listIssues", () => {
       },
     });
     await listIssues(client);
-    expect(client.request).toHaveBeenCalledWith(GetIssuesDocument, {
+    expect(client.request).toHaveBeenCalledWith(FilteredSearchIssuesDocument, {
       first: 25,
       after: undefined,
+      filter: { state: { type: { neq: "completed" } } },
       orderBy: "updatedAt",
+      includeArchived: false,
     });
   });
+
+  it("drops the non-completed default when archived issues are requested", async () => {
+    // Archived issues are almost always completed, so keeping the implicit
+    // clause would make --include-archived hide what it was passed to show.
+    for (const [filter, expected] of [
+      [undefined, undefined],
+      [{ priority: { eq: 1 } }, { priority: { eq: 1 } }],
+    ] as const) {
+      const client = mockGqlClient({
+        issues: {
+          nodes: [],
+          pageInfo: { hasNextPage: false, endCursor: null },
+        },
+      });
+
+      await listIssues(client, { limit: 10, includeArchived: true }, filter);
+
+      expect(client.request).toHaveBeenCalledWith(
+        FilteredSearchIssuesDocument,
+        expect.objectContaining({ filter: expected, includeArchived: true }),
+      );
+    }
+  });
 });
 
 describe("getIssue", () => {
@@ -786,6 +980,7 @@ describe("searchIssues", () => {
       term: "query",
       first: 5,
       after: "prevCursor",
+      includeArchived: false,
     });
   });
 
@@ -803,6 +998,7 @@ describe("searchIssues", () => {
       term: "bug",
       first: 10,
       after: undefined,
+      includeArchived: false,
       filter,
     });
   });
@@ -819,6 +1015,7 @@ describe("searchIssues", () => {
       term: "test",
       first: 25,
       after: undefined,
+      includeArchived: false,
     });
   });
 });
@@ -905,3 +1102,227 @@ describe("deleteIssue", () => {
     );
   });
 });
+
+describe("subscriber and sharing mutations", () => {
+  const issueId = asUuid("issue-1");
+  const userId = asUuid("user-1");
+
+  const cases = [
+    {
+      name: "subscribeToIssue",
+      call: subscribeToIssue,
+      document: SubscribeToIssueDocument,
+      payloadKey: "issueSubscribe",
+      failure: 'Failed to subscribe user "user-1" to issue "issue-1"',
+    },
+    {
+      name: "unsubscribeFromIssue",
+      call: unsubscribeFromIssue,
+      document: UnsubscribeFromIssueDocument,
+      payloadKey: "issueUnsubscribe",
+      failure: 'Failed to unsubscribe user "user-1" from issue "issue-1"',
+    },
+    {
+      name: "shareIssue",
+      call: shareIssue,
+      document: ShareIssueDocument,
+      payloadKey: "issueShare",
+      failure: 'Failed to share issue "issue-1" with user "user-1"',
+    },
+    {
+      name: "unshareIssue",
+      call: unshareIssue,
+      document: UnshareIssueDocument,
+      payloadKey: "issueUnshare",
+      failure: 'Failed to unshare issue "issue-1" from user "user-1"',
+    },
+  ] as const;
+
+  it.each(cases)("$name returns the updated issue", async (testCase) => {
+    const client = mockGqlClient({
+      [testCase.payloadKey]: { success: true, issue: { id: "issue-1" } },
+    });
+
+    await expect(testCase.call(client, issueId, userId)).resolves.toEqual({
+      id: "issue-1",
+    });
+    expect(client.request).toHaveBeenCalledWith(testCase.document, {
+      id: "issue-1",
+      userId: "user-1",
+    });
+  });
+
+  it.each(cases)("$name throws when the mutation fails", async (testCase) => {
+    const client = mockGqlClient({
+      [testCase.payloadKey]: { success: false, issue: null },
+    });
+
+    await expect(testCase.call(client, issueId, userId)).rejects.toThrow(
+      testCase.failure,
+    );
+  });
+});
+
+describe("remindOnIssue", () => {
+  it("passes the reminder instant through untouched", async () => {
+    const client = mockGqlClient({
+      issueReminder: { success: true, issue: { id: "issue-1" } },
+    });
+
+    await expect(
+      remindOnIssue(client, asUuid("issue-1"), "2026-08-14T09:00:00.000Z"),
+    ).resolves.toEqual({ id: "issue-1" });
+    expect(client.request).toHaveBeenCalledWith(RemindOnIssueDocument, {
+      id: "issue-1",
+      reminderAt: "2026-08-14T09:00:00.000Z",
+    });
+  });
+
+  it("throws when the mutation fails", async () => {
+    const client = mockGqlClient({
+      issueReminder: { success: false, issue: null },
+    });
+
+    await expect(
+      remindOnIssue(client, asUuid("issue-1"), "2026-08-14T09:00:00.000Z"),
+    ).rejects.toThrow('Failed to set a reminder on issue "issue-1"');
+  });
+});
+
+describe("batchCreateIssues", () => {
+  it("wraps the inputs in the batch input shape", async () => {
+    const client = mockGqlClient({
+      issueBatchCreate: { success: true, issues: [{ id: "issue-1" }] },
+    });
+
+    await expect(
+      batchCreateIssues(client, [
+        { title: "A", teamId: asUuid("team-1") },
+        { title: "B", teamId: asUuid("team-1") },
+      ]),
+    ).resolves.toEqual([{ id: "issue-1" }]);
+
+    expect(client.request).toHaveBeenCalledWith(BatchCreateIssuesDocument, {
+      input: {
+        issues: [
+          { title: "A", teamId: "team-1" },
+          { title: "B", teamId: "team-1" },
+        ],
+      },
+    });
+  });
+
+  it("throws when the transaction reports failure", async () => {
+    const client = mockGqlClient({
+      issueBatchCreate: { success: false, issues: [] },
+    });
+
+    await expect(
+      batchCreateIssues(client, [{ title: "A", teamId: asUuid("team-1") }]),
+    ).rejects.toThrow("Failed to create 1 issues");
+  });
+});
+
+describe("batchUpdateIssues", () => {
+  it("sends the id list and one shared patch", async () => {
+    const client = mockGqlClient({
+      issueBatchUpdate: { success: true, issues: [{ id: "issue-1" }] },
+    });
+
+    await expect(
+      batchUpdateIssues(client, [asUuid("issue-1"), asUuid("issue-2")], {
+        priority: 2,
+      }),
+    ).resolves.toEqual([{ id: "issue-1" }]);
+
+    expect(client.request).toHaveBeenCalledWith(BatchUpdateIssuesDocument, {
+      ids: ["issue-1", "issue-2"],
+      input: { priority: 2 },
+    });
+  });
+
+  it("throws when the transaction reports failure", async () => {
+    const client = mockGqlClient({
+      issueBatchUpdate: { success: false, issues: [] },
+    });
+
+    await expect(
+      batchUpdateIssues(client, [asUuid("issue-1")], { priority: 2 }),
+    ).rejects.toThrow("Failed to update 1 issues");
+  });
+});
+
+describe("findIssueByBranch", () => {
+  it("returns the issue owning the branch", async () => {
+    const client = mockGqlClient({
+      issueVcsBranchSearch: { id: "issue-1", identifier: "ENG-1" },
+    });
+
+    await expect(
+      findIssueByBranch(client, "fabian/eng-1-login"),
+    ).resolves.toEqual({ id: "issue-1", identifier: "ENG-1" });
+    expect(client.request).toHaveBeenCalledWith(IssueVcsBranchSearchDocument, {
+      branchName: "fabian/eng-1-login",
+    });
+  });
+
+  it("throws when the branch belongs to no issue", async () => {
+    const client = mockGqlClient({ issueVcsBranchSearch: null });
+
+    await expect(findIssueByBranch(client, "main")).rejects.toThrow(
+      'Issue for branch "main" not found',
+    );
+  });
+});
+
+describe("restoreIssue", () => {
+  it("untrashes via issueUpdate, since issueUnarchive does not cover trash", async () => {
+    const client = mockGqlClient({
+      issueUpdate: { success: true, issue: { id: "issue-1" } },
+    });
+
+    await expect(restoreIssue(client, asUuid("issue-1"))).resolves.toEqual({
+      id: "issue-1",
+    });
+    expect(client.request).toHaveBeenCalledWith(UpdateIssueDocument, {
+      id: "issue-1",
+      input: { trashed: false },
+    });
+  });
+});
+
+describe("snoozeIssue", () => {
+  it("sets the snooze instant", async () => {
+    const client = mockGqlClient({
+      issueUpdate: { success: true, issue: { id: "issue-1" } },
+    });
+
+    await snoozeIssue(client, asUuid("issue-1"), "2026-08-20T00:00:00.000Z");
+    expect(client.request).toHaveBeenCalledWith(UpdateIssueDocument, {
+      id: "issue-1",
+      input: { snoozedUntilAt: "2026-08-20T00:00:00.000Z" },
+    });
+  });
+
+  it("wakes the issue with an explicit null", async () => {
+    const client = mockGqlClient({
+      issueUpdate: { success: true, issue: { id: "issue-1" } },
+    });
+
+    await snoozeIssue(client, asUuid("issue-1"), null);
+    expect(client.request).toHaveBeenCalledWith(UpdateIssueDocument, {
+      id: "issue-1",
+      input: { snoozedUntilAt: null },
+    });
+  });
+
+  it("surfaces a failed update", async () => {
+    const client = mockGqlClient({
+      issueUpdate: { success: false, issue: null },
+    });
+
+    await expect(snoozeIssue(client, asUuid("issue-1"), null)).rejects.toThrow(
+      "Failed to update issue",
+    );
+  });
+});
diff --git a/tests/unit/services/label-service.test.ts b/tests/unit/services/label-service.test.ts
index 58bb1a99..54dd98a3 100644
--- a/tests/unit/services/label-service.test.ts
+++ b/tests/unit/services/label-service.test.ts
@@ -1,12 +1,23 @@
 import { describe, expect, it, vi } from "vitest";
 import type { GraphQLClient } from "../../../src/client/graphql-client.js";
 import { asUuid } from "../../../src/common/identifier.js";
+import {
+  CreateProjectLabelDocument,
+  DeleteProjectLabelDocument,
+  GetProjectLabelDocument,
+  RestoreProjectLabelDocument,
+  RetireIssueLabelDocument,
+  RetireProjectLabelDocument,
+  UpdateProjectLabelDocument,
+} from "../../../src/gql/graphql.js";
 import {
   createLabel,
   deleteLabel,
   getLabel,
   listLabels,
   listProjectLabels,
+  restoreLabel,
+  retireLabel,
   updateLabel,
 } from "../../../src/services/label-service.js";
 
@@ -434,3 +445,171 @@ describe("listProjectLabels", () => {
     expect(result.nodes[0]?.type).toBe("project");
   });
 });
+
+describe("project label CRUD", () => {
+  it("reads a project label and tags it as one", async () => {
+    const client = mockGqlClient({
+      projectLabel: {
+        id: "plbl-1",
+        name: "Customer",
+        color: "#0000ff",
+        isGroup: false,
+        retiredAt: null,
+        parent: { id: "plbl-0", name: "Tier" },
+      },
+    });
+
+    await expect(
+      getLabel(client, asUuid("plbl-1"), "project"),
+    ).resolves.toEqual({
+      id: "plbl-1",
+      name: "Customer",
+      color: "#0000ff",
+      type: "project",
+      isGroup: false,
+      parent: { id: "plbl-0", name: "Tier" },
+    });
+
+    expect(client.request).toHaveBeenCalledWith(GetProjectLabelDocument, {
+      id: "plbl-1",
+    });
+  });
+
+  it("throws when the project label is missing", async () => {
+    const client = mockGqlClient({ projectLabel: null });
+
+    await expect(getLabel(client, asUuid("plbl-1"), "project")).rejects.toThrow(
+      'Project label with ID "plbl-1" not found',
+    );
+  });
+
+  it("drops teamId on create because project labels have no team", async () => {
+    const client = mockGqlClient({
+      projectLabelCreate: {
+        success: true,
+        projectLabel: { id: "plbl-1", name: "Customer", color: "#0000ff" },
+      },
+    });
+
+    await createLabel(
+      client,
+      { name: "Customer", color: "#0000ff", teamId: asUuid("team-1") },
+      "project",
+    );
+
+    expect(client.request).toHaveBeenCalledWith(CreateProjectLabelDocument, {
+      input: { name: "Customer", color: "#0000ff" },
+    });
+  });
+
+  it("throws when project label creation fails", async () => {
+    const client = mockGqlClient({
+      projectLabelCreate: { success: false, projectLabel: null },
+    });
+
+    await expect(
+      createLabel(client, { name: "Customer" }, "project"),
+    ).rejects.toThrow('Failed to create project label "Customer"');
+  });
+
+  it("updates a project label", async () => {
+    const client = mockGqlClient({
+      projectLabelUpdate: {
+        success: true,
+        projectLabel: { id: "plbl-1", name: "Client", color: "#0000ff" },
+      },
+    });
+
+    await expect(
+      updateLabel(client, asUuid("plbl-1"), { name: "Client" }, "project"),
+    ).resolves.toMatchObject({ id: "plbl-1", type: "project" });
+
+    expect(client.request).toHaveBeenCalledWith(UpdateProjectLabelDocument, {
+      id: "plbl-1",
+      input: { name: "Client" },
+    });
+  });
+
+  it("deletes a project label", async () => {
+    const client = mockGqlClient({
+      projectLabelDelete: { success: true, entityId: "plbl-1" },
+    });
+
+    await expect(
+      deleteLabel(client, asUuid("plbl-1"), "project"),
+    ).resolves.toEqual({ id: "plbl-1", success: true });
+
+    expect(client.request).toHaveBeenCalledWith(DeleteProjectLabelDocument, {
+      id: "plbl-1",
+    });
+  });
+});
+
+describe("retireLabel and restoreLabel", () => {
+  it("retires an issue label by default", async () => {
+    const client = mockGqlClient({
+      issueLabelRetire: {
+        success: true,
+        issueLabel: {
+          id: "lbl-1",
+          name: "Bug",
+          color: "#ff0000",
+          retiredAt: "2026-08-10T00:00:00.000Z",
+        },
+      },
+    });
+
+    await expect(retireLabel(client, asUuid("lbl-1"))).resolves.toMatchObject({
+      type: "issue",
+      retiredAt: "2026-08-10T00:00:00.000Z",
+    });
+
+    expect(client.request).toHaveBeenCalledWith(RetireIssueLabelDocument, {
+      id: "lbl-1",
+    });
+  });
+
+  it("retires a project label when asked", async () => {
+    const client = mockGqlClient({
+      projectLabelRetire: {
+        success: true,
+        projectLabel: { id: "plbl-1", name: "Customer", color: "#0000ff" },
+      },
+    });
+
+    await expect(
+      retireLabel(client, asUuid("plbl-1"), "project"),
+    ).resolves.toMatchObject({ type: "project" });
+
+    expect(client.request).toHaveBeenCalledWith(RetireProjectLabelDocument, {
+      id: "plbl-1",
+    });
+  });
+
+  it("restores a project label", async () => {
+    const client = mockGqlClient({
+      projectLabelRestore: {
+        success: true,
+        projectLabel: { id: "plbl-1", name: "Customer", color: "#0000ff" },
+      },
+    });
+
+    await expect(
+      restoreLabel(client, asUuid("plbl-1"), "project"),
+    ).resolves.toMatchObject({ type: "project" });
+
+    expect(client.request).toHaveBeenCalledWith(RestoreProjectLabelDocument, {
+      id: "plbl-1",
+    });
+  });
+
+  it("throws when a retire is refused", async () => {
+    const client = mockGqlClient({
+      projectLabelRetire: { success: false, projectLabel: null },
+    });
+
+    await expect(
+      retireLabel(client, asUuid("plbl-1"), "project"),
+    ).rejects.toThrow('Failed to retire project label "plbl-1"');
+  });
+});
diff --git a/tests/unit/services/project-activity-service.test.ts b/tests/unit/services/project-activity-service.test.ts
new file mode 100644
index 00000000..92bea10f
--- /dev/null
+++ b/tests/unit/services/project-activity-service.test.ts
@@ -0,0 +1,200 @@
+import { describe, expect, it, vi } from "vitest";
+import type { GraphQLClient } from "../../../src/client/graphql-client.js";
+import { asUuid } from "../../../src/common/identifier.js";
+import {
+  GetProjectActivityRefDocument,
+  ListProjectActivityHistoryDocument,
+  ListProjectActivityUpdatesDocument,
+  ListProjectDiscussionReplyCandidatesDocument,
+  ListProjectDiscussionRootsDocument,
+} from "../../../src/gql/graphql.js";
+import { getProjectActivity } from "../../../src/services/project-activity-service.js";
+
+const EMPTY_PAGE = { hasNextPage: false, endCursor: null };
+
+interface Fixture {
+  roots?: unknown[];
+  replies?: unknown[];
+  history?: unknown[];
+  updates?: unknown[];
+  projectMissing?: boolean;
+}
+
+function mockGqlClient(fixture: Fixture): {
+  client: GraphQLClient;
+  request: ReturnType<typeof vi.fn>;
+} {
+  const request = vi.fn(async (document: unknown) => {
+    if (document === GetProjectActivityRefDocument) {
+      return fixture.projectMissing
+        ? { project: null }
+        : { project: { id: "proj-1", name: "Auth" } };
+    }
+
+    if (document === ListProjectDiscussionRootsDocument) {
+      return {
+        project: {
+          comments: { nodes: fixture.roots ?? [], pageInfo: EMPTY_PAGE },
+        },
+      };
+    }
+
+    if (document === ListProjectDiscussionReplyCandidatesDocument) {
+      return {
+        comments: { nodes: fixture.replies ?? [], pageInfo: EMPTY_PAGE },
+      };
+    }
+
+    if (document === ListProjectActivityHistoryDocument) {
+      return {
+        project: {
+          history: { nodes: fixture.history ?? [], pageInfo: EMPTY_PAGE },
+        },
+      };
+    }
+
+    if (document === ListProjectActivityUpdatesDocument) {
+      return {
+        projectUpdates: { nodes: fixture.updates ?? [], pageInfo: EMPTY_PAGE },
+      };
+    }
+
+    throw new Error("unexpected document");
+  });
+
+  return { client: { request } as unknown as GraphQLClient, request };
+}
+
+describe("getProjectActivity", () => {
+  it("interleaves threads, history and updates by creation time", async () => {
+    const { client } = mockGqlClient({
+      roots: [
+        { id: "cmt-1", createdAt: "2026-08-02T00:00:00.000Z", parentId: null },
+      ],
+      history: [
+        { id: "hist-1", createdAt: "2026-08-01T00:00:00.000Z", entries: {} },
+      ],
+      updates: [
+        { id: "upd-1", createdAt: "2026-08-03T00:00:00.000Z", body: "Week 1" },
+      ],
+    });
+
+    const result = await getProjectActivity(client, asUuid("proj-1"));
+
+    expect(result.project).toEqual({ id: "proj-1", name: "Auth" });
+    expect(result.activity.map((item) => item.type)).toEqual([
+      "history",
+      "commentThread",
+      "update",
+    ]);
+    expect(result.pageInfo).toEqual({
+      hasNextPage: false,
+      endCursor: "upd-1",
+    });
+  });
+
+  it("passes history entries through verbatim", async () => {
+    const entries = { nested: { anything: [1, 2, 3] } };
+    const { client } = mockGqlClient({
+      history: [
+        { id: "hist-1", createdAt: "2026-08-01T00:00:00.000Z", entries },
+      ],
+    });
+
+    const result = await getProjectActivity(client, asUuid("proj-1"));
+
+    expect(result.activity[0]).toEqual({
+      type: "history",
+      id: "hist-1",
+      createdAt: "2026-08-01T00:00:00.000Z",
+      entries,
+    });
+  });
+
+  it("nests replies under their root thread", async () => {
+    const { client } = mockGqlClient({
+      roots: [
+        { id: "cmt-1", createdAt: "2026-08-01T00:00:00.000Z", parentId: null },
+      ],
+      replies: [
+        {
+          id: "cmt-2",
+          createdAt: "2026-08-02T00:00:00.000Z",
+          parentId: "cmt-1",
+        },
+      ],
+    });
+
+    const result = await getProjectActivity(client, asUuid("proj-1"));
+
+    expect(result.activity).toHaveLength(1);
+    expect(result.activity[0]).toMatchObject({
+      type: "commentThread",
+      root: { id: "cmt-1" },
+      replies: [{ id: "cmt-2" }],
+    });
+  });
+
+  it("--comments-only skips history and updates entirely", async () => {
+    const { client, request } = mockGqlClient({
+      roots: [
+        { id: "cmt-1", createdAt: "2026-08-01T00:00:00.000Z", parentId: null },
+      ],
+      history: [
+        { id: "hist-1", createdAt: "2026-08-01T00:00:00.000Z", entries: {} },
+      ],
+      updates: [{ id: "upd-1", createdAt: "2026-08-01T00:00:00.000Z" }],
+    });
+
+    const result = await getProjectActivity(client, asUuid("proj-1"), {
+      commentsOnly: true,
+    });
+
+    expect(result.activity.map((item) => item.type)).toEqual(["commentThread"]);
+    expect(request).not.toHaveBeenCalledWith(
+      ListProjectActivityHistoryDocument,
+      expect.anything(),
+    );
+    expect(request).not.toHaveBeenCalledWith(
+      ListProjectActivityUpdatesDocument,
+      expect.anything(),
+    );
+  });
+
+  it("paginates with an opaque id cursor", async () => {
+    const { client } = mockGqlClient({
+      history: [
+        { id: "hist-1", createdAt: "2026-08-01T00:00:00.000Z", entries: {} },
+        { id: "hist-2", createdAt: "2026-08-02T00:00:00.000Z", entries: {} },
+      ],
+    });
+
+    const first = await getProjectActivity(client, asUuid("proj-1"), {
+      limit: 1,
+    });
+    expect(first.pageInfo).toEqual({ hasNextPage: true, endCursor: "hist-1" });
+
+    const second = await getProjectActivity(client, asUuid("proj-1"), {
+      limit: 1,
+      after: "hist-1",
+    });
+    expect(second.activity).toMatchObject([{ id: "hist-2" }]);
+    expect(second.pageInfo.hasNextPage).toBe(false);
+  });
+
+  it("rejects a cursor that is not in the timeline", async () => {
+    const { client } = mockGqlClient({});
+
+    await expect(
+      getProjectActivity(client, asUuid("proj-1"), { after: "nope" }),
+    ).rejects.toThrow('Activity cursor "nope" not found');
+  });
+
+  it("throws when the project does not exist", async () => {
+    const { client } = mockGqlClient({ projectMissing: true });
+
+    await expect(getProjectActivity(client, asUuid("proj-1"))).rejects.toThrow(
+      'Project with ID "proj-1" not found',
+    );
+  });
+});
diff --git a/tests/unit/services/project-relation-service.test.ts b/tests/unit/services/project-relation-service.test.ts
new file mode 100644
index 00000000..822a9d03
--- /dev/null
+++ b/tests/unit/services/project-relation-service.test.ts
@@ -0,0 +1,244 @@
+import { describe, expect, it, vi } from "vitest";
+import type { GraphQLClient } from "../../../src/client/graphql-client.js";
+import { asUuid } from "../../../src/common/identifier.js";
+import {
+  CreateProjectRelationDocument,
+  DeleteProjectRelationDocument,
+  UpdateProjectRelationDocument,
+} from "../../../src/gql/graphql.js";
+import {
+  createProjectRelation,
+  deleteProjectRelation,
+  getProjectRelation,
+  listAllProjectRelations,
+  listProjectRelations,
+  updateProjectRelation,
+} from "../../../src/services/project-relation-service.js";
+
+function mockGqlClient(response: Record<string, unknown>): GraphQLClient {
+  return {
+    request: vi.fn().mockResolvedValue(response),
+  } as unknown as GraphQLClient;
+}
+
+describe("listProjectRelations", () => {
+  it("returns both directions separately", async () => {
+    const client = mockGqlClient({
+      project: {
+        id: "proj-1",
+        name: "Auth",
+        relations: {
+          nodes: [{ id: "rel-1" }],
+          pageInfo: { hasNextPage: false },
+        },
+        inverseRelations: {
+          nodes: [{ id: "rel-2" }],
+          pageInfo: { hasNextPage: false },
+        },
+      },
+    });
+
+    await expect(
+      listProjectRelations(client, asUuid("proj-1")),
+    ).resolves.toEqual({
+      project: { id: "proj-1", name: "Auth" },
+      relations: [{ id: "rel-1" }],
+      inverseRelations: [{ id: "rel-2" }],
+      truncated: false,
+    });
+  });
+
+  it("reports truncation when either connection is cut off", async () => {
+    const client = mockGqlClient({
+      project: {
+        id: "proj-1",
+        name: "Auth",
+        relations: { nodes: [], pageInfo: { hasNextPage: false } },
+        inverseRelations: { nodes: [], pageInfo: { hasNextPage: true } },
+      },
+    });
+
+    await expect(
+      listProjectRelations(client, asUuid("proj-1")),
+    ).resolves.toMatchObject({ truncated: true });
+  });
+
+  it("throws when the project is missing", async () => {
+    const client = mockGqlClient({ project: null });
+
+    await expect(
+      listProjectRelations(client, asUuid("proj-1")),
+    ).rejects.toThrow('Project "proj-1" not found');
+  });
+});
+
+describe("createProjectRelation", () => {
+  it('always writes type "dependency", the one literal Linear uses', async () => {
+    const client = mockGqlClient({
+      projectRelationCreate: {
+        success: true,
+        projectRelation: { id: "rel-1" },
+      },
+    });
+
+    await expect(
+      createProjectRelation(client, {
+        projectId: asUuid("proj-1"),
+        relatedProjectId: asUuid("proj-2"),
+        anchorType: "end",
+        relatedAnchorType: "start",
+      }),
+    ).resolves.toEqual({ id: "rel-1" });
+
+    expect(client.request).toHaveBeenCalledWith(CreateProjectRelationDocument, {
+      input: {
+        projectId: "proj-1",
+        relatedProjectId: "proj-2",
+        anchorType: "end",
+        relatedAnchorType: "start",
+        type: "dependency",
+      },
+    });
+  });
+
+  it("passes milestone anchors through", async () => {
+    const client = mockGqlClient({
+      projectRelationCreate: {
+        success: true,
+        projectRelation: { id: "rel-1" },
+      },
+    });
+
+    await createProjectRelation(client, {
+      projectId: asUuid("proj-1"),
+      relatedProjectId: asUuid("proj-2"),
+      anchorType: "end",
+      relatedAnchorType: "start",
+      projectMilestoneId: asUuid("ms-1"),
+      relatedProjectMilestoneId: asUuid("ms-2"),
+    });
+
+    expect(client.request).toHaveBeenCalledWith(
+      CreateProjectRelationDocument,
+      expect.objectContaining({
+        input: expect.objectContaining({
+          projectMilestoneId: "ms-1",
+          relatedProjectMilestoneId: "ms-2",
+        }),
+      }),
+    );
+  });
+
+  it("names both endpoints when the mutation fails", async () => {
+    const client = mockGqlClient({
+      projectRelationCreate: { success: false, projectRelation: null },
+    });
+
+    await expect(
+      createProjectRelation(client, {
+        projectId: asUuid("proj-1"),
+        relatedProjectId: asUuid("proj-2"),
+        anchorType: "end",
+        relatedAnchorType: "start",
+      }),
+    ).rejects.toThrow('Failed to relate project "proj-1" to "proj-2"');
+  });
+});
+
+describe("updateProjectRelation", () => {
+  it("forwards a null milestone to detach the anchor", async () => {
+    const client = mockGqlClient({
+      projectRelationUpdate: {
+        success: true,
+        projectRelation: { id: "rel-1" },
+      },
+    });
+
+    await updateProjectRelation(client, asUuid("rel-1"), {
+      projectMilestoneId: null,
+      anchorType: "start",
+    });
+
+    expect(client.request).toHaveBeenCalledWith(UpdateProjectRelationDocument, {
+      id: "rel-1",
+      input: { projectMilestoneId: null, anchorType: "start" },
+    });
+  });
+
+  it("throws when the mutation reports failure", async () => {
+    const client = mockGqlClient({
+      projectRelationUpdate: { success: false, projectRelation: null },
+    });
+
+    await expect(
+      updateProjectRelation(client, asUuid("rel-1"), { anchorType: "start" }),
+    ).rejects.toThrow('Failed to update project relation "rel-1"');
+  });
+});
+
+describe("deleteProjectRelation", () => {
+  it("returns the deleted id", async () => {
+    const client = mockGqlClient({
+      projectRelationDelete: { success: true, entityId: "rel-1" },
+    });
+
+    await expect(
+      deleteProjectRelation(client, asUuid("rel-1")),
+    ).resolves.toEqual({ id: "rel-1", success: true });
+
+    expect(client.request).toHaveBeenCalledWith(DeleteProjectRelationDocument, {
+      id: "rel-1",
+    });
+  });
+
+  it("throws when the mutation reports failure", async () => {
+    const client = mockGqlClient({
+      projectRelationDelete: { success: false, entityId: null },
+    });
+
+    await expect(
+      deleteProjectRelation(client, asUuid("rel-1")),
+    ).rejects.toThrow('Failed to delete project relation "rel-1"');
+  });
+});
+
+describe("getProjectRelation", () => {
+  it("returns the relation when found", async () => {
+    const client = mockGqlClient({ projectRelation: { id: "rel-1" } });
+
+    await expect(getProjectRelation(client, asUuid("rel-1"))).resolves.toEqual({
+      id: "rel-1",
+    });
+  });
+
+  it("throws when the relation is missing", async () => {
+    const client = mockGqlClient({ projectRelation: null });
+
+    await expect(getProjectRelation(client, asUuid("rel-1"))).rejects.toThrow(
+      'Project relation "rel-1" not found',
+    );
+  });
+});
+
+describe("listAllProjectRelations", () => {
+  it("pages the unfiltered workspace connection", async () => {
+    const client = mockGqlClient({
+      projectRelations: {
+        nodes: [{ id: "rel-1" }],
+        pageInfo: { hasNextPage: false, endCursor: null },
+      },
+    });
+
+    await expect(
+      listAllProjectRelations(client, { limit: 10, after: "cursor-1" }),
+    ).resolves.toEqual({
+      nodes: [{ id: "rel-1" }],
+      pageInfo: { hasNextPage: false, endCursor: null },
+    });
+
+    expect(client.request).toHaveBeenCalledWith(expect.anything(), {
+      first: 10,
+      after: "cursor-1",
+    });
+  });
+});
diff --git a/tests/unit/services/project-service.test.ts b/tests/unit/services/project-service.test.ts
index 20a1595e..d66f369b 100644
--- a/tests/unit/services/project-service.test.ts
+++ b/tests/unit/services/project-service.test.ts
@@ -5,19 +5,20 @@ import { describe, expect, it, vi } from "vitest";
 import type { GraphQLClient } from "../../../src/client/graphql-client.js";
 import { asUuid } from "../../../src/common/identifier.js";
 import {
-  ArchiveProjectDocument,
+  AddProjectLabelDocument,
+  DisableProjectExternalSyncDocument,
   GetProjectDocument,
-  GetProjectLabelIdsDocument,
   GetProjectWithReactionsDocument,
   UpdateProjectDocument,
 } from "../../../src/gql/graphql.js";
 import {
-  archiveProject,
+  applyProjectLabels,
   createProject,
   deleteProject,
+  disableProjectExternalSync,
   getProject,
-  getProjectLabelIds,
   listProjects,
+  searchProjects,
   unarchiveProject,
   updateProject,
 } from "../../../src/services/project-service.js";
@@ -350,50 +351,6 @@ describe("getProject", () => {
   });
 });
 
-describe("getProjectLabelIds", () => {
-  it("returns the project's label UUIDs via the lean query", async () => {
-    const client = mockGqlClient({
-      project: {
-        id: "proj-1",
-        labels: {
-          nodes: [{ id: "label-1" }, { id: "label-2" }],
-          pageInfo: { hasNextPage: false },
-        },
-      },
-    });
-
-    const result = await getProjectLabelIds(client, asUuid("proj-1"));
-
-    expect(result).toEqual(["label-1", "label-2"]);
-    expect(client.request).toHaveBeenCalledWith(GetProjectLabelIdsDocument, {
-      id: "proj-1",
-    });
-  });
-
-  it("throws when project not found", async () => {
-    const client = mockGqlClient({ project: null });
-    await expect(
-      getProjectLabelIds(client, asUuid("nonexistent")),
-    ).rejects.toThrow('Project with ID "nonexistent" not found');
-  });
-
-  it("throws instead of returning a truncated label set", async () => {
-    const client = mockGqlClient({
-      project: {
-        id: "proj-1",
-        labels: {
-          nodes: [{ id: "label-1" }],
-          pageInfo: { hasNextPage: true },
-        },
-      },
-    });
-
-    await expect(getProjectLabelIds(client, asUuid("proj-1"))).rejects.toThrow(
-      "refusing to modify labels from a truncated label set",
-    );
-  });
-});
-
 describe("project fragment connection bounds", () => {
   // Linear's complexity estimator charges an unbounded connection at its
   // default page size per parent row; unbounded connections in these
@@ -449,42 +406,6 @@ describe("project fragment connection bounds", () => {
       }
     },
   );
-
-  it("bounds the lean label lookup and selects its truncation signal", () => {
-    const operation = GetProjectLabelIdsDocument.definitions.find(
-      (definition) => definition.kind === Kind.OPERATION_DEFINITION,
-    );
-    if (!operation || operation.kind !== Kind.OPERATION_DEFINITION) {
-      throw new Error("GetProjectLabelIds operation not found");
-    }
-
-    const projectField = operation.selectionSet.selections.find(
-      (selection) =>
-        selection.kind === Kind.FIELD && selection.name.value === "project",
-    );
-    if (!projectField || projectField.kind !== Kind.FIELD) {
-      throw new Error("GetProjectLabelIds does not select project");
-    }
-
-    const labelsField = projectField.selectionSet?.selections.find(
-      (selection) =>
-        selection.kind === Kind.FIELD && selection.name.value === "labels",
-    );
-    if (!labelsField || labelsField.kind !== Kind.FIELD) {
-      throw new Error("GetProjectLabelIds does not select labels");
-    }
-
-    const firstArgument = labelsField.arguments?.find(
-      (argument) => argument.name.value === "first",
-    );
-    expect(firstArgument?.value.kind).toBe(Kind.INT);
-
-    const pageInfo = labelsField.selectionSet?.selections.find(
-      (selection) =>
-        selection.kind === Kind.FIELD && selection.name.value === "pageInfo",
-    );
-    expect(pageInfo).toBeDefined();
-  });
 });
 
 describe("createProject", () => {
@@ -597,36 +518,6 @@ describe("updateProject", () => {
   });
 });
 
-describe("archiveProject", () => {
-  it("returns archived project on success", async () => {
-    const client = mockGqlClient({
-      projectArchive: {
-        success: true,
-        entity: { id: "proj-1", name: "Archived Project" },
-      },
-    });
-
-    await expect(archiveProject(client, asUuid("proj-1"))).resolves.toEqual({
-      id: "proj-1",
-      name: "Archived Project",
-    });
-
-    expect(client.request).toHaveBeenCalledWith(ArchiveProjectDocument, {
-      id: "proj-1",
-    });
-  });
-
-  it("throws on failure", async () => {
-    const client = mockGqlClient({
-      projectArchive: { success: false, entity: null },
-    });
-
-    await expect(archiveProject(client, asUuid("proj-1"))).rejects.toThrow(
-      'Failed to archive project "proj-1"',
-    );
-  });
-});
-
 describe("unarchiveProject", () => {
   it("returns unarchived project on success", async () => {
     const client = mockGqlClient({
@@ -694,3 +585,145 @@ describe("deleteProject", () => {
     );
   });
 });
+
+describe("searchProjects", () => {
+  it("forwards the term, team filter and pagination", async () => {
+    const client = mockGqlClient({
+      searchProjects: {
+        nodes: [{ id: "proj-1", name: "Auth" }],
+        pageInfo: { hasNextPage: false, endCursor: null },
+      },
+    });
+
+    await expect(
+      searchProjects(client, "auth", {
+        limit: 10,
+        after: "cursor-1",
+        includeArchived: true,
+        teamId: asUuid("team-1"),
+      }),
+    ).resolves.toEqual({
+      nodes: [{ id: "proj-1", name: "Auth" }],
+      pageInfo: { hasNextPage: false, endCursor: null },
+    });
+
+    expect(client.request).toHaveBeenCalledWith(expect.anything(), {
+      term: "auth",
+      first: 10,
+      after: "cursor-1",
+      includeArchived: true,
+      teamId: "team-1",
+    });
+  });
+
+  it("defaults to 25 results, no team, and no archived projects", async () => {
+    const client = mockGqlClient({
+      searchProjects: { nodes: [], pageInfo: { hasNextPage: false } },
+    });
+
+    await searchProjects(client, "auth");
+
+    expect(client.request).toHaveBeenCalledWith(expect.anything(), {
+      term: "auth",
+      first: 25,
+      after: undefined,
+      includeArchived: false,
+      teamId: undefined,
+    });
+  });
+});
+
+describe("disableProjectExternalSync", () => {
+  it("returns the project on success", async () => {
+    const client = mockGqlClient({
+      projectExternalSyncDisable: {
+        success: true,
+        project: { id: "proj-1", name: "Auth" },
+      },
+    });
+
+    await expect(
+      disableProjectExternalSync(client, asUuid("proj-1"), "jira"),
+    ).resolves.toEqual({ id: "proj-1", name: "Auth" });
+
+    expect(client.request).toHaveBeenCalledWith(
+      DisableProjectExternalSyncDocument,
+      { projectId: "proj-1", syncSource: "jira" },
+    );
+  });
+
+  it("names the source in the failure message", async () => {
+    const client = mockGqlClient({
+      projectExternalSyncDisable: { success: false, project: null },
+    });
+
+    await expect(
+      disableProjectExternalSync(client, asUuid("proj-1"), "github"),
+    ).rejects.toThrow('Failed to disable github sync on project "proj-1"');
+  });
+});
+
+describe("applyProjectLabels", () => {
+  it("issues one add mutation per label, in order", async () => {
+    const client = mockGqlClient({
+      projectAddLabel: { success: true, project: { id: "proj-1" } },
+    });
+
+    await expect(
+      applyProjectLabels(
+        client,
+        asUuid("proj-1"),
+        [asUuid("label-1"), asUuid("label-2")],
+        "add",
+      ),
+    ).resolves.toEqual({ id: "proj-1" });
+
+    expect(client.request).toHaveBeenCalledTimes(2);
+    expect(client.request).toHaveBeenNthCalledWith(1, AddProjectLabelDocument, {
+      id: "proj-1",
+      labelId: "label-1",
+    });
+    expect(client.request).toHaveBeenNthCalledWith(2, AddProjectLabelDocument, {
+      id: "proj-1",
+      labelId: "label-2",
+    });
+  });
+
+  it("removes through the remove mutation", async () => {
+    const client = mockGqlClient({
+      projectRemoveLabel: { success: true, project: { id: "proj-1" } },
+    });
+
+    await applyProjectLabels(
+      client,
+      asUuid("proj-1"),
+      [asUuid("label-1")],
+      "remove",
+    );
+
+    expect(client.request).toHaveBeenCalledWith(expect.anything(), {
+      id: "proj-1",
+      labelId: "label-1",
+    });
+  });
+
+  it("names the label that failed", async () => {
+    const client = mockGqlClient({
+      projectAddLabel: { success: false, project: null },
+    });
+
+    await expect(
+      applyProjectLabels(client, asUuid("proj-1"), [asUuid("label-1")], "add"),
+    ).rejects.toThrow('Failed to add label "label-1" on project "proj-1"');
+  });
+
+  it("throws rather than reporting success for an empty label list", async () => {
+    const client = mockGqlClient({});
+
+    await expect(
+      applyProjectLabels(client, asUuid("proj-1"), [], "add"),
+    ).rejects.toThrow('No labels given to add on project "proj-1"');
+
+    expect(client.request).not.toHaveBeenCalled();
+  });
+});
diff --git a/tests/unit/services/project-status-service.test.ts b/tests/unit/services/project-status-service.test.ts
new file mode 100644
index 00000000..04678ddb
--- /dev/null
+++ b/tests/unit/services/project-status-service.test.ts
@@ -0,0 +1,409 @@
+import { describe, expect, it, vi } from "vitest";
+import type { GraphQLClient } from "../../../src/client/graphql-client.js";
+import { asUuid } from "../../../src/common/identifier.js";
+import {
+  ArchiveProjectStatusDocument,
+  CreateProjectStatusDocument,
+  GetProjectStatusDocument,
+  GetProjectStatusProjectCountDocument,
+  ListProjectStatusesDocument,
+  ReassignProjectStatusDocument,
+  UnarchiveProjectStatusDocument,
+  UpdateProjectStatusDocument,
+} from "../../../src/gql/graphql.js";
+import {
+  archiveProjectStatus,
+  createProjectStatus,
+  getProjectStatus,
+  listProjectStatuses,
+  reassignProjectStatus,
+  unarchiveProjectStatus,
+  updateProjectStatus,
+} from "../../../src/services/project-status-service.js";
+
+/** Routes each document to its own canned response. */
+function mockGqlClient(responses: Map<unknown, unknown>): {
+  client: GraphQLClient;
+  request: ReturnType<typeof vi.fn>;
+} {
+  const request = vi.fn(async (document: unknown) => {
+    if (!responses.has(document)) {
+      throw new Error("unexpected document");
+    }
+    return responses.get(document);
+  });
+
+  return { client: { request } as unknown as GraphQLClient, request };
+}
+
+describe("listProjectStatuses", () => {
+  it("excludes archived statuses by default", async () => {
+    const { client, request } = mockGqlClient(
+      new Map([
+        [
+          ListProjectStatusesDocument,
+          { projectStatuses: { nodes: [], pageInfo: { hasNextPage: false } } },
+        ],
+      ]),
+    );
+
+    await expect(listProjectStatuses(client)).resolves.toEqual({
+      nodes: [],
+      truncated: false,
+    });
+    expect(request).toHaveBeenCalledWith(ListProjectStatusesDocument, {
+      includeArchived: false,
+      first: 250,
+    });
+  });
+
+  it("reports a flow that outgrew the page bound as truncated", async () => {
+    const { client } = mockGqlClient(
+      new Map([
+        [
+          ListProjectStatusesDocument,
+          {
+            projectStatuses: {
+              nodes: [{ id: "st-1" }],
+              pageInfo: { hasNextPage: true },
+            },
+          },
+        ],
+      ]),
+    );
+
+    await expect(listProjectStatuses(client, true)).resolves.toMatchObject({
+      truncated: true,
+    });
+  });
+});
+
+describe("getProjectStatus", () => {
+  it("folds the project count into the status payload", async () => {
+    const { client } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [GetProjectStatusDocument, { projectStatus: { id: "st-1" } }],
+        [
+          GetProjectStatusProjectCountDocument,
+          {
+            projectStatusProjectCount: {
+              count: 3,
+              privateCount: 1,
+              archivedTeamCount: 0,
+            },
+          },
+        ],
+      ]),
+    );
+
+    await expect(getProjectStatus(client, asUuid("st-1"))).resolves.toEqual({
+      id: "st-1",
+      projectCount: { count: 3, privateCount: 1, archivedTeamCount: 0 },
+    });
+  });
+
+  it("throws when the status is missing", async () => {
+    const { client } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [GetProjectStatusDocument, { projectStatus: null }],
+        [
+          GetProjectStatusProjectCountDocument,
+          { projectStatusProjectCount: { count: 0 } },
+        ],
+      ]),
+    );
+
+    await expect(getProjectStatus(client, asUuid("st-1"))).rejects.toThrow(
+      'Project status with ID "st-1" not found',
+    );
+  });
+});
+
+describe("createProjectStatus", () => {
+  it("appends past the highest existing position when none is given", async () => {
+    const { client, request } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [
+          ListProjectStatusesDocument,
+          {
+            projectStatuses: {
+              nodes: [{ position: 2 }, { position: 5 }],
+              pageInfo: { hasNextPage: false },
+            },
+          },
+        ],
+        [
+          CreateProjectStatusDocument,
+          { projectStatusCreate: { success: true, status: { id: "st-new" } } },
+        ],
+      ]),
+    );
+
+    await expect(
+      createProjectStatus(client, {
+        name: "Blocked",
+        type: "paused",
+        color: "#B45309",
+      }),
+    ).resolves.toEqual({ id: "st-new" });
+
+    expect(request).toHaveBeenCalledWith(CreateProjectStatusDocument, {
+      input: {
+        name: "Blocked",
+        type: "paused",
+        color: "#B45309",
+        position: 6,
+      },
+    });
+  });
+
+  it("counts archived statuses when picking the next position", async () => {
+    const { client, request } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [
+          ListProjectStatusesDocument,
+          {
+            projectStatuses: {
+              nodes: [{ position: 2 }, { position: 9 }],
+              pageInfo: { hasNextPage: false },
+            },
+          },
+        ],
+        [
+          CreateProjectStatusDocument,
+          { projectStatusCreate: { success: true, status: { id: "st-new" } } },
+        ],
+      ]),
+    );
+
+    await createProjectStatus(client, {
+      name: "Blocked",
+      type: "paused",
+      color: "#B45309",
+    });
+
+    expect(request).toHaveBeenCalledWith(ListProjectStatusesDocument, {
+      includeArchived: true,
+      first: 250,
+    });
+    expect(request).toHaveBeenCalledWith(CreateProjectStatusDocument, {
+      input: expect.objectContaining({ position: 10 }),
+    });
+  });
+
+  it("refuses to guess a position from a truncated flow", async () => {
+    const { client, request } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [
+          ListProjectStatusesDocument,
+          {
+            projectStatuses: {
+              nodes: [{ position: 2 }],
+              pageInfo: { hasNextPage: true },
+            },
+          },
+        ],
+      ]),
+    );
+
+    await expect(
+      createProjectStatus(client, {
+        name: "Blocked",
+        type: "paused",
+        color: "#B45309",
+      }),
+    ).rejects.toThrow("more than 250 project statuses");
+
+    expect(request).not.toHaveBeenCalledWith(
+      CreateProjectStatusDocument,
+      expect.anything(),
+    );
+  });
+
+  it("uses an explicit position without reading the flow", async () => {
+    const { client, request } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [
+          CreateProjectStatusDocument,
+          { projectStatusCreate: { success: true, status: { id: "st-new" } } },
+        ],
+      ]),
+    );
+
+    await createProjectStatus(client, {
+      name: "Blocked",
+      type: "paused",
+      color: "#B45309",
+      position: 1.5,
+    });
+
+    expect(request).toHaveBeenCalledTimes(1);
+    expect(request).toHaveBeenCalledWith(CreateProjectStatusDocument, {
+      input: {
+        name: "Blocked",
+        type: "paused",
+        color: "#B45309",
+        position: 1.5,
+      },
+    });
+  });
+
+  it("throws when the mutation reports failure", async () => {
+    const { client } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [
+          CreateProjectStatusDocument,
+          { projectStatusCreate: { success: false, status: null } },
+        ],
+      ]),
+    );
+
+    await expect(
+      createProjectStatus(client, {
+        name: "Blocked",
+        type: "paused",
+        color: "#B45309",
+        position: 1,
+      }),
+    ).rejects.toThrow('Failed to create project status "Blocked"');
+  });
+});
+
+describe("updateProjectStatus", () => {
+  it("forwards the patch", async () => {
+    const { client, request } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [
+          UpdateProjectStatusDocument,
+          { projectStatusUpdate: { success: true, status: { id: "st-1" } } },
+        ],
+      ]),
+    );
+
+    await expect(
+      updateProjectStatus(client, asUuid("st-1"), { indefinite: false }),
+    ).resolves.toEqual({ id: "st-1" });
+
+    expect(request).toHaveBeenCalledWith(UpdateProjectStatusDocument, {
+      id: "st-1",
+      input: { indefinite: false },
+    });
+  });
+
+  it("rejects an empty patch before calling the API", async () => {
+    const { client, request } = mockGqlClient(new Map());
+
+    await expect(
+      updateProjectStatus(client, asUuid("st-1"), {}),
+    ).rejects.toThrow("at least one update field must be provided");
+
+    expect(request).not.toHaveBeenCalled();
+  });
+});
+
+describe("reassignProjectStatus", () => {
+  it("resolves when the mutation succeeds", async () => {
+    const { client, request } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [
+          ReassignProjectStatusDocument,
+          { projectReassignStatus: { success: true } },
+        ],
+      ]),
+    );
+
+    await expect(
+      reassignProjectStatus(client, asUuid("st-1"), asUuid("st-2")),
+    ).resolves.toBeUndefined();
+
+    expect(request).toHaveBeenCalledWith(ReassignProjectStatusDocument, {
+      originalProjectStatusId: "st-1",
+      newProjectStatusId: "st-2",
+    });
+  });
+
+  it("throws when the mutation reports failure", async () => {
+    const { client } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [
+          ReassignProjectStatusDocument,
+          { projectReassignStatus: { success: false } },
+        ],
+      ]),
+    );
+
+    await expect(
+      reassignProjectStatus(client, asUuid("st-1"), asUuid("st-2")),
+    ).rejects.toThrow(
+      'Failed to reassign projects from status "st-1" to "st-2"',
+    );
+  });
+});
+
+describe("archiveProjectStatus", () => {
+  it("returns the archived status", async () => {
+    const { client } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [
+          ArchiveProjectStatusDocument,
+          { projectStatusArchive: { success: true, entity: { id: "st-1" } } },
+        ],
+      ]),
+    );
+
+    await expect(archiveProjectStatus(client, asUuid("st-1"))).resolves.toEqual(
+      { id: "st-1" },
+    );
+  });
+
+  it("throws when Linear refuses the archive", async () => {
+    const { client } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [
+          ArchiveProjectStatusDocument,
+          { projectStatusArchive: { success: false, entity: null } },
+        ],
+      ]),
+    );
+
+    await expect(archiveProjectStatus(client, asUuid("st-1"))).rejects.toThrow(
+      'Failed to archive project status "st-1"',
+    );
+  });
+});
+
+describe("unarchiveProjectStatus", () => {
+  it("returns the restored status", async () => {
+    const { client, request } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [
+          UnarchiveProjectStatusDocument,
+          { projectStatusUnarchive: { success: true, entity: { id: "st-1" } } },
+        ],
+      ]),
+    );
+
+    await expect(
+      unarchiveProjectStatus(client, asUuid("st-1")),
+    ).resolves.toEqual({ id: "st-1" });
+
+    expect(request).toHaveBeenCalledWith(UnarchiveProjectStatusDocument, {
+      id: "st-1",
+    });
+  });
+
+  it("throws when the mutation reports failure", async () => {
+    const { client } = mockGqlClient(
+      new Map<unknown, unknown>([
+        [
+          UnarchiveProjectStatusDocument,
+          { projectStatusUnarchive: { success: false, entity: null } },
+        ],
+      ]),
+    );
+
+    await expect(
+      unarchiveProjectStatus(client, asUuid("st-1")),
+    ).rejects.toThrow('Failed to unarchive project status "st-1"');
+  });
+});
diff --git a/tests/unit/services/project-update-service.test.ts b/tests/unit/services/project-update-service.test.ts
new file mode 100644
index 00000000..11a7c0eb
--- /dev/null
+++ b/tests/unit/services/project-update-service.test.ts
@@ -0,0 +1,247 @@
+import { describe, expect, it, vi } from "vitest";
+import type { GraphQLClient } from "../../../src/client/graphql-client.js";
+import { asUuid } from "../../../src/common/identifier.js";
+import {
+  ArchiveProjectUpdateDocument,
+  CreateProjectUpdateDocument,
+  CreateProjectUpdateReminderDocument,
+  EditProjectUpdateDocument,
+  GetProjectUpdateDocument,
+  ListProjectUpdatesDocument,
+  UnarchiveProjectUpdateDocument,
+} from "../../../src/gql/graphql.js";
+import {
+  archiveProjectUpdate,
+  createProjectUpdate,
+  editProjectUpdate,
+  getProjectUpdate,
+  listProjectUpdates,
+  remindProjectUpdate,
+  unarchiveProjectUpdate,
+} from "../../../src/services/project-update-service.js";
+
+function mockGqlClient(response: Record<string, unknown>): {
+  client: GraphQLClient;
+  request: ReturnType<typeof vi.fn>;
+} {
+  const request = vi.fn().mockResolvedValue(response);
+  return {
+    client: { request } as unknown as GraphQLClient,
+    request,
+  };
+}
+
+describe("listProjectUpdates", () => {
+  it("forwards the project filter and pagination", async () => {
+    const { client, request } = mockGqlClient({
+      projectUpdates: {
+        nodes: [{ id: "upd-1", body: "Week 1" }],
+        pageInfo: { hasNextPage: false, endCursor: null },
+      },
+    });
+
+    await expect(
+      listProjectUpdates(client, {
+        projectId: asUuid("proj-1"),
+        limit: 5,
+        after: "cursor-1",
+        includeArchived: true,
+      }),
+    ).resolves.toEqual({
+      nodes: [{ id: "upd-1", body: "Week 1" }],
+      pageInfo: { hasNextPage: false, endCursor: null },
+    });
+
+    expect(request).toHaveBeenCalledWith(ListProjectUpdatesDocument, {
+      projectId: "proj-1",
+      first: 5,
+      after: "cursor-1",
+      includeArchived: true,
+    });
+  });
+
+  it("defaults to 50 results and excludes archived updates", async () => {
+    const { client, request } = mockGqlClient({
+      projectUpdates: { nodes: [], pageInfo: { hasNextPage: false } },
+    });
+
+    await listProjectUpdates(client, { projectId: asUuid("proj-1") });
+
+    expect(request).toHaveBeenCalledWith(ListProjectUpdatesDocument, {
+      projectId: "proj-1",
+      first: 50,
+      after: undefined,
+      includeArchived: false,
+    });
+  });
+});
+
+describe("getProjectUpdate", () => {
+  it("returns the update when found", async () => {
+    const update = { id: "upd-1", body: "Week 1", health: "onTrack" };
+    const { client, request } = mockGqlClient({ projectUpdate: update });
+
+    await expect(getProjectUpdate(client, asUuid("upd-1"))).resolves.toEqual(
+      update,
+    );
+    expect(request).toHaveBeenCalledWith(GetProjectUpdateDocument, {
+      id: "upd-1",
+    });
+  });
+
+  it("throws when the update is missing", async () => {
+    const { client } = mockGqlClient({ projectUpdate: null });
+
+    await expect(getProjectUpdate(client, asUuid("upd-1"))).rejects.toThrow(
+      'Project update with ID "upd-1" not found',
+    );
+  });
+});
+
+describe("createProjectUpdate", () => {
+  it("returns the created update", async () => {
+    const { client, request } = mockGqlClient({
+      projectUpdateCreate: {
+        success: true,
+        projectUpdate: { id: "upd-1", body: "Week 1" },
+      },
+    });
+
+    await expect(
+      createProjectUpdate(client, {
+        projectId: asUuid("proj-1"),
+        body: "Week 1",
+        health: "atRisk",
+        isDiffHidden: true,
+      }),
+    ).resolves.toEqual({ id: "upd-1", body: "Week 1" });
+
+    expect(request).toHaveBeenCalledWith(CreateProjectUpdateDocument, {
+      input: {
+        projectId: "proj-1",
+        body: "Week 1",
+        health: "atRisk",
+        isDiffHidden: true,
+      },
+    });
+  });
+
+  it("throws when the mutation reports failure", async () => {
+    const { client } = mockGqlClient({
+      projectUpdateCreate: { success: false, projectUpdate: null },
+    });
+
+    await expect(
+      createProjectUpdate(client, { projectId: asUuid("proj-1") }),
+    ).rejects.toThrow("Failed to create project update");
+  });
+});
+
+describe("editProjectUpdate", () => {
+  it("returns the edited update", async () => {
+    const { client, request } = mockGqlClient({
+      projectUpdateUpdate: {
+        success: true,
+        projectUpdate: { id: "upd-1", body: "Revised" },
+      },
+    });
+
+    await expect(
+      editProjectUpdate(client, asUuid("upd-1"), { body: "Revised" }),
+    ).resolves.toEqual({ id: "upd-1", body: "Revised" });
+
+    expect(request).toHaveBeenCalledWith(EditProjectUpdateDocument, {
+      id: "upd-1",
+      input: { body: "Revised" },
+    });
+  });
+
+  it("rejects an empty patch before calling the API", async () => {
+    const { client, request } = mockGqlClient({});
+
+    await expect(
+      editProjectUpdate(client, asUuid("upd-1"), {}),
+    ).rejects.toThrow("at least one update field must be provided");
+
+    expect(request).not.toHaveBeenCalled();
+  });
+});
+
+describe("archiveProjectUpdate", () => {
+  it("returns the archived update", async () => {
+    const { client, request } = mockGqlClient({
+      projectUpdateArchive: { success: true, entity: { id: "upd-1" } },
+    });
+
+    await expect(
+      archiveProjectUpdate(client, asUuid("upd-1")),
+    ).resolves.toEqual({ id: "upd-1" });
+
+    expect(request).toHaveBeenCalledWith(ArchiveProjectUpdateDocument, {
+      id: "upd-1",
+    });
+  });
+
+  it("throws when the mutation reports failure", async () => {
+    const { client } = mockGqlClient({
+      projectUpdateArchive: { success: false, entity: null },
+    });
+
+    await expect(archiveProjectUpdate(client, asUuid("upd-1"))).rejects.toThrow(
+      'Failed to archive project update "upd-1"',
+    );
+  });
+});
+
+describe("unarchiveProjectUpdate", () => {
+  it("returns the restored update", async () => {
+    const { client, request } = mockGqlClient({
+      projectUpdateUnarchive: { success: true, entity: { id: "upd-1" } },
+    });
+
+    await expect(
+      unarchiveProjectUpdate(client, asUuid("upd-1")),
+    ).resolves.toEqual({ id: "upd-1" });
+
+    expect(request).toHaveBeenCalledWith(UnarchiveProjectUpdateDocument, {
+      id: "upd-1",
+    });
+  });
+
+  it("throws when the mutation reports failure", async () => {
+    const { client } = mockGqlClient({
+      projectUpdateUnarchive: { success: false, entity: null },
+    });
+
+    await expect(
+      unarchiveProjectUpdate(client, asUuid("upd-1")),
+    ).rejects.toThrow('Failed to unarchive project update "upd-1"');
+  });
+});
+
+describe("remindProjectUpdate", () => {
+  it("echoes the project because the payload carries no entity", async () => {
+    const { client, request } = mockGqlClient({
+      createProjectUpdateReminder: { success: true },
+    });
+
+    await expect(
+      remindProjectUpdate(client, asUuid("proj-1"), asUuid("user-1")),
+    ).resolves.toEqual({ projectId: "proj-1", success: true });
+
+    expect(request).toHaveBeenCalledWith(CreateProjectUpdateReminderDocument, {
+      projectId: "proj-1",
+      userId: "user-1",
+    });
+  });
+
+  it("throws when the mutation reports failure", async () => {
+    const { client } = mockGqlClient({
+      createProjectUpdateReminder: { success: false },
+    });
+
+    await expect(remindProjectUpdate(client, asUuid("proj-1"))).rejects.toThrow(
+      'Failed to create an update reminder for project "proj-1"',
+    );
+  });
+});