@pennixrv/trellis 0.7.0-beta.31 → 0.7.0-beta.34

package/dist/templates/common/bundled-skills/trellis-channel/references/forum.md

@@ -26,8 +26,7 @@ trellis channel create design-feedback \
   --type forum \
   --scope global \
   --description "Cross-project design feedback board." \
-  --context-raw "One thread per design topic; close when resolved." \
-  --by main
+  --context-raw "One thread per design topic; close when resolved."
 ```
 
 Use `--scope project` for a board scoped to one repo, `--scope global` for a
@@ -42,7 +41,6 @@ a thread is `opened`; everything afterwards uses the same `--thread` key.
 ```bash
 trellis channel post design-feedback opened \
   --scope global \
-  --as main \
   --thread login-empty-state \
   --title "Empty state on the login screen" \
   --description "Track design feedback for the new login empty state." \
@@ -58,13 +56,11 @@ trellis channel post design-feedback comment \
 
 trellis channel post design-feedback status \
   --scope global \
-  --as main \
   --thread login-empty-state \
   --status closed
 
 trellis channel post design-feedback summary \
   --scope global \
-  --as main \
   --thread login-empty-state \
   --summary "Adopted the option-B layout; ticket TRELLIS-123 owns the fix."
 ```
@@ -187,12 +183,10 @@ wrong key (typo, wrong slug convention, etc.). Threads do not support hard
 deletion — rename is the supported corrective action.
 
 ```bash
-trellis channel thread rename design-feedback old-key new-key \
-  --scope global \
-  --as main
+trellis channel thread rename design-feedback old-key new-key --scope global
 ```
 
-- `--as <agent>` is **required**.
+- Omit `--as` to use `TRELLIS_CHANNEL_AS` or `main`; pass it only to attribute the rename to another actor.
 - `post <name> rename` is rejected — you must use `thread rename`.
 
 ## Deletion Discipline
@@ -216,12 +210,10 @@ trellis channel create release-notes \
   --type forum \
   --scope global \
   --description "Internal release and runtime changelog." \
-  --context-raw "One thread per notable change; close when shipped." \
-  --by main
+  --context-raw "One thread per notable change; close when shipped."
 
 trellis channel post release-notes opened \
   --scope global \
-  --as main \
   --thread release-2026-q1 \
   --title "Channel threads and forum UX in 0.6" \
   --description "Forum channel UX shipped in the 0.6 line." \

package/dist/templates/common/bundled-skills/trellis-channel/references/multi-target-dispatch.md

@@ -0,0 +1,113 @@
+# Multiple Evidence Units
+
+Use after the user has authorized independent evidence and the task owns a
+reviewed unit mapping. Read `subnode-work.md` for artifact and acceptance rules.
+Codex inline mode governs native implement/check agents; it does not disable
+explicit Channel evidence. Missing independent reports cannot be replaced by
+main-session pass claims.
+
+## Prepare And Dispatch In One Host Call
+
+Choose units by work, complexity, evidence range, and relationship. Combine only
+individually quick/simple and obviously related points with shared context and
+a bounded total workload. Each scope item keeps its own evidence, conclusion,
+unknowns, and stop condition. Neither eight slots nor eight owner domains imply
+eight work packages. Store this mapping in the task's existing plan or matrix.
+
+Read the actual native guard and current workers/reservations. Initially fill
+all available capacity in FIFO order; a justified dependency or resource limit
+belongs in the task record, not an arbitrary coordinator throttle. Initialize
+all reviewed briefs before queue creation or spawning. A failed initialization
+stops admission; preserve/reconcile partial artifacts without dispatching them.
+
+For a configured subnode profile, `spawn --profile <id> --as <worker>` implies
+the subnode role and inherits its Codex provider; do not repeat
+`--agent subnode --provider codex`. Keep each worker ID and `send --to` explicit.
+Author identity on `send` defaults to `TRELLIS_CHANNEL_AS` or `main`, so routine
+dispatch need not repeat `--as main`.
+
+Coalesce operations that can share one noninteractive host invocation. Use ONE
+native `exec_command` containing a standard-library loop over existing CLI
+commands. Multiple `exec_command` calls inside `functions.exec` still count as
+multiple host calls. This is a procedure, not a new Channel batch API, scheduler,
+or worker-state store. Keep init and dispatch as separate admission stages.
+
+The following runnable pattern consumes a temporary, reviewed JSON array of
+`{"target": "unit-id", "argv": ["trellis", "channel", ...]}` entries. Use
+`[sys.executable, ".trellis/scripts/subnode_artifact.py", ...]` for artifact
+commands. Put claim, spawn, and send in queue order; do not include waits. Review
+each argument vector and the native capacity before executing. The input and
+raw receipts are temporary command data, not task authority; retain only needed
+non-sensitive evidence and clean the temporary input after use.
+
+```bash
+# python on Windows; python3 elsewhere. Execute this whole block in ONE host call.
+python3 - /absolute/path/to/reviewed-actions.json <<'PY'
+import json
+import subprocess
+import sys
+
+actions = json.load(open(sys.argv[1], encoding="utf-8"))
+failed = False
+for action in actions:
+    if failed:
+        print(json.dumps({"target": action["target"], "status": "not_attempted"}))
+        continue
+    argv = [sys.executable if part == "{python}" else part for part in action["argv"]]
+    try:
+        result = subprocess.run(argv, capture_output=True, text=True, check=False)
+        failed = result.returncode != 0
+        receipt = {"target": action["target"], "argv": argv,
+                   "status": "error" if failed else "completed",
+                   "exit_code": result.returncode,
+                   "stdout": result.stdout, "stderr": result.stderr}
+    except OSError as error:
+        failed = True
+        receipt = {"target": action["target"], "argv": argv,
+                   "status": "error", "error": str(error)}
+    print(json.dumps(receipt), flush=True)
+sys.exit(1 if failed else 0)
+PY
+```
+
+The aggregate exit code is not per-target evidence. Inspect every receipt,
+including missing or conflicting receipts; the first error stops later actions
+and pauses the whole queue. Never retry a claimed attempt. A new approved
+attempt needs a new brief and ID.
+
+## Rolling FIFO
+
+1. Capture a durable barrier before dispatch. Claim the earliest unclaimed unit,
+   spawn/send through native Channel, and preserve its receipt. The helper
+   enforces claim order; earlier claims need not be accepted to fill initial slots.
+2. Establish exactly one native waiter for the dispatched workers without
+   `--all`. Resume only its live host continuation until it returns, times out,
+   or errors; run no other host action meanwhile.
+3. Recheck dispatched items for failures, conflicts, and unresolved terminal
+   states. Still-running healthy workers do not need to finish. Validate the
+   completed worker's per-scope report, recheck sources and protected targets,
+   then write its create-once `accepted` disposition.
+4. That acceptance plus verified native capacity authorizes the next unclaimed
+   FIFO unit immediately, while other healthy workers continue. Preserve the
+   barrier/event cursor so already emitted terminal events cannot be lost.
+5. Incomplete/blocked/rejected results, validator concerns, capacity refusal,
+   missing/conflicting receipts, or unresolvable reservations pause the entire
+   queue. A terminal event alone never authorizes replacement. On recovery,
+   reconstruct claims, events, workers/reservations, reports, and dispositions;
+   never redispatch an old claim or require all healthy live predecessors to
+   complete merely to refill an accepted slot.
+
+## Temporary Task Switch
+
+Save the old task's checkpoint. Pause refills and drain ALL already dispatched
+units: wait, validate, and disposition each result, including failures; confirm
+the live continuation, worker, and reservation boundaries are closed. A drain
+does not dispatch pending queue items or turn a failure into acceptance. Do not
+automatically kill, retry, or abandon the old queue. Preserve unclaimed work and
+the old phase. Only after drain, run native `task.py select <new-task>`; it
+changes context without status, branch, after_start hooks, or implementation
+authority. With no in-flight work, select directly after saving the checkpoint.
+
+When returning, reconstruct only the missing old-task facts and resume only
+still-authorized work. Selecting a user-stopped audit never restarts it. Ordinary
+continue and sufficient compaction recovery retain their direct checkpoint path.

package/dist/templates/common/bundled-skills/trellis-channel/references/progress-debugging.md

@@ -127,7 +127,7 @@ wait command starts, capture a barrier before that operation and pass it back:
 ```bash
 BARRIER="$(trellis channel barrier T)"
 # spawn or trigger work that may emit a terminal event
-trellis channel wait T --as main --workers check \
+trellis channel wait T --workers check \
   --after-seq "$BARRIER" --timeout 15m
 ```
 
@@ -146,10 +146,10 @@ The separate event-filter mode wakes on:
 Useful filters:
 
 ```bash
-trellis channel wait T --as main --from check --kind done --timeout 15m
-trellis channel wait T --as main --from check,check-cx --kind done --all --timeout 15m
+trellis channel wait T --from check --kind done --timeout 15m
+trellis channel wait T --from check,check-cx --kind done --all --timeout 15m
 trellis channel wait T --as worker --kind message --timeout 1h
-trellis channel wait T --as main --thread release-note --action status --timeout 10m
+trellis channel wait T --thread release-note --action status --timeout 10m
 ```
 
 Exit codes: `0` matched, `124` timeout, `1`/`2` errors. On `wait --all`

package/dist/templates/common/bundled-skills/trellis-channel/references/subnode-work.md

@@ -20,7 +20,26 @@ dependencies, stop conditions, deadline, and `channel_ref`. Set `retry_of`
 only for an explicit manual retry and `counter_of` only for intentional
 counterwork. A retry names an existing, different subnode in the same task and
 `work_id`; counterwork may be initialized independently. The helper supplies
-the immutable task identity and report path.
+the immutable task identity and report path. New units also require `unit_plan`:
+
+```json
+{
+  "unit_plan": {
+    "plan_ref": ".trellis/tasks/09-07-example/design.md#evidence-units",
+    "sizing_rationale": "One bounded dependency inspection with a separately reviewable result."
+  }
+}
+```
+
+The reference must identify an existing regular Markdown document inside this
+task. For multiple scope items, add `grouping_rationale` explaining why every
+item is quick/simple, obviously related, and uses shared context while retaining
+separate conclusions. Record the actual scope mapping and evidence in the task
+plan before initializing briefs; owner domains and slot counts do not determine
+unit counts. Complex or lengthy points need separate units or further splitting.
+The helper checks structure, not the truth of the sizing judgment. Historical
+brief/report readers remain compatible; new init and queue admission require
+the unit plan.
 
 ```bash
 TASK=.trellis/tasks/09-07-example
@@ -117,19 +136,20 @@ the worker can emit a terminal event. The CLI waits once for a worker lifecycle
 transition after that barrier, including supervisor-authored terminal events:
 
 ```bash
-trellis channel create subnode-example --by main --cwd "$PWD"
+trellis channel create subnode-example
 BARRIER="$(trellis channel barrier subnode-example)"
-trellis channel spawn subnode-example --agent subnode --provider codex \
-  --as "$SUBNODE_ID" --cwd "$PWD"
+trellis channel spawn subnode-example --agent subnode --as "$SUBNODE_ID"
 
 printf '%s\n' "Read $TASK/subnodes/$WORK_ID/$SUBNODE_ID/brief.json and perform only that bounded work." \
-  | trellis channel send subnode-example --as main --to "$SUBNODE_ID" \
+  | trellis channel send subnode-example --to "$SUBNODE_ID" \
       --stdin --delivery-mode requireRunningWorker
 
-trellis channel wait subnode-example --as main --workers "$SUBNODE_ID" \
+trellis channel wait subnode-example --workers "$SUBNODE_ID" \
   --after-seq "$BARRIER" --timeout 30m
 ```
 
+When selecting a configured model profile, use `--profile <id>` in place of `--agent subnode`; it implies the subnode role and reads its Codex provider from role frontmatter. Keep the unique worker `--as` for dispatch identity. Omit author `--as` on `send` and `wait` to use `TRELLIS_CHANNEL_AS` or `main`.
+
 `channel.subnode` in `.trellis/config.yaml` supplies the role defaults for
 `max_live_workers` (generated default `8`), `idle_timeout`, `timeout`, and
 `warn_before`. Change that section before a dispatch group when its resource
@@ -137,7 +157,12 @@ or lifetime needs differ; pass the corresponding `spawn` flag only for a
 one-off override. The generic `channel.worker_guard` remains the fallback for
 ordinary workers and for a subnode key omitted from the project config.
 
-For a group, use `--workers a,b --all` with the barrier captured before dispatch.
+For rolling FIFO dispatch, follow `references/multi-target-dispatch.md`: initially
+fill available native capacity, wait for the first terminal worker, review and
+accept it, then refill while other workers continue. Do not use `--all` as an
+ordinary refill prerequisite. Use `--workers a,b --all` only when the intent
+requires draining all already dispatched workers, with the barrier captured
+before dispatch.
 Worker mode emits one terminal worker projection per satisfied target. Ordinary
 adapter errors and peer turn completion do not end the wait. `--from` remains
 an exact event-author filter; it is not a worker lifecycle selector.

package/dist/templates/common/bundled-skills/trellis-channel/references/workers.md

@@ -106,8 +106,7 @@ trellis channel spawn cr-example --agent check --provider codex --as check-cx \
   --file "$TASK/prd.md" \
   --file "$TASK/design.md" \
   --file "$TASK/implement.md" \
-  --jsonl "$TASK/check.jsonl" \
-  --cwd "$PWD" --timeout 30m
+  --jsonl "$TASK/check.jsonl" --timeout 30m
 ```
 
 The `spawned` event records both the literal `files` array and any `manifests`
@@ -128,7 +127,7 @@ channel:
 trellis channel spawn cr-feature --agent check --as check-claude
 trellis channel spawn cr-feature --agent check --provider codex --as check-cx
 
-trellis channel wait cr-feature --as main \
+trellis channel wait cr-feature \
   --from check-claude,check-cx --kind done --all --timeout 15m
 ```
 

package/dist/templates/common/bundled-skills/trellis-channel/references/workflows.md

@@ -9,7 +9,7 @@ Use when the user says "和 codex/claude 讨论一下", "brainstorm", or "拉一
 进来一起看".
 
 ```bash
-trellis channel create brainstorm-storage-layer --by main \
+trellis channel create brainstorm-storage-layer \
   --task .trellis/tasks/05-XX-storage-adapter
 BARRIER="$(trellis channel barrier brainstorm-storage-layer)"
 
@@ -20,10 +20,10 @@ trellis channel spawn brainstorm-storage-layer \
   --as cx-arch --timeout 30m
 
 trellis channel send brainstorm-storage-layer \
-  --as main --to cx-arch --text-file /tmp/brainstorm-r1.md
+  --to cx-arch --text-file /tmp/brainstorm-r1.md
 
 trellis channel wait brainstorm-storage-layer \
-  --as main --kind done --from cx-arch --after-seq "$BARRIER" --timeout 10m
+  --kind done --from cx-arch --after-seq "$BARRIER" --timeout 10m
 ```
 
 Do not stop after one answer. Read the answer, identify vague areas, send a
@@ -53,7 +53,7 @@ Use when the user asks to dispatch implementation or review work.
 
 ```bash
 TASK=.trellis/tasks/05-12-foo
-trellis channel create cr-foo --task "$TASK" --by main
+trellis channel create cr-foo --task "$TASK"
 BARRIER="$(trellis channel barrier cr-foo)"
 
 trellis channel spawn cr-foo \
@@ -61,11 +61,10 @@ trellis channel spawn cr-foo \
   --jsonl "$TASK/check.jsonl" \
   --file "$TASK/prd.md" \
   --file "$TASK/design.md" \
-  --file "$TASK/implement.md" \
-  --cwd "$PWD" --timeout 15m
+  --file "$TASK/implement.md" --timeout 15m
 
-trellis channel send cr-foo --as main --to check --text-file /tmp/cr-brief.md
-trellis channel wait cr-foo --as main --kind done --from check --after-seq "$BARRIER" --timeout 15m
+trellis channel send cr-foo --to check --text-file /tmp/cr-brief.md
+trellis channel wait cr-foo --kind done --from check --after-seq "$BARRIER" --timeout 15m
 trellis channel messages cr-foo --kind message --from check --tag final_answer
 ```
 
@@ -78,7 +77,7 @@ already run.
 Use one channel and distinct worker names.
 
 ```bash
-trellis channel create cr-feature --by main --ephemeral
+trellis channel create cr-feature --ephemeral
 BARRIER="$(trellis channel barrier cr-feature)"
 
 trellis channel spawn cr-feature --agent check \
@@ -89,9 +88,9 @@ trellis channel spawn cr-feature --agent check --provider codex --as check-cx \
   --jsonl "$TASK/check.jsonl" --file "$TASK/prd.md" --file "$TASK/design.md" \
   --timeout 15m
 
-trellis channel send cr-feature --as main --to check --text-file /tmp/cr-brief.md
-trellis channel send cr-feature --as main --to check-cx --text-file /tmp/cr-brief.md
-trellis channel wait cr-feature --as main --kind done --from check,check-cx --all --after-seq "$BARRIER" --timeout 15m
+trellis channel send cr-feature --to check --text-file /tmp/cr-brief.md
+trellis channel send cr-feature --to check-cx --text-file /tmp/cr-brief.md
+trellis channel wait cr-feature --kind done --from check,check-cx --all --after-seq "$BARRIER" --timeout 15m
 ```
 
 `--all` means every listed worker must emit a matching event.

package/dist/templates/common/bundled-skills/trellis-meta/references/customize-local/change-task-lifecycle.md

@@ -10,6 +10,7 @@ Task lifecycle includes creation, start, context configuration, finish, archive,
 4. `.trellis/scripts/common/task_store.py`
 5. `.trellis/scripts/common/task_utils.py`
 6. The current task's `.trellis/tasks/<task>/task.json`
+7. `.trellis/scripts/common/task_planning.py` for material revisions and start admission
 
 ## Common Needs And Edit Points
 
@@ -23,6 +24,8 @@ Task lifecycle includes creation, start, context configuration, finish, archive,
 | Change default task fields | `.trellis/scripts/common/task_store.py`. |
 | Change task parsing/search | `.trellis/scripts/common/task_utils.py`. |
 | Change active task behavior | `.trellis/scripts/common/active_task.py`. |
+| Select context without starting | Native `task.py select`; preserve phase/branch and drain live Channel work first. |
+| Seal and record later approval of a material plan | Native `task.py plan seal/approve`; reserved `meta.planning`, owned by `common/task_planning.py`. |
 
 ## lifecycle hooks
 
@@ -44,7 +47,7 @@ Hook commands receive the `TASK_JSON_PATH` environment variable, pointing to the
 
 ## Change Task Fields
 
-If the user wants to add project-local fields, prefer putting them under `meta` in `task.json` to avoid breaking existing scripts' assumptions about standard fields.
+If the user wants to add project-local fields, prefer putting them under `meta` in `task.json` to avoid breaking existing scripts' assumptions about standard fields. `meta.planning` is reserved for native seal/approve; do not prefill or overwrite it through generic metadata. Classification uses `execution_class=direct|planned` and `delivery_mode=change_bearing|analysis_only`.
 
 Example:
 
@@ -70,7 +73,8 @@ Active task is session-level state stored in `.trellis/.runtime/sessions/`. Do n
 `cmd_create` in `.trellis/scripts/common/task_store.py` calls `set_active_task` best-effort right after writing the new task directory. The behavior:
 
 - When the calling shell carries session identity (`TRELLIS_CONTEXT_ID` env var, or any platform-specific session env that `resolve_context_key` recognizes — see `active_task.py:_ENV_SESSION_KEYS`), the per-session pointer at `.trellis/.runtime/sessions/<context_key>.json` is rewritten to point at the new task. The task's `status=planning` and `[workflow-state:planning]` fires on the very next `UserPromptSubmit`.
-- When session identity is unavailable (raw CLI invocation outside an AI session, or a platform that doesn't propagate identity to shell), the task directory is still created and `status=planning` is still written, but the active pointer is left untouched. The user can attach the task later with `task.py start <dir>` once they're back in an AI session.
+- When session identity is unavailable (raw CLI invocation outside an AI session, or a platform that doesn't propagate identity to shell), the task directory is still created and `status=planning` is still written, but the active pointer is left untouched. Attach planning context later with `task.py select <dir>` once identity is available; start requires its own phase/approval gates.
+- `create --no-start` deliberately preserves the prior pointer; use select to switch context after saving the checkpoint and draining already dispatched Channel work. Selecting does not change phase/branch, run after_start, or grant implementation authority.
 
 This makes `[workflow-state:planning]` the live breadcrumb during the brainstorm and JSONL curation work that follows `task.py create`. The pre-R7 behavior left the breadcrumb stuck on `no_task` until `task.py start`, so the planning block was effectively dead text.
 

package/dist/templates/common/bundled-skills/trellis-meta/references/local-architecture/task-system.md

@@ -43,6 +43,8 @@ The Trellis task system is stored entirely under `.trellis/tasks/` in the user p
 | `children` / `parent` | Parent/child task relationships. |
 | `commit` / `pr_url` | Commit and PR information after completion. |
 | `meta` | Extension fields. |
+| `meta.execution_class` / `meta.delivery_mode` | Explicit task classification; planned/change-bearing start needs current material-plan approval. |
+| `meta.planning` | Reserved native material revision, seal, and later approval; use plan seal/approve, never generic metadata. |
 
 ## Parent / Child Task Trees
 
@@ -81,7 +83,7 @@ The user sees a "current task," but Trellis stores active task state per session
 .trellis/.runtime/sessions/<context-key>.json
 ```
 
-`task.py start` writes the task path into the runtime session file for the current session. `task.py current --source` shows the current task and where it came from. Different AI windows can point to different tasks without overwriting each other.
+`task.py select` writes only the current session's task context; status/branch and implementation authority are unchanged. `task.py start` also enters execution after its admission gates. `task.py current --source` shows the current task and where it came from. Different AI windows can point to different tasks without overwriting each other. Before switching with live Channel work, pause refills and drain already dispatched units/reservations while preserving pending work and the old phase.
 
 If the platform or shell environment has no stable session identity, `task.py start` may be unable to set the active task. The AI should read the error, inspect the platform hook/session environment, and not fall back to a shared global pointer.
 
@@ -107,6 +109,9 @@ Rules:
 
 ```bash
 python3 ./.trellis/scripts/task.py create "<title>" --description "<one-line summary>" --slug <slug>
+python3 ./.trellis/scripts/task.py select <task>
+python3 ./.trellis/scripts/task.py plan seal <task>
+python3 ./.trellis/scripts/task.py plan approve <task> --revision <n> --basis "<actual later approval>"
 python3 ./.trellis/scripts/task.py start <task>
 python3 ./.trellis/scripts/task.py current --source
 python3 ./.trellis/scripts/task.py add-context <task> implement <file> <reason>

package/dist/templates/common/commands/continue.md

@@ -4,14 +4,28 @@ Resume work on the current task — pick up at the right phase/step in `.trellis
 
 ---
 
-## Step 1: Load Current Context
+## Step 1: Reuse the Checkpoint; Fill Only Missing Context
+
+If the current conversation or compaction summary already supplies project root,
+task, phase, authorization and pending action, resume that action directly. Keep
+running tool handles and completed work; skip the queries below and Steps 2–4
+unless a specific fact or instruction is missing/conflicting. A plain continue
+does not require startup, Git/status/history or formal handoff validation.
+
+After compaction, never repeat or re-answer the last consumed user input from
+before compaction. Continue from the actual checkpoint. Handle genuinely new
+post-compaction input normally.
+
+For a fresh session, changed target, missing/conflicting facts or explicit
+inspection, use the minimum query that resolves the gap:
 
 ```bash
-{{PYTHON_CMD}} ./.trellis/scripts/get_context.py
 {{PYTHON_CMD}} ./.trellis/scripts/task.py current --json
 ```
 
-Confirms: current task, git state, recent commits.
+Use full `get_context.py` only when its identity/project/Git overview is needed.
+Protected native writes still enforce identity, binding and ownership through
+their owner; this shortcut never bypasses those checks.
 
 Before routing by status, distinguish identity from task binding. A non-null
 `session_source` confirms available identity; only `source=session:...` confirms
@@ -19,17 +33,18 @@ a direct task binding. For `unbound` / `unbound_ambiguous`, review existing task
 artifacts and select by the user's explicit intent. Exit code 1 for ambiguity
 does not mean identity is absent. Do not guess, duplicate tasks, invent identity,
 or edit runtime pointers. Return a planning candidate to the planning gates below;
-use native `task.py start <task>` only when its activation contract permits it.
+use native `task.py select <task>` to bind planning context after any required
+Channel drain; use `task.py start` only when its activation contract permits it.
 An eligible `analysis_only` candidate remains in planning without start.
 If `session_source` is null, report unavailable identity separately.
 
-## Step 2: Load the Phase Index
+## Step 2: Load the Phase Index Only When Needed
 
 ```bash
 {{PYTHON_CMD}} ./.trellis/scripts/get_context.py --mode phase
 ```
 
-Shows the Phase Index (Plan / Execute / Finish) with routing + skill mapping.
+Run only when the phase or routing rule is missing; otherwise reuse it.
 
 ## Step 3: Decide Where You Are
 
@@ -37,11 +52,11 @@ Shows the Phase Index (Plan / Execute / Finish) with routing + skill mapping.
 
 - `status=planning` + `task.json.meta.delivery_mode = "analysis_only"` → first confirm the task still satisfies the bounded evidence-only eligibility rule; then complete the PRD's evidence work, verify its acceptance criteria and no-change boundary, and archive directly. Do not run `task.py start`; a protected-target change requires a separate change-bearing task.
 - `status=planning` + no `prd.md` → **1.1** (load `trellis-brainstorm`)
-- `status=planning` + a recorded `decision-needed` or unsealed decision chain → return to the planning frontier and load `pennix-decision-gates` when independent material questions can be batched.
+- `status=planning` + a recorded `decision-needed` or unsealed decision chain → return to the planning frontier and load `pennix-decision-grill` when independent material questions can be batched.
 - `status=in_progress` + a material unresolved decision → record the reason and run `task.py replan <task> "<reason>"`; do not ask a native question during implementation.
 - `status=planning` + `prd.md` only → decide whether the task is lightweight or complex. Lightweight can move to **1.4** review; complex returns to **1.1** to add `design.md` + `implement.md`.
 - `status=planning` + complex artifacts complete + sub-agent jsonl not curated (empty, or only a legacy `_example` placeholder row) → **1.3**
-- `status=planning` + required artifacts complete + required jsonl curated or inline mode → run the Planning Seal closure pass, then **1.4** (ask for start review; only run `task.py start` after user confirms)
+- `status=planning` + required artifacts complete + required jsonl curated or inline mode → run the Planning Seal closure pass, then **1.4**. Existing authorization must be a later explicit implementation approval for this task's current sealed material revision. Initial requests, design answers, and parent-task approval do not qualify. Use native plan seal/approve/start; ask only when that approval is missing. A replan invalidates it; minor progress edits do not.
 - `status=in_progress` + implementation not started → **2.1**
 - `status=in_progress` + implementation done, not yet checked → **2.2**
 - `status=in_progress` + check passed → **3.3** (spec update) → **3.4** (commit)
@@ -55,7 +70,7 @@ Phase rules (full detail in `.trellis/workflow.md`):
 
 ## Step 4: Load the Specific Step
 
-Once you know which step to resume at:
+Only if the identified step's instructions are missing:
 
 ```bash
 {{PYTHON_CMD}} ./.trellis/scripts/get_context.py --mode phase --step <X.X> --platform {{CLI_FLAG}}

package/dist/templates/common/commands/start.md

@@ -2,6 +2,12 @@
 
 Initialize a Trellis-managed development session. This platform has no session-start hook, so manually load the equivalent compact context by following these steps.
 
+Run this initialization once when project context is genuinely missing or the
+target project changes. Existing session context and a sufficient compaction
+summary count as loaded context. An ordinary continue or new task in the same
+known project resumes the pending action without repeating these steps. For
+partial missing/conflicting facts, query only the needed owner evidence.
+
 ---
 
 ## Step 1: Current state
@@ -39,6 +45,7 @@ From Step 1 you know the current task and status. Check the task directory:
 - **Active task with `task.json.meta.delivery_mode = "analysis_only"`** → keep `planning`, complete the PRD's bounded evidence work, then verify the no-change boundary, commit task artifacts, and archive directly. Do not run `task.py start`; any protected-target change needs a separate change-bearing task.
 - **Active task status `planning` + no `prd.md`** → Phase 1.1. Load the `trellis-brainstorm` skill.
 - **Active task status `planning` + `prd.md` exists** → stay in Phase 1. Lightweight tasks can be PRD-only; complex tasks need `design.md` + `implement.md`. Load the relevant Phase 1 step detail before `task.py start`.
+- **Existing task selected by explicit intent but not bound** → use native `task.py select` for context only. Drain already dispatched Channel units before a real task switch. Planned/change-bearing start requires native plan seal and matching later approval for this task's current material revision; selecting or recovering context does not approve implementation.
 - **Active task status `in_progress`** → Phase 2 step 2.1. Load the step detail:
   ```bash
   {{PYTHON_CMD}} ./.trellis/scripts/get_context.py --mode phase --step 2.1 --platform {{CLI_FLAG}}

package/dist/templates/common/skills/brainstorm.md

@@ -6,7 +6,7 @@ A request to build, implement, fix, refactor, or "go ahead" is not approval to l
 
 For every non-trivial task, the user must respond at least once after the initial request before implementation begins. If no clarification is needed, that response must approve the final planning summary described below.
 
-While any user-owned product, scope, UX, compatibility, risk, or acceptance decision remains unresolved, keep the task in planning. First inventory evidence and decision dependencies. If at least two independent material decisions remain and `pennix-decision-gates` is available, delegate one bounded batch of up to three frontier questions; otherwise ask the single highest-value question. Do not edit product code, dispatch implementation, or run `task.py start` until the decision chain is sealed.
+While any user-owned product, scope, UX, compatibility, risk, or acceptance decision remains unresolved, keep the task in planning. First inventory evidence and decision dependencies. If at least two independent material decisions remain and `pennix-decision-grill` is available, delegate one bounded batch of up to three frontier questions; otherwise ask the single highest-value question. Do not edit product code, dispatch implementation, or run `task.py start` until the decision chain is sealed.
 
 ## Analysis-Only Exception
 
@@ -30,6 +30,15 @@ Repository evidence establishes current behavior and technical constraints. The
 
 When research, audit, review, or investigation is too large to leave one independently useful conclusion in the current bounded session, split it into evidence units. Each unit must have one question or scope, a minimal evidence range, a destination artifact, and a stop condition; write its facts, conclusion or blocker, unknowns, and recovery point before starting another unit. Size units so one normal context window can finish and persist one useful result; do not promise an exact token or time limit. Routine navigation and transient tool output do not need an artifact. Create a child task only when the unit has an independent owner, lifecycle, and acceptance contract.
 
+Persist the unit-to-point mapping in this task's existing plan/matrix before
+dispatch. Include workload rationale, dependencies, minimal evidence, shared
+context, and per-point delivery. Combine points only when each is quick/simple
+and they are obviously related; explain the grouping and bounded total workload.
+Complex or lengthy points need separate units or further splitting. Slots and
+owner domains do not determine unit count. Explicit independent subnodes use
+`trellis-channel`'s unit-plan and multi-target procedure; planning itself does
+not authorize dispatch.
+
 ---
 
 Use this skill during Phase 1 planning to turn the user's request into clear requirements and planning artifacts.
@@ -60,12 +69,16 @@ Use a concise title from the user's request. Both the title and `--description`
    - product intent still needed from the user
    - scope or risk decisions still needed from the user
    - likely out-of-scope items
-4. If user-owned decisions remain, calculate the independent frontier. Use `pennix-decision-gates` for a bounded batch when two or more independent material decisions are ready; otherwise ask the single highest-value question. Include recommendation and trade-off. Yield only while the answer is unavailable.
+4. If user-owned decisions remain, calculate the independent frontier. Use `pennix-decision-grill` for a bounded batch when two or more independent material decisions are ready; otherwise ask the single highest-value question. Include recommendation and trade-off. Yield only while the answer is unavailable.
 5. When the host returns the current continuation's answer, immediately persist it in `prd.md` or the decision artifact, recheck evidence and conflicts, recalculate the frontier, and continue the same planning loop. Do not create a second Trellis lifecycle for the same decision chain. Stop only for a new unresolved frontier, a real capability or authority block, or a final sealed summary awaiting implementation approval.
 6. When no user-owned decision remains, create or update `design.md` and `implement.md` for complex tasks.
 7. Run the requirement convergence gate, then the PRD convergence pass. Finish with one Planning Seal closure pass.
 8. Present the final planning summary and stop. Do not run `task.py start` or edit product code in the same turn.
-9. Only a subsequent user message that explicitly approves the latest planning summary authorizes `task.py start` and implementation. If implementation reveals a material unresolved decision, record `decision-needed`, run `task.py replan <task> "<reason>"`, and return through this planning flow; do not open a popup during implementation.
+9. For planned/change-bearing tasks, classify `execution_class=planned` and `delivery_mode=change_bearing` in native task meta, then run `task.py plan seal <task>` after closure. Only a subsequent user message explicitly approving this task's current material plan authorizes `task.py plan approve <task> --revision <n> --basis "<short non-sensitive actual approval basis>"`, followed by `task.py start` and implementation. Initial delivery requests, parent-task approval, and design answers are insufficient. If scope, owner, risk, public behavior, or acceptance materially changes, run `task.py replan <task> "<reason>"`; it invalidates seal/approval. Return through planning, seal the new revision, present it, and obtain later approval. Minor wording, formatting, and progress records do not require resealing. The native record enforces structure, not authenticity of chat approval.
+
+When changing the active task only for planning, use native `task.py select`,
+not start. `create --no-start` intentionally preserves the old pointer. Follow
+the Channel drain procedure before switching with live evidence workers.
 
 Do not invent a project-specific product/spec hierarchy. If the repository already has product, domain, or spec docs, use them. If it does not, proceed with the evidence that exists.
 

package/dist/templates/copilot/prompts/brainstorm.prompt.md

@@ -10,7 +10,7 @@ A request to build, implement, fix, refactor, or "go ahead" is not approval to l
 
 For every non-trivial task, the user must respond at least once after the initial request before implementation begins. If no clarification is needed, that response must approve the final planning summary described below.
 
-While any user-owned product, scope, UX, compatibility, risk, or acceptance decision remains unresolved, keep the task in planning. First inventory evidence and decision dependencies. If at least two independent material decisions remain and `pennix-decision-gates` is available, delegate one bounded batch of up to three frontier questions; otherwise ask the single highest-value question. Do not edit product code, dispatch implementation, or run `task.py start` until the decision chain is sealed.
+While any user-owned product, scope, UX, compatibility, risk, or acceptance decision remains unresolved, keep the task in planning. First inventory evidence and decision dependencies. If at least two independent material decisions remain and `pennix-decision-grill` is available, delegate one bounded batch of up to three frontier questions; otherwise ask the single highest-value question. Do not edit product code, dispatch implementation, or run `task.py start` until the decision chain is sealed.
 
 ## Analysis-Only Exception
 
@@ -60,7 +60,7 @@ Use a concise title from the user's request. Both the title and `--description`
    - product intent still needed from the user
    - scope or risk decisions still needed from the user
    - likely out-of-scope items
-4. If user-owned decisions remain, calculate the independent frontier. Use `pennix-decision-gates` for a bounded batch when two or more independent material decisions are ready; otherwise ask the single highest-value question. Include recommendation and trade-off. Yield only while the answer is unavailable.
+4. If user-owned decisions remain, calculate the independent frontier. Use `pennix-decision-grill` for a bounded batch when two or more independent material decisions are ready; otherwise ask the single highest-value question. Include recommendation and trade-off. Yield only while the answer is unavailable.
 5. When the host returns the current continuation's answer, persist it in `prd.md` or the decision artifact, recheck evidence and conflicts, recalculate the frontier, and continue the same planning loop. Stop only for a new unresolved frontier, a real capability or authority block, or a final sealed summary awaiting implementation approval.
 6. When no user-owned decision remains, create or update `design.md` and `implement.md` for complex tasks.
 7. Run the requirement convergence gate, then the PRD convergence pass. Finish with one Planning Seal closure pass.

package/dist/templates/shared-hooks/inject-workflow-state.py

@@ -74,7 +74,7 @@ from typing import Optional
 # get the full SessionStart overview; this short reminder points the main session
 # at the start skill once and leaves the per-turn state block compact.
 CODEX_NO_TASK_BOOTSTRAP_NOTICE = """<trellis-bootstrap>
-If you have not already loaded Trellis context this session, read the `trellis-start` skill once.
+If Trellis project context is missing, read the `trellis-start` skill once. Current context or a sufficient compaction summary counts as loaded; an ordinary continue resumes its pending action without restarting.
 </trellis-bootstrap>"""
 
 
@@ -363,7 +363,8 @@ def _codex_mode_banner(config: dict) -> str:
     else:
         meaning = (
             "inline: the main session implements/checks directly; "
-            "do not dispatch implement/check sub-agents."
+            "do not dispatch implement/check sub-agents. Explicit Channel independent-evidence "
+            "subnodes follow the selected project workflow and remain available in inline mode."
         )
     return f"<codex-mode>{meaning}</codex-mode>"
 

package/dist/templates/trellis/index.d.ts

@@ -36,6 +36,7 @@ export declare const commonTasks: string;
 export declare const commonTaskContext: string;
 export declare const commonContextProjection: string;
 export declare const commonTaskStore: string;
+export declare const commonTaskPlanning: string;
 export declare const commonSessionContext: string;
 export declare const commonContinuationRecord: string;
 export declare const commonOwnershipRecord: string;

package/dist/templates/trellis/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/templates/trellis/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAcH,eAAO,MAAM,WAAW,QAAsC,CAAC;AAG/D,eAAO,MAAM,UAAU,QAA6C,CAAC;AACrE,eAAO,MAAM,WAAW,QAA0C,CAAC;AACnE,eAAO,MAAM,eAAe,QAA8C,CAAC;AAC3E,eAAO,MAAM,gBAAgB,QAAgD,CAAC;AAC9E,eAAO,MAAM,eAAe,QAA+C,CAAC;AAC5E,eAAO,MAAM,eAAe,QAA+C,CAAC;AAC5E,eAAO,MAAM,gBAAgB,QAAgD,CAAC;AAC9E,eAAO,MAAM,gBAAgB,QAAgD,CAAC;AAC9E,eAAO,MAAM,YAAY,QAA2C,CAAC;AACrE,eAAO,MAAM,QAAQ,QAAuC,CAAC;AAC7D,eAAO,MAAM,SAAS,QAAwC,CAAC;AAC/D,eAAO,MAAM,SAAS,QAAwC,CAAC;AAC/D,eAAO,MAAM,WAAW,QAA0C,CAAC;AACnE,eAAO,MAAM,WAAW,QAA0C,CAAC;AACnE,eAAO,MAAM,iBAAiB,QAAiD,CAAC;AAChF,eAAO,MAAM,uBAAuB,QAEnC,CAAC;AACF,eAAO,MAAM,eAAe,QAA+C,CAAC;AAC5E,eAAO,MAAM,oBAAoB,QAEhC,CAAC;AACF,eAAO,MAAM,wBAAwB,QAEpC,CAAC;AACF,eAAO,MAAM,qBAAqB,QAEjC,CAAC;AACF,eAAO,MAAM,qBAAqB,QAEjC,CAAC;AACF,eAAO,MAAM,mBAAmB,QAE/B,CAAC;AACF,eAAO,MAAM,uBAAuB,QAEnC,CAAC;AACF,eAAO,MAAM,mBAAmB,QAE/B,CAAC;AACF,eAAO,MAAM,eAAe,QAA+C,CAAC;AAC5E,eAAO,MAAM,gBAAgB,QAAgD,CAAC;AAC9E,eAAO,MAAM,gBAAgB,QAAgD,CAAC;AAG9E,eAAO,MAAM,kBAAkB,QAA2C,CAAC;AAC3E,eAAO,MAAM,mBAAmB,QAA4C,CAAC;AAC7E,eAAO,MAAM,UAAU,QAAkC,CAAC;AAC1D,eAAO,MAAM,gBAAgB,QAAyC,CAAC;AACvE,eAAO,MAAM,gBAAgB,QAAyC,CAAC;AACvE,eAAO,MAAM,qBAAqB,QAEjC,CAAC;AACF,eAAO,MAAM,mBAAmB,QAA4C,CAAC;AAG7E,eAAO,MAAM,kBAAkB,QAA8B,CAAC;AAC9D,eAAO,MAAM,kBAAkB,QAA8B,CAAC;AAC9D,eAAO,MAAM,iBAAiB,QAAgC,CAAC;AAC/D,eAAO,MAAM,qBAAqB,QAAoC,CAAC;AAMvE,eAAO,MAAM,sBAAsB,QAAsC,CAAC;AAC1E,eAAO,MAAM,kBAAkB,QAAkC,CAAC;AAClE,eAAO,MAAM,oBAAoB,QAAoC,CAAC;AACtE,eAAO,MAAM,uBAAuB,QAEnC,CAAC;AAEF;;GAEG;AACH,wBAAgB,aAAa,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA6CnD;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAOlD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/templates/trellis/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAcH,eAAO,MAAM,WAAW,QAAsC,CAAC;AAG/D,eAAO,MAAM,UAAU,QAA6C,CAAC;AACrE,eAAO,MAAM,WAAW,QAA0C,CAAC;AACnE,eAAO,MAAM,eAAe,QAA8C,CAAC;AAC3E,eAAO,MAAM,gBAAgB,QAAgD,CAAC;AAC9E,eAAO,MAAM,eAAe,QAA+C,CAAC;AAC5E,eAAO,MAAM,eAAe,QAA+C,CAAC;AAC5E,eAAO,MAAM,gBAAgB,QAAgD,CAAC;AAC9E,eAAO,MAAM,gBAAgB,QAAgD,CAAC;AAC9E,eAAO,MAAM,YAAY,QAA2C,CAAC;AACrE,eAAO,MAAM,QAAQ,QAAuC,CAAC;AAC7D,eAAO,MAAM,SAAS,QAAwC,CAAC;AAC/D,eAAO,MAAM,SAAS,QAAwC,CAAC;AAC/D,eAAO,MAAM,WAAW,QAA0C,CAAC;AACnE,eAAO,MAAM,WAAW,QAA0C,CAAC;AACnE,eAAO,MAAM,iBAAiB,QAAiD,CAAC;AAChF,eAAO,MAAM,uBAAuB,QAEnC,CAAC;AACF,eAAO,MAAM,eAAe,QAA+C,CAAC;AAC5E,eAAO,MAAM,kBAAkB,QAE9B,CAAC;AACF,eAAO,MAAM,oBAAoB,QAEhC,CAAC;AACF,eAAO,MAAM,wBAAwB,QAEpC,CAAC;AACF,eAAO,MAAM,qBAAqB,QAEjC,CAAC;AACF,eAAO,MAAM,qBAAqB,QAEjC,CAAC;AACF,eAAO,MAAM,mBAAmB,QAE/B,CAAC;AACF,eAAO,MAAM,uBAAuB,QAEnC,CAAC;AACF,eAAO,MAAM,mBAAmB,QAE/B,CAAC;AACF,eAAO,MAAM,eAAe,QAA+C,CAAC;AAC5E,eAAO,MAAM,gBAAgB,QAAgD,CAAC;AAC9E,eAAO,MAAM,gBAAgB,QAAgD,CAAC;AAG9E,eAAO,MAAM,kBAAkB,QAA2C,CAAC;AAC3E,eAAO,MAAM,mBAAmB,QAA4C,CAAC;AAC7E,eAAO,MAAM,UAAU,QAAkC,CAAC;AAC1D,eAAO,MAAM,gBAAgB,QAAyC,CAAC;AACvE,eAAO,MAAM,gBAAgB,QAAyC,CAAC;AACvE,eAAO,MAAM,qBAAqB,QAEjC,CAAC;AACF,eAAO,MAAM,mBAAmB,QAA4C,CAAC;AAG7E,eAAO,MAAM,kBAAkB,QAA8B,CAAC;AAC9D,eAAO,MAAM,kBAAkB,QAA8B,CAAC;AAC9D,eAAO,MAAM,iBAAiB,QAAgC,CAAC;AAC/D,eAAO,MAAM,qBAAqB,QAAoC,CAAC;AAMvE,eAAO,MAAM,sBAAsB,QAAsC,CAAC;AAC1E,eAAO,MAAM,kBAAkB,QAAkC,CAAC;AAClE,eAAO,MAAM,oBAAoB,QAAoC,CAAC;AACtE,eAAO,MAAM,uBAAuB,QAEnC,CAAC;AAEF;;GAEG;AACH,wBAAgB,aAAa,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA8CnD;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAOlD"}