opencode-thrum-pro 0.1.5 → 0.1.7

package/assets/skills/implementer-maintaining-memory/SKILL.md

@@ -40,7 +40,7 @@ thrum memory create --kind agent_rule --scope role \
 ```
 
 `--short`/`--full` carry real prose — compose via heredoc or file, never
-double-quoted inline; see your role preamble's 🔴 PROSE INTO A COMMAND rule.
+double-quoted inline; see the heredoc-or-file rule in your role preamble.
 
 Body shape is uniform across all role-rule writes — see
 `memory-write-discipline`. The `Why:` line is load-bearing: future-you needs the
@@ -48,9 +48,8 @@ reason to judge edge cases the rule doesn't literally cover.
 
 ## Implementer does NOT write
 
-- **Refactoring opportunities discovered mid-task** → file under the project's
-  refactoring epic, e.g. `<refactor-epic-id>`, NOT memory. Memory is for AGENT
-  BEHAVIOR rules; bd tracks code work.
+- **Refactoring opportunities discovered mid-task** → report them to the
+  coordinator, NOT memory and not bd. Memory is for AGENT BEHAVIOR rules.
 - **Research findings about the codebase** → ping the researcher; they own
   `kind: research_note` writes.
 - **Per-task notes / scratch state** → use the conversation context or task

package/assets/skills/implementer-orchestrating-execution/SKILL.md

@@ -6,7 +6,7 @@ description: "Use when starting execution of a scoped implementation task — ab
 # Implementer: Orchestrating Execution
 
 You implement by **orchestrating sub-agents**, not by doing research, edits, and
-verification yourself. Your Opus context is for judgment — synthesizing
+verification yourself. Your own context is for judgment — synthesizing
 research, targeting edits, judging verification against the plan. The legwork
 goes to cheaper sub-agents. This skill is the procedure; invoke it at the start
 of executing any scoped task.
@@ -27,10 +27,7 @@ The size bound (~15 lines / 2 files) is the project default; a project-local
 
 ## Subagent model selection
 
-> **Model tiers:** pass an explicit `model:` on every dispatch — `sonnet`
-> (low effort) mechanical, `sonnet` (medium effort) judgment, Opus only on
-> operator-ask or a skill step that names it. See the
-> `choosing-subagent-models` skill for the full policy.
+> **Model tiers:** pass an explicit `model:` on every dispatch; choose model and effort per the `choosing-subagent-models` skill (read `runtime.role_models` at the moment of use). Never let a sub-agent inherit your own model.
 
 ## Step 1 — Dispatch research
 
@@ -44,13 +41,13 @@ you do not read the code into your own context. Label the dispatch
 From the report, decide exactly what changes where, then dispatch
 general-purpose sub-agent(s) to make the edits. Give each the bd task ID, the
 exact files, the acceptance criteria, and the relevant slice of the report.
-Model: `sonnet`; use `sonnet` (low effort) for purely mechanical edits
+Model: per `choosing-subagent-models`; use the cheapest tier for purely mechanical edits
 (find/replace, rename). Label `description="implement: <what>"`. Parallelize independent
 edit-targets; serialize edits to shared files.
 
 ## Step 3 — Dispatch verification
 
-Spawn a `sonnet` verifier against **the plan the implementation sub-agent was
+Spawn a verifier sub-agent (model per `choosing-subagent-models`) against **the plan the implementation sub-agent was
 given** — does the diff satisfy the acceptance criteria and honor the plan?
 Label `description="verify: <what>"`. (For the full code-quality +
 spec-compliance review at DONE, `implementer-tdd-and-quality` and the
@@ -89,12 +86,12 @@ hard size bound.
 
 | Dispatch           | Model                                              |
 | ------------------ | -------------------------------------------------- |
-| research / explore | `sonnet` (or the `Explore` agent type)             |
-| implementation     | `sonnet`; `sonnet` (low effort) for purely mechanical edits |
-| verification       | `sonnet`                                           |
+| research / explore | per `choosing-subagent-models` (or the `Explore` agent type) |
+| implementation     | per `choosing-subagent-models`; cheapest tier for purely mechanical edits |
+| verification       | per `choosing-subagent-models`                     |
 
-Use the bare `sonnet` alias (resolves to the current Sonnet); do not hard-pin a
-version id. Never let a sub-agent inherit the parent (Opus) model.
+Use the bare alias from `runtime.role_models`; do not hard-pin a version id.
+Never let a sub-agent inherit the parent model.
 
 ## Sub-agent label convention (required)
 
@@ -105,8 +102,8 @@ delegation shape from these labels.
 ## Anti-patterns
 
 ❌ **Inline Worker** — does the research and edits itself instead of
-dispatching. Your Opus context is for orchestration judgment, not hand-typing
-edits a Sonnet sub-agent should make.
+dispatching. Your own context is for orchestration judgment, not hand-typing
+edits a sub-agent should make.
 
 ❌ **Over-orchestrator** — dispatches a sub-agent for a known one-line change,
 paying more in prompt-composition than the edit costs. The Step-0 scoping gate
@@ -117,8 +114,7 @@ prefix, blinding the evaluation harness.
 
 ## Project-specific rules (already loaded)
 
-Read the shared partial at the absolute path:
-`claude-plugin/commands/_project-rules-protocol.md`
+Load the /thrum:project-rules-protocol skill and follow it.
 
 Capture new rules mid-session via the `implementer-maintaining-memory` skill —
 it references the `memory-write-discipline` common for the canonical

package/assets/skills/implementer-receiving-dispatch/SKILL.md

@@ -38,7 +38,7 @@ config loading, string sanitization, validation), run a targeted grep.
 something similar exists, use it. If it needs extension, extend it. Only create
 a new function when nothing exists.
 
-## Don't refactor for free — log opportunities, don't implement them
+## Don't refactor for free — report opportunities, don't implement them
 
 **Why:** A bug fix doesn't need surrounding cleanup. A one-shot operation
 doesn't need a helper. Inlining "improvements" into a scoped task expands the
@@ -46,26 +46,25 @@ diff, complicates review, and risks introducing bugs unrelated to the work.
 Three similar lines is better than a premature abstraction.
 
 **How to apply:** When you spot duplicated patterns, hardcoded values that
-should be shared, or missed abstractions during implementation, log them to the
-project's refactor backlog (a beads epic, e.g. `<refactor-epic-id>`):
+should be shared, or missed abstractions during implementation, report them to
+the coordinator; do not file a bd issue yourself.
 
-`--description` is multi-line prose — never double-quoted inline. On
-`scripts/bd-shared`, `--stdin`/`--body-file` are refused (remote-path
-resolution + silent-empty-body hazards), so write it to a scratch file and
-pass `-d "$(cat <file>)"`; see your role preamble's 🔴 PROSE INTO A COMMAND
-rule.
+The report body is multi-line prose — never double-quoted inline; see the
+heredoc-or-file rule in your role preamble.
 
 ```bash
-cat > /tmp/refactor-task-desc.md <<'EOF'
-**Discovered during:** <task-id>
-**Files:** <paths>
-**Opportunity:** <what could be improved>
-**Effort:** small/medium/large
+thrum send --to @<coordinator> --stdin <<'EOF'
+Refactoring opportunity (discovered during <task-id>)
+Files: <paths>
+Opportunity: <what could be improved>
+Effort: small/medium/large
 EOF
-bd create --title="Refactor: <short description>" --type=task \
-  --parent=<refactor-epic-id> --priority=3 -d "$(cat /tmp/refactor-task-desc.md)"
 ```
 
+If the coordinator asks you to file the bead, write the description to a scratch
+file and pass `--body-file <file>` to `scripts/bd-shared` (and
+`comments add <id> -f <file>` for comments).
+
 Then continue with the assigned work. Do not implement the refactoring.
 
 ## Flag scope deviations immediately — not in the final report
@@ -96,8 +95,7 @@ related files.
 
 ## Project-specific rules (already loaded)
 
-Read the shared partial at the absolute path:
-`claude-plugin/commands/_project-rules-protocol.md`
+Load the /thrum:project-rules-protocol skill and follow it.
 
 If you accumulate a new rule mid-session (the user corrects you), capture it via
 the `implementer-maintaining-memory` skill — it references the

package/assets/skills/implementer-receiving-review-feedback/SKILL.md

@@ -71,8 +71,8 @@ trade-off explicitly:
 - Is the fix a few lines? Default to fix-now
 - Does verification require running the same tests as the main fix? Default to
   fix-now
-- Is the fix a meaningful refactor or design change? Defer is legitimate; file
-  the bd issue and link it in the commit message
+- Is the fix a meaningful refactor or design change? Defer is legitimate; report
+  it to the coordinator (not a bd issue) and cite the report in the commit message
 
 Don't reach for "deferred" as a shortcut to ship faster.
 
@@ -117,8 +117,7 @@ list, file them as bd issues — don't slip them into the fix commit.
 
 ## Project-specific rules (already loaded)
 
-Read the shared partial at the absolute path:
-`claude-plugin/commands/_project-rules-protocol.md`
+Load the /thrum:project-rules-protocol skill and follow it.
 
 If you accumulate a new rule mid-session (the user corrects you), capture it via
 the `implementer-maintaining-memory` skill — it references the

package/assets/skills/implementer-status-and-handoff/SKILL.md

@@ -107,22 +107,9 @@ make test PASS (race), make lint PASS.
 
 For first-pass DONE (not review-fix), cite the closing SHA and the test result.
 
-## Close beads tasks with `--suggest-next` when relevant
-
-**Why:** `bd close <id>` works fine, but `bd close <id> --suggest-next` prints
-newly-unblocked downstream issues immediately. If you're in the middle of an
-epic, the next task is often the most useful next move; the flag saves a
-`bd ready` round-trip.
-
-**How to apply:** When closing a task that has dependents, use
-`bd close <id> --suggest-next`. For the last task in an epic where you're
-stopping at a review gate, plain `bd close` is fine — you're not picking up the
-next task anyway.
-
 ## Project-specific rules (already loaded)
 
-Read the shared partial at the absolute path:
-`claude-plugin/commands/_project-rules-protocol.md`
+Load the /thrum:project-rules-protocol skill and follow it.
 
 If you accumulate a new rule mid-session (the user corrects you), capture it via
 the `implementer-maintaining-memory` skill — it references the

package/assets/skills/implementer-tdd-and-quality/SKILL.md

@@ -86,13 +86,13 @@ that would otherwise come back as findings.
    package searched -> primitive adopted, or none exists + bounded cost formula
    (frequency x production cardinality, at production scale). Include it in
    your DONE report.
+   - Before writing a raw read-in-loop, `db.Query`-in-loop, `COUNT(DISTINCT ...)`, or a second transaction or pool acquisition per logical unit under a hot root, search the callee package for an existing targeted, cached, covering or batch primitive.
 
 Fix what you find before sending the ping.
 
 ## Project-specific rules (already loaded)
 
-Read the shared partial at the absolute path:
-`claude-plugin/commands/_project-rules-protocol.md`
+Load the /thrum:project-rules-protocol skill and follow it.
 
 If you accumulate a new rule mid-session (the user corrects you), capture it via
 the `implementer-maintaining-memory` skill — it references the

package/assets/skills/memory-curate/SKILL.md

@@ -108,7 +108,7 @@ thrum memory create --kind comment \
 ```
 
 `--short`/`--full` carry real prose — compose via heredoc or file, never
-double-quoted inline; see your role preamble's 🔴 PROSE INTO A COMMAND rule.
+double-quoted inline; see the heredoc-or-file rule in your role preamble.
 
 `--parent` shorthand creates the `child_of` edge in the same operation. Author =
 `agent_id`, timestamp = `created_at`. Threading walks via the daemon's

package/assets/skills/memory-write-discipline/SKILL.md

@@ -25,7 +25,7 @@ thrum memory create --kind <K> --scope <S> \
 ```
 
 `--short`/`--full` carry real prose — compose via heredoc or file, never
-double-quoted inline; see the role preamble's 🔴 PROSE INTO A COMMAND rule.
+double-quoted inline; see the heredoc-or-file rule in your role preamble.
 
 Three flags are **REQUIRED** (schema NOT NULL): `--kind`, `--title`,
 `--oneline`. The daemon rejects any `memory.create` call missing these.

package/assets/skills/orchestrate/SKILL.md

@@ -53,8 +53,11 @@ grep "## Review Gate:" <prompt-file-path>
 # 4. Dependencies configured
 bd dep tree <epic-id>
 
-# 5. Merge target in config
-cat .thrum/config.json | grep merge_target
+# 5. Merge target in config (resolve through .thrum/redirect when present --
+#    a worktree's .thrum/ holds only a `redirect` file, not its own config.json)
+CONFIG=.thrum/config.json
+[ -f .thrum/redirect ] && CONFIG="$(cat .thrum/redirect)/config.json"
+cat "$CONFIG" | grep merge_target
 ```
 
 ### Step 2b: Triage CANDIDATE beads (if the dispatch carries any)
@@ -79,8 +82,8 @@ by the result:
 > `choosing-subagent-models` skill's job, not this one — see it for the tiers. What
 > matters here is that you pass one at all: the `roleDefault()` backstop in the
 > daemon covers `thrum tmux launch` of thrum agents, **not** Agent-tool sub-agents,
-> which inherit the PARENT model when unspecified. An orchestrator on Opus that
-> omits `model:` gets Opus-priced triage.
+> which inherit the PARENT model when unspecified. An orchestrator whose own tier is
+> costly that omits `model:` gets costly-priced triage.
 
 | Result | Action |
 |---|---|
@@ -181,13 +184,15 @@ thrum worktree create <name>
 # Pin --model on BOTH create AND launch — create's persist to runtime_config.json
 # is asynchronous and can lose the race to launch's resolution if launch omits
 # the flag (see CLAUDE.md "Launching an Agent"). There is no create-only shortcut.
-# Always launch implementers at --model sonnet. sonnet-medium is the floor;
-# no lower tier exists.
+# Always launch implementers pinned to the tier from runtime.role_models, per
+# choosing-subagent-models; that tier is the floor, no lower tier exists.
 thrum tmux create <name> --cwd <worktree-path> \
   --name <agent_name> --role implementer --module <module> \
   --mode ephemeral --identity ephemeral \
-  --model sonnet
-thrum tmux launch <name> --runtime <runtime> --model sonnet
+  --model <from runtime.role_models, per choosing-subagent-models> \
+  --effort <from runtime.role_models, per choosing-subagent-models>
+thrum tmux launch <name> --runtime <runtime> --model <from runtime.role_models, per choosing-subagent-models> \
+  --effort <from runtime.role_models, per choosing-subagent-models>
 ```
 
 > **Implementer lifecycle:** All implementers are ephemeral+stateless (no agent
@@ -215,7 +220,7 @@ it fails again, escalate to the human.
 ### Step 3b: Verify the model pin took
 
 If `--model` is dropped anywhere in the create/launch sequence, the implementer
-launches UNPINNED and the runtime defaults to Opus — the exact expensive
+launches UNPINNED and the runtime defaults to its own (costly) model — the exact expensive
 failure this tier exists to prevent. Confirm the pin landed before assigning
 work, using `thrum tmux capture --format=annotated` (see CLAUDE.md "Launching
 an Agent — Verify the Model by Pane, Never by `runtime-config get`" for the
@@ -226,12 +231,12 @@ NBSP fallback trap, and the by-position read):
 thrum tmux capture <agent-name> --format=annotated --lines 12
 ```
 
-That prints the runtime's own footer line, e.g. `Model: Sonnet 5`. **Read the
+That prints the runtime's own footer line, e.g. `Model: <resolved model>`. **Read the
 intended tier from `.thrum/config.json` → `runtime.role_models`, not from memory.**
-If the footer shows a different tier (see the BLOCKED note under Step 2 — there is
-no valid `haiku` pin), the pin failed silently — re-pin with
-`thrum tmux create ... --model sonnet` (or
-`thrum agent runtime-config set <agent_name> --model sonnet`) and relaunch BEFORE
+If the footer shows a different tier (see the BLOCKED note under Step 2 — the model ban
+list lives in `choosing-subagent-models`), the pin failed silently — re-pin with
+`thrum tmux create ... --model <from runtime.role_models, per choosing-subagent-models> --effort <from runtime.role_models, per choosing-subagent-models>` (or
+`thrum agent runtime-config set <agent_name> --model <from runtime.role_models, per choosing-subagent-models>`) and relaunch BEFORE
 assigning work. **Do not dispatch an unpinned implementer** — the daemon's
 role-default backstop (`jq -r '.runtime.role_models' .thrum/config.json`) is a
 net for a forgotten pin, not a substitute for this check.
@@ -329,9 +334,9 @@ Handle each message type:
 2. Dispatch BOTH reviewers IN PARALLEL (one Agent call per reviewer in the same
    response). Block until BOTH return:
    - Code-quality: `superpowers:code-reviewer` (or `feature-dev:code-reviewer`
-     if the project provides one) — `model: "sonnet"`
+     if the project provides one) — `model: <per choosing-subagent-models>`
    - Spec-compliance: `general-purpose` reviewer cross-referencing the plan/
-     spec — `model: "sonnet"`
+     spec — `model: <per choosing-subagent-models>`
 3. **Verify** every cited `file:line` claim against the actual source before
    forwarding. Reviewers can misread files; forwarding unverified findings
    wastes the implementer's time.
@@ -389,10 +394,7 @@ Handle each message type:
 **Sub-agent model discipline (applies to ALL Agent tool calls in this phase and
 Phase 5):**
 
-> **Model tiers:** pass an explicit `model:` on every dispatch — `sonnet`
-> (low effort) mechanical, `sonnet` (medium effort) judgment, Opus only on
-> operator-ask or a skill step that names it. See the
-> `choosing-subagent-models` skill for the full policy.
+> **Model tiers:** pass an explicit `model:` on every dispatch; choose model and effort per the `choosing-subagent-models` skill (read `runtime.role_models` at the moment of use). Never let a sub-agent inherit your own model.
 
 **Blocker:**
 
@@ -504,11 +506,11 @@ done
 
 **C. If conflicts arise:**
 Reading the conflicted files directly is permitted (merge-conflict carve-out
-in Scope Boundaries). Analyze the conflict using your plan/intent context to
+in the Scope section of your preamble). Analyze the conflict using your plan/intent context to
 determine the correct resolution. Then spawn a targeted edit sub-agent:
 
 ```text
-Agent(subagent_type="general-purpose", model="sonnet",
+Agent(subagent_type="general-purpose", model="<per choosing-subagent-models>",
   prompt="Resolve this specific merge conflict.
   File: <file-path>
   Conflicted section: <paste the <<<< ==== >>>> block>
@@ -618,18 +620,30 @@ can act on, which is how a guard gets disabled. Classify every hit — only a
 classifier failure is a real only-copy:
 
 ```bash
-# STAGE 2 — CLASSIFY every hit from stage 1 against ALL HISTORY, not the tip
-# tree (a tip-only check like `git cat-file -e origin/<ref>:<path>` flags
-# every file the 19-session sliding window has legitimately trimmed as
-# unrecoverable — over-reporting, not under-reporting, but still an alarm
-# nobody can act on):
-git log --all --oneline -- ".thrum/agents/<path>" | head -1
-#   NON-EMPTY -> RECOVERABLE (in git history)
-#   EMPTY     -> ONLY-COPY — SALVAGE BEFORE REMOVAL
-
-# CONTROLS — the classifier must be able to both affirm and refuse:
-git log --all --oneline -- ".thrum/agents/<a-real-trimmed-path>"   # must be NON-EMPTY
-git log --all --oneline -- ".thrum/agents/__nope__/x"              # must be EMPTY
+# STAGE 2 — classify every stage-1 hit. Test that a BLOB IS RETRIEVABLE,
+# never that the path merely appears in the log: `git log -- <path>` also
+# matches the commit that DELETED the file, and `| head -1` returns exactly
+# that for a trimmed file.
+git log --all --oneline --name-status -- ".thrum/agents/<path>"   # read the A/M/D column; do NOT head -1
+git cat-file -e "<add-or-modify-sha>:.thrum/agents/<path>"        # rc=0 proves the BLOB EXISTS
+git show "<that-sha>:.thrum/agents/<path>" > /tmp/x && cmp /tmp/x "<worktree-copy>"
+#   blob retrievable AND byte-identical -> RECOVERABLE
+#   otherwise                           -> ONLY-COPY — SALVAGE BEFORE REMOVAL
+# Always check rc explicitly on git show/cat-file; never infer from output size.
+# Form the cmp control from two files KNOWN to differ — comparing an
+# accidentally-empty extraction against /dev/null reports "identical" and
+# reads as a passing control.
+
+# CONTROLS — the classifier must be able to both affirm and refuse.
+# Exercise BOTH halves of the decision: existence (cat-file -e) AND
+# byte-identity (cmp). Controlling only existence leaves the cmp step
+# unguarded — and cmp is where an accidentally-empty extraction reads
+# as "identical" and passes.
+git cat-file -e "<add-or-modify-sha>:.thrum/agents/<path>";      echo "rc=$? (must be 0)"
+git cat-file -e "<add-or-modify-sha>:.thrum/agents/__nope__/x";  echo "rc=$? (must be NON-ZERO)"
+printf 'x' > /tmp/ctl-differs
+cmp -s /tmp/x /tmp/ctl-differs; echo "rc=$? (must be NON-ZERO — proves cmp CAN detect a difference)"
+cmp -s /tmp/x /tmp/x;           echo "rc=$? (must be 0 — proves cmp CAN affirm)"
 ```
 
 ```bash
@@ -719,7 +733,7 @@ Run review rounds; converge to zero BLOCKING:
 **Round N:**
 
 1. Dispatch BOTH reviewers IN PARALLEL — code-quality (`feature-dev:code-reviewer`,
-   `model: "sonnet"`) + spec-compliance (`general-purpose`, `model: "sonnet"`).
+   `model: <per choosing-subagent-models>`) + spec-compliance (`general-purpose`, `model: <per choosing-subagent-models>`).
    **In each reviewer dispatch prompt, mandate structured severity:**
    > "Label every finding BLOCKING / IMPORTANT / MINOR. At least one label per
    > finding, prefix each finding line."
@@ -775,7 +789,7 @@ them, forward to coordinator at merge-approval.
 **Hard cap — 2 rounds max:**
 If BLOCKING findings remain after round 2:
 
-- Step A: REMOVED. sonnet-medium is the implementer floor, so there is no
+- Step A: REMOVED. The implementer tier is the floor, so there is no
   lower tier to escalate from. A round-2 BLOCKING failure goes straight to
   Step B.
 - Step B (escalate up): if the implementer fails to converge, escalate to coordinator
@@ -793,3 +807,30 @@ EOF
 ```
 
 Do not proceed without approval when autonomy is `per_epic`.
+
+### Tier-swap: replace an underperforming implementer in the same worktree
+
+Use when the first review shows multiple BLOCKING findings, systematic misunderstanding of the task, or an agent clearly going long. The swap reuses the SAME worktree: retire the underperforming agent and relaunch a fresh one under a NEW name in place. Never `thrum agent delete` (operator-only, gated to the coordinator; orchestrators are refused). The swapped-out agent is retired with `set-phase retired`; its registry row, messages and transcript are retained.
+
+Step 1: kill the old agent's tmux session first, so its pid is dead. A live-pid identity file is preserved and not quarantined; a dead pid lets the new create quarantine it.
+  thrum tmux kill <same_worktree_name>
+Step 2: retire the old agent. It keeps the registry row (Retired tab). `set-phase` is not operator-gated. Retiring does not free the identity; Step 4's create does.
+  thrum agent set-phase retired --agent <underperforming_agent_name>
+Step 3: verify the worktree is intact (WIP code preserved).
+  ls <worktree-path>
+Step 4: launch a fresh ephemeral identity under a NEW name in the SAME worktree, pinned on both create and launch from `runtime.role_models` (per `choosing-subagent-models`). `--intent` carries the orient-from-WIP one-liner.
+  thrum tmux create <same_worktree_name> --cwd <worktree-path> --name <new_agent_name> --role implementer --module <module> --mode ephemeral --identity ephemeral --model <per runtime.role_models> --effort <per runtime.role_models> --intent "tier-swap: orient in the worktree (WIP + first-review findings) and continue"
+  thrum tmux launch <same_worktree_name> --runtime claude --model <per runtime.role_models> --effort <per runtime.role_models>
+Step 5: deliver the WIP pointer and first-review findings (a cold handoff: the code plus the findings).
+  thrum send --to @<new_agent_name> --stdin <<'EOF'
+  Tier-swap pickup: <WIP summary + first-review findings>
+  EOF
+
+The pickup prompt (Step 5) must include:
+  You are picking up in-progress work from a prior agent that was replaced.
+  Context:
+  - Worktree: <path> — contains partial implementation, review it with git diff
+  - Task: <epic-id> / <task description>
+  - First-review findings from the prior pass:
+    <paste the consolidated finding list here>
+  - Your goal: address all BLOCKING findings + complete the remaining task scope.