fix(session-flow,discipline): drop the per-session subagent cap that no longer exists, and record the doc-currency audit

plugins/discipline/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "discipline",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Discipline correctors that re-anchor a standing rule mid-session, then audit both the work in flight and the pre-existing state and choices it trusts, and correct what has drifted: do-your-research (research and no-assumptions discipline; sibling do-your-research-deep escalates to a typed full inventory of the session's claims — assumptions, asserted facts, concrete specifics, load-bearing premises — verified at a configurable depth and reported as a per-item ledger), follow-our-standards (alignment to the consuming org's engineering conventions), point-dont-copy (pointer-over-copy discipline \u2014 no copied content, internal-name coupling, or closed capability lists), reason-dont-recite (interrogate inherited content \u2014 precedent is evidence of what is, never self-justifying authority), tighten-your-output (terseness discipline \u2014 fewer words or lines with no loss of meaning or correctness), recheck-against-upstream (existing state is not evidence of its own correctness \u2014 audit config, code, and infra against current official upstream docs; sibling recheck-against-upstream-deep fans subagents doc-by-doc over a whole subsystem), pick-for-the-problem (tool, library, framework, and approach selection fitted to the problem, not reached for out of habit, availability, incumbency, or preconception), mind-your-maxims (cooperative-communication discipline per Grice plus the AI-augmented transparency maxim), script-the-deterministic-work (offload deterministic sub-work \u2014 counts, diffs, sorts, transforms, and scaffolds \u2014 to a script that runs, reserving model output for judgment over its real output; the audit runs both ways, also catching an existing script that over-reaches into judgement), use-your-skills (actually use the skills already in context \u2014 scan the listing, map the task, invoke the fitting skill instead of reinventing it, and name skills when delegating to a subagent), and reuse-or-replace (anti-fragmentation \u2014 new work reuses an established way of doing something or openly replaces it (migrate the old uses, record the decision), never silently stands up a second parallel way; divergence is allowed but owes a recorded reason proportional to blast radius), and scrutinize-dont-coast (adversarial self-scrutiny \u2014 stop coasting on your own recent output and re-examine whether it is sound, not merely confidently produced, through a fresh-context pass blind to the reasoning that made it, then remediate with the user; it stops the trajectory first and remediates collaboratively rather than autonomously). Plus two declared further species that are not correctors: sweep-all, a posture-batch runbook that composes them — it fans out an audit-only subagent per in-scope corrector, then applies the corrections on the main thread in a fixed order, with batch membership and order set by each corrector's own colocated tier metadata and an optional userConfig overlay — and wait-what, a one-shot user-invoked-only communication repair: type /discipline:wait-what when the last message did not land and the model re-pitches it, backing up as far as needed, adding the missing context, in ASD-STE100 Simplified Technical English, using the project's ubiquitous language; never model-invoked and never in the batch. Firing a corrector is a re-anchor, not an accusation; the audit may return clean.",
   "author": {
     "name": "Melodic Software",

plugins/discipline/CHANGELOG.md

@@ -5,6 +5,30 @@ All notable changes to the `discipline` plugin are documented here. Format follo
 
 Entries below `0.9.0` were released under the plugin's former name, `re-anchor`.
 
+## [0.12.1]
+
+### Fixed
+
+- **`sweep-all` no longer counts dispatches against a per-session cap that was removed.** Its
+  budget reasoning had every Agent-tool subagent counting against both
+  `CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS` (default 20, still current) and
+  `CLAUDE_CODE_MAX_SUBAGENTS_PER_SESSION` (documented default 200). The second was removed in
+  v2.1.220–v2.1.224 ([2026-w32](https://code.claude.com/docs/en/whats-new/2026-w32), verified
+  2026-08-10) and is gone from the sub-agents page along with its variable. The concurrency limit —
+  the one the paragraph calls "the hard one" — is unchanged, so the dispatch conclusion stands; only
+  the second constraint has since been removed. It was accurate when written (documented default
+  200, v2.1.212+) and went stale under the platform, which is the failure mode a dated verification
+  stamp exists to make findable.
+- **The `env-vars` citation is restored, and one variable is now marked as unverified.** Re-sourcing
+  the cap removal had swapped that link out, which left the paragraph's *first* claim —
+  `CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY`, documented default 10 — with no source at all. The link is
+  back alongside the new one. That variable itself could **not** be re-verified: two `env-vars`
+  fetches truncated before its alphabetical range, and the sub-agents page names only the concurrency
+  and depth limits. That is not evidence of removal — the same truncated fetch returned ABSENT for
+  `CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS`, which is quoted verbatim elsewhere — so the claim is marked
+  in place as carried forward from the 2026-07-29 read and not re-verified, with its currency tracked
+  as an open item rather than left looking fresh.
+
 ## [0.12.0]
 
 ### Removed

plugins/discipline/skills/sweep-all/SKILL.md

@@ -226,10 +226,17 @@ unchanged and bind every member.
    default 20): past it, "spawning another with the Agent tool fails with
    `Concurrent subagent limit reached`, and the error tells Claude not to
    retry." Every Agent-tool subagent counts against it, forks included, shared
-   with everything else the session is running, and against
-   `CLAUDE_CODE_MAX_SUBAGENTS_PER_SESSION` (documented default 200)
+   with everything else the session is running. There is no longer a per-session
+   total to count against: the 200-subagent-per-session cap and its
+   `CLAUDE_CODE_MAX_SUBAGENTS_PER_SESSION` variable were removed in
+   v2.1.220–v2.1.224, leaving the concurrency and depth limits
    (<https://code.claude.com/docs/en/sub-agents>,
-   <https://code.claude.com/docs/en/env-vars>). So even a fully-admitted set —
+   <https://code.claude.com/docs/en/env-vars>,
+   <https://code.claude.com/docs/en/whats-new/2026-w32>; cap removal verified
+   2026-08-10, `CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY` above carried forward from
+   the 2026-07-29 read and NOT re-verified — the env-vars page truncated before
+   that range on re-fetch, so its currency is open, tracked as its own item).
+   So even a fully-admitted set —
    every core plus every situational corrector — dispatches in one wave in an
    otherwise-quiet session.
 

plugins/session-flow/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "session-flow",
-  "version": "0.22.1",
+  "version": "0.22.2",
   "description": "Session-lifecycle toolkit of thirteen skills: workflow (navigate a staged dev workflow and suggest the next stage), handoff (write a save-point and resume prompt for /clear-and-resume), continue-in-background (delegate the task to a fresh background agent that continues it now — same save-point engine as handoff, delivered by launching a detached claude --bg session seeded with the resume prompt; launches only on explicit user request), keep-going (recover and continue after any interruption OR when live off-thread work looks stalled — inventory off-thread work, inspect its real output, act only on evidence, then continue; after a usage limit lifts it continues rather than summarizing-and-stalling), find-handoff (recover a lost handoff after /clear — when the resume prompt was written but never copied — via a read-only detection ladder: known-location glob of the handoffs dir, then a bounded, recency-ranked transcript scan for the handoff directive and dashed-rail markers, then a confirm-before-resume gate; surfaces only the resume prompt + metadata, never raw transcript content), clean-stop (get to a durable, linked stopping point before the machine may go away — sweep every repo/worktree for uncommitted, unpushed, or PR-less work, push it durable, put breadcrumbs in PR/issue bodies, then give a free-and-clear verdict), retro (structured end-of-session retrospective with transcript metrics and learning codification), running-retro (in-flight retrospective checkpoints that spawn a subagent to analyze the transcript so far and append classified findings to a cumulative running ledger — capture and route only, the live counterpart to retro; also owns a detached-observer substrate that can watch a session out-of-band and run the checkpoint autonomously after the session ends), orient (read-only session orientation — synthesize where we stand, what we are doing, and why, from durable + off-thread state the built-in /recap never sees: ledgers, handoffs, workflow checklists, running-retro ledgers, open PRs and work-items, and git), orchestrate (arm a session or worker with proactive-orchestration imperatives), reanchor (verify a session's working assumptions are still true against live reality — referenced PRs/issues/branches, base-branch drift, renamed/version-drifted surfaces, stale memory-tier files, and the goal a handoff records, compared across the chain so a re-derived goal reports as drift — before building on them), reconcile (retire finished off-thread work and reconcile this session's task ledger with reality — the prune-and-reconcile counterpart to keep-going's resume: inventory the work this session spawned, inspect its real state, retire the finished and close proven-done tasks, auto-settling the finished and gating any kill of still-running work; sibling sessions in the project are reported read-only), and setup (check-centric verification of the observer's runtime prerequisites and configuration).",
   "author": {
     "name": "Melodic Software",

plugins/session-flow/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog — session-flow plugin
 
+## [0.22.2]
+
+### Fixed
+
+- **`orchestrate` no longer records a per-session subagent cap that no longer exists.** The sources
+  file and the SKILL both carried "at most 200 subagents per session"
+  (`CLAUDE_CODE_MAX_SUBAGENTS_PER_SESSION`, v2.1.212+), read from the sub-agents page on 2026-07-29.
+  That cap was removed in v2.1.220–v2.1.224 — "The 200-subagent-per-session cap is removed, so
+  long-running sessions no longer refuse new subagents; the concurrency and depth limits still
+  apply" ([2026-w32](https://code.claude.com/docs/en/whats-new/2026-w32)) — and both the cap and its
+  variable are gone from the reference page. A long-running orchestration planned around a session
+  total was budgeting against a ceiling that is not there.
+- The concurrency limit gains two riders recorded on the same re-read (verified 2026-08-10): sessions
+  with `ultracode` active are exempt from it, and an in-session `/subtask` fork takes a slot while it
+  runs but is never blocked by the limit.
+- The superseded claim is kept in `sources.md` as an explicit **Superseded** note rather than
+  deleted, so a reader who remembers the old cap finds out what replaced it instead of finding
+  silence.
+
 ## [0.22.1]
 
 ### Fixed

plugins/session-flow/skills/orchestrate/SKILL.md

@@ -151,10 +151,13 @@ sources — provenance is the field that makes a wrong-target answer detectable
 **Never author a tree that needs a specific depth.** The platform ceiling is configurable and has
 moved repeatedly — a fixed five layers (v2.1.172), then nesting off by default (v2.1.217), then a
 configurable default of three (v2.1.219), all inside seven weeks
-([changelog](https://code.claude.com/docs/en/changelog)). Depth, per-session spawn count, and
-concurrent-worker count are each separately capped and separately overridable
-(`CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH`, `CLAUDE_CODE_MAX_SUBAGENTS_PER_SESSION`,
-`CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS`); read the current values rather than assuming them, and
+([changelog](https://code.claude.com/docs/en/changelog)). A **different** cap disappeared entirely
+after that list was written — the per-session spawn total, removed in v2.1.220–v2.1.224
+([2026-w32](https://code.claude.com/docs/en/whats-new/2026-w32), verified 2026-08-10). The depth
+ceiling itself is still where v2.1.219 left it; what the removal changes is how many caps there are.
+Two remain, each separately capped and separately overridable
+(`CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH`, `CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS`). Read the current
+values rather than assuming them, and
 design the tree so it degrades to a shallower one instead of failing. One shape constraint that is
 not a tunable: a fork inherits its parent's conversation but cannot spawn a further fork, so a fork
 is a leaf, never an intermediate tier.

plugins/session-flow/skills/orchestrate/context/sources.md

@@ -112,13 +112,23 @@ which way it broke.
   of its own while the depth limit allows it, but any type list inside the parentheses is ignored."
   To stop one spawning while nesting is on, "omit `Agent` from its `tools` list or add it to
   `disallowedTools`."
-- Three separate caps, each with its own variable *(verbatim, verified 2026-07-29 — sub-agents
-  page)*: "this one caps the total spawned over a session, the concurrent subagent limit stops
-  Claude from spawning more while too many are running, and the depth limit caps how deeply
-  subagents nest." Defaults: "at most 200 subagents per session"
-  (`CLAUDE_CODE_MAX_SUBAGENTS_PER_SESSION`, v2.1.212+) and "when 20 subagents are running in a
-  session, spawning another with the Agent tool fails with `Concurrent subagent limit reached`"
-  (`CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS`, v2.1.217+). "A fork can't spawn further forks."
+- **Two caps now, not three — the per-session total was removed** *(verified 2026-08-10 — sub-agents
+  page)*. What remains is the concurrency limit and the depth limit: "By default, when 20 subagents
+  are running in a session, spawning another with the Agent tool fails with `Concurrent subagent
+  limit reached`, and the error tells Claude not to retry. Spawning succeeds again when the running
+  count drops below the limit" (`CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS`, v2.1.217+), plus the depth
+  limit above. "A fork can't spawn further forks."
+  Two riders on the concurrency limit, both new since the 2026-07-29 read: "Sessions with
+  [ultracode](https://code.claude.com/docs/en/model-config#adjust-effort-level) active are exempt:
+  the limit isn't enforced there", and an in-session `/subtask` fork "takes a slot while it runs and
+  is never blocked by the limit."
+  **Superseded:** this entry previously recorded a third cap — "at most 200 subagents per session"
+  via `CLAUDE_CODE_MAX_SUBAGENTS_PER_SESSION` (v2.1.212+), read 2026-07-29. Week 32 removed it:
+  "The 200-subagent-per-session cap is removed, so long-running sessions no longer refuse new
+  subagents; the concurrency and depth limits still apply"
+  ([2026-w32](https://code.claude.com/docs/en/whats-new/2026-w32), v2.1.220–v2.1.224). The variable
+  and the cap are both gone from the sub-agents page; a long-running orchestration should no longer
+  be planned around a session total.
 - **A permission gate can deny a spawn before depth is ever consulted.** Changelog v2.1.178
   *(verbatim, verified 2026-07-29)*: "Improved auto mode: subagent spawns are now evaluated by the
   classifier before launch, closing a gap where a subagent could request a blocked action without