@tekyzinc/gsd-t 3.16.12 → 3.18.11

package/commands/gsd-t-wave.md

@@ -4,16 +4,16 @@ You are the wave orchestrator. You do NOT execute phases yourself. Instead, you
 
 ## Argument Parsing
 
-Parse `$ARGUMENTS`. Detect `--watch` (sets `WATCH_FLAG=true`; default `false`). Per `.gsd-t/contracts/headless-default-contract.md` §2, `--watch` propagates to **primary** phase-agent spawns only. Validation spawns (doc-ripple in Step 7) always go headless regardless of the flag.
+Parse `$ARGUMENTS`. M43 D4 removed `--watch`; `--in-session`/`--headless` were never shipped. Under `.gsd-t/contracts/headless-default-contract.md` **v2.0.0** every phase-agent spawn goes headless unconditionally. A legacy `--watch` token in `$ARGUMENTS` is accepted but ignored (one-line stderr deprecation warning from the spawn primitive).
 
-## Spawn Primitive — Default Headless (M38 Domain 1)
+## Spawn Primitive — Always Headless (M43 D4, v2.0.0)
 
-Per `.gsd-t/contracts/headless-default-contract.md` v1.0.0. Spawn classifications used below:
+Per `.gsd-t/contracts/headless-default-contract.md` v2.0.0. Spawn classifications (kept for logging only — both always headless):
 
 - `spawnType: 'primary'` — per-phase agents (partition, discuss, plan, impact, execute, test-sync, integrate, verify+complete)
 - `spawnType: 'validation'` — post-phase spot-checks, doc-ripple agent
 
-Default path is `autoSpawnHeadless({command, spawnType, watch: WATCH_FLAG, projectDir, sessionContext})` with the read-back banner surfacing completion. When `WATCH_FLAG=true` AND `spawnType='primary'`, `autoSpawnHeadless` returns `{mode:'in-context'}` and the orchestrator falls back to the in-context Task-agent pattern documented inline.
+Spawn path is `autoSpawnHeadless({command, spawnType, projectDir, sessionContext})` with the read-back banner surfacing completion.
 
 ## Model Assignment
 
@@ -35,7 +35,7 @@ Run via Bash:
 node -e "const tb = require('./bin/token-budget.cjs'); const s = tb.getSessionStatus('.'); console.log(JSON.stringify(s));"
 ```
 
-This calls `getSessionStatus()` which reads `.gsd-t/.context-meter-state.json` produced by the Context Meter PostToolUse hook. The returned `threshold` is `normal` or `threshold` (single-band model per `context-meter-contract.md` v1.3.0) and drives the gate logic in the Phase Agent Spawn Pattern below. When the state file is absent, `getSessionStatus()` returns `{pct: 0, threshold: 'normal'}`. `thresholdPct` (default `75`) and `modelWindowSize` are configured in `.gsd-t/context-meter-config.json`.
+This calls `getSessionStatus()` which reads `.gsd-t/.context-meter-state.json` produced by the Context Meter PostToolUse hook. The returned `{pct, threshold}` is captured for the NEXT spawn's token-log Ctx% column — under headless-default-contract v2.0.0 the `threshold` band does NOT drive the spawn decision; every phase agent goes through `autoSpawnHeadless()` unconditionally. When the state file is absent, `getSessionStatus()` returns `{pct: 0, threshold: 'normal'}`. `thresholdPct` (default `75`) and `modelWindowSize` are configured in `.gsd-t/context-meter-config.json`.
 
 ## Step 1: Load State (Lightweight)
 
@@ -175,8 +175,7 @@ node -e "const tb=require('./bin/token-budget.cjs'); const s=tb.getSessionStatus
 The JSON on stdout contains `{pct, threshold}` where `threshold` is `normal` or `threshold` (single-band model per `context-meter-contract.md` v1.3.0).
 
 Handling:
-- `threshold === 'normal'` → proceed to the next phase.
-- `threshold === 'threshold'` → the Context Meter's PostToolUse hook has already emitted the `next-spawn-headless:true` marker; the orchestrator routes subsequent subagent spawns through `autoSpawnHeadless()`. No manual checkpoint/halt — the meter + spawn primitive together handle handoff.
+Capture `pct` for the next spawn's Ctx% log field. The `threshold` field is observational under headless-default-contract v2.0.0 — every spawn routes through `autoSpawnHeadless()` unconditionally, so the band does not gate phase progression.
 
 ### Phase Sequence
 
@@ -211,6 +210,20 @@ Spawn agent → `commands/gsd-t-impact.md`
 #### 5. EXECUTE
 Spawn agent → `commands/gsd-t-execute.md`
 - This is the heaviest phase. The execute agent uses **task-level dispatch** (fresh-dispatch-contract.md): one Task subagent per task within each domain, each receiving only scope.md + relevant contracts + single task + graph context + up to 5 prior summaries. The execute agent handles domain task-dispatching and QA internally.
+
+##### Optional — Parallel Dispatch (M44)
+
+The spawned execute agent will itself decide whether to dispatch parallel workers via `gsd-t parallel` (see `commands/gsd-t-execute.md` Step 3 → "Optional — Parallel Dispatch (M44)"). The wave orchestrator does not need to configure this — it is automatic:
+
+- If `.gsd-t/domains/` contains more than one pending task passing D4/D5/D6 gates, the execute agent dispatches via `gsd-t parallel` instead of sequentially.
+- Mode is auto-detected from `GSD_T_UNATTENDED=1` — the wave orchestrator inherits this env from its own spawn. Do not hardcode `--mode`.
+- Fallback is silent: any gate veto, unprovable disjointness, or single-task scope drops back to the sequential execute path without a user prompt.
+- D2 owns the spawn observability; the parallel path writes the same `.gsd-t/events/YYYY-MM-DD.jsonl` records and `.gsd-t/token-log.md` rows as the sequential path via `captureSpawn`. D3 adds no new spawn machinery.
+- `[unattended]` — D2 enforces the zero-compaction contract by splitting tasks when D6 estimates per-worker CW > 60%.
+- `[in-session]` — NEVER interrupts the user with pause/resume. If headroom is tight, D2 reduces the worker count (floor N=1) and emits `parallelism_reduced`.
+
+No wave-orchestrator-level flag exists to opt out; the parallel-vs-sequential decision is owned by the execute agent and the D2 gating math. Contract: `.gsd-t/contracts/wave-join-contract.md` v1.1.0.
+
 - **Adaptive replanning**: After each domain completes, the execute agent runs a replan check (per `adaptive-replan-contract.md`). If a completed domain's task summaries reveal new constraints (e.g., deprecated API, wrong column name, incompatible library), the execute agent checks remaining domains' `tasks.md` files for invalidated assumptions and revises them on disk before dispatching the next domain. Maximum 2 replan cycles per execute run — if exceeded, execution pauses for user input. All replan decisions are logged to the Decision Log in `progress.md`. The wave phase summary includes any replan actions taken.
 - **Team/parallel mode**: If the plan defines parallel domains (same wave), the execute agent dispatches each domain teammate with `isolation: "worktree"` (per worktree-isolation-contract.md). Each domain works in an isolated git worktree. After all domains complete, the execute agent runs the Sequential Merge Protocol: merge domain A → test → merge domain B → test. Per-domain rollback if tests fail. Worktrees are cleaned up after all merges complete.
 - After: Read `progress.md`, verify status = EXECUTED. Phase summary must include replan actions if any occurred:
@@ -246,7 +259,7 @@ After the final phase completes but before wave reports done:
 
 1. Run threshold check — read `git diff --name-only HEAD~1` and evaluate against doc-ripple-contract.md trigger conditions
 2. If SKIP: log "Doc-ripple: SKIP — {reason}" and proceed
-3. If FIRE: spawn doc-ripple agent — `spawnType: 'validation'` (always headless, `--watch` ignored):
+3. If FIRE: spawn doc-ripple agent — `spawnType: 'validation'` (always headless per headless-default-contract v2.0.0):
 
 ⚙ [{model}] gsd-t-doc-ripple → blast radius analysis + parallel updates
 

package/commands/gsd.md

@@ -26,7 +26,9 @@ Before semantic evaluation, determine if this is a **continuation** of an alread
 
 ## Step 2.5: Intent Classification
 
-For non-continuation messages, decide whether the request is **conversational** (user is thinking, exploring, or articulating — no command spawn) or **workflow** (user wants work done — route to a GSD-T command via Step 2).
+> **Inverted default (M43 D4, v2.0.0)** — the only in-session surface in GSD-T is this router itself, and only for dialog-only (exploratory) turns. Every **workflow** turn spawns a detached command unconditionally. There is no `--in-session` flag, no `--headless` flag, no context-meter threshold that reroutes. See `.gsd-t/contracts/headless-default-contract.md` v2.0.0 §Invariants.
+
+For non-continuation messages, decide whether the request is **conversational** (user is thinking, exploring, or articulating — no command spawn; stays in the dialog channel) or **workflow** (user wants work done — route to a GSD-T command via Step 2; **always spawns detached**).
 
 This step replaces the retired `/gsd-t-prompt`, `/gsd-t-brainstorm`, and `/gsd-t-discuss` commands, whose use cases the router now handles inline.
 
@@ -41,12 +43,12 @@ This step replaces the retired `/gsd-t-prompt`, `/gsd-t-brainstorm`, and `/gsd-t
 
 ### Workflow triggers (proceed to Step 2 semantic evaluation):
 
-- Direct task requests: "fix", "add", "implement", "refactor", "ship", "build", "delete", "rename"
+- Direct task requests / action verbs: "fix", "add", "implement", "refactor", "ship", "build", "run", "execute", "deploy", "delete", "rename"
 - Named artifacts: "run the tests", "scan the codebase", "verify the milestone", "status"
 - Design-to-code requests (see Step 2 design-to-code routing)
 - Anything where the user expects files to change or a command to run
 
-**Action for workflow triggers**: proceed to Step 2.
+**Action for workflow triggers**: proceed to Step 2 — which then spawns detached unconditionally (v2.0.0 invariant).
 
 ### Default
 
@@ -218,4 +220,44 @@ I'll route to the right GSD-T command — or just think out loud with you
 if you're still figuring things out (no command spawn).
 ```
 
+## Step 5: Dialog-Channel Growth Warning (M43 D5)
+
+After you've finished your response text (routing header + any conversational body + any command invocation), check whether dialog growth is trending toward `/compact` and, if so, append a one-line warning footer. This is a pure read/warn signal — it never refuses, never reroutes, never blocks.
+
+### When to check
+
+- Always — every router turn ends with this check. Cost is a single JSONL read of `.gsd-t/metrics/token-usage.jsonl`.
+
+### How to check
+
+Run the following (substitute the current session id; `$CLAUDE_SESSION_ID` works in most shells, otherwise fall back to the most recent `sessionType: "in-session"` session in the sink):
+
+```
+node -e "
+const { estimateDialogGrowth } = require('./bin/runway-estimator.cjs');
+const r = estimateDialogGrowth({
+  projectDir: '.',
+  sessionId: process.env.CLAUDE_SESSION_ID || '',
+});
+if (r.shouldWarn) {
+  const n = r.predicted_turns_to_compact;
+  const k = r.k;
+  const d = Math.round(r.median_delta);
+  console.log('> ⚠  Dialog pressure: ~' + n + ' turns to /compact (last K=' + k + ' turns, growth ~' + d + '/turn).');
+  console.log('> Consider spawning the next action detached (\`/gsd ... --detach\`) or running \`/compact\` now.');
+}
+"
+```
+
+### What to emit
+
+If the node call prints nothing (growth flat, insufficient history, no session, etc.), emit nothing. Otherwise append the printed block verbatim as the last lines of your response. It MUST render as a blockquote — two lines, starting with `> ⚠`. Never reformat it, never prepend explanation, never turn it into a modal or a `/clear` command.
+
+### What NOT to do
+
+- Do NOT refuse or defer the user's request based on this signal.
+- Do NOT silently route to a different command because of growth.
+- Do NOT emit the warning more than once per turn.
+- Do NOT write to any file from this step — it is pure read + footer print.
+
 $ARGUMENTS

package/docs/GSD-T-README.md

@@ -101,12 +101,12 @@ GSD-T reads all state files and tells you exactly where you left off.
 | `/gsd-t-discuss` | Multi-perspective design exploration | In wave |
 | `/gsd-t-plan` | Create atomic task lists per domain (tasks auto-split to fit one context window) | In wave |
 | `/gsd-t-impact` | Analyze downstream effects | In wave |
-| `/gsd-t-execute` | Run tasks — task-level fresh dispatch, worktree isolation, adaptive replanning, stack rules injection | In wave |
+| `/gsd-t-execute` | Run tasks — task-level fresh dispatch, worktree isolation, adaptive replanning, stack rules injection. M44 (D3): conditionally dispatches >1 gate-passing task via `gsd-t parallel`; single-task or veto falls back to sequential silently. | In wave |
 | `/gsd-t-test-sync` | Sync tests with code changes | In wave |
 | `/gsd-t-qa` | QA agent — test generation, execution, gap reporting | Auto-spawned |
 | *Red Team* | Adversarial QA — spawns after QA passes to find bugs the builder missed | Auto-spawned |
 | `/gsd-t-doc-ripple` | Automated document ripple — update downstream docs after code changes | Auto-spawned |
-| `/gsd-t-integrate` | Wire domains together | In wave |
+| `/gsd-t-integrate` | Wire domains together. M44 (D3): conditionally dispatches multi-domain integration tasks via `gsd-t parallel`; single-domain wiring unchanged. | In wave |
 | `/gsd-t-verify` | Run quality gates + goal-backward verification → auto-invokes complete-milestone | In wave |
 | `/gsd-t-complete-milestone` | Archive + git tag (auto-invoked by verify, also standalone) | In wave |
 
@@ -117,12 +117,12 @@ GSD-T reads all state files and tells you exactly where you left off.
 | `/gsd-t-unattended` | Launch detached supervisor — runs active milestone to completion with zero human intervention | Manual |
 | `/gsd-t-unattended-watch` | Watch tick — fires every 270s via ScheduleWakeup, reports supervisor status | Auto |
 | `/gsd-t-unattended-stop` | Touch stop sentinel — supervisor halts after current worker finishes | Manual |
-| `/gsd-t-wave` | Full cycle, auto-advances all phases | Manual |
+| `/gsd-t-wave` | Full cycle, auto-advances all phases. M44 (D3): EXECUTE phase inherits parallel dispatch from execute agent; no wave-level flag needed — mode auto-detected from `GSD_T_UNATTENDED`. | Manual |
 | `/gsd-t-status` | Cross-domain progress view with token breakdown, global ELO and cross-project rankings | Manual |
 | `/gsd-t-resume` | Restore context, continue | Manual |
-| `/gsd-t-quick` | Fast task with GSD-T guarantees | Manual |
+| `/gsd-t-quick` | Fast task with GSD-T guarantees. M44 (D3): lightweight — conditional parallel dispatch only when >1 pending task AND all gates pass; single-task (the common case) runs sequentially unchanged. | Manual |
 | `/gsd-t-visualize` | Launch browser dashboard — SSE server + React Flow agent visualization | Manual |
-| `/gsd-t-debug` | Systematic debugging with state | Manual |
+| `/gsd-t-debug` | Systematic debugging with state. M44 (D3): conditional parallel dispatch only for multi-domain contract-boundary/gap debug sessions; single-domain debug runs sequentially unchanged. | Manual |
 | `/gsd-t-metrics` | View task telemetry, process ELO, signal distribution, domain health, and cross-project comparison (`--cross-project`) | Manual |
 | `/gsd-t-health` | Validate .gsd-t/ structure, optionally repair | Manual |
 | `/gsd-t-pause` | Save exact position for reliable resume | Manual |
@@ -351,6 +351,44 @@ gsd-t headless --debug-loop [--max-iterations=N] [--test-cmd=CMD] [--fix-scope=P
 
 ---
 
+## Parallel CLI (M44)
+
+Run task-level parallel workers with mode-aware gating (D4 depgraph → D5 file-disjointness → D6 economics + headroom/split).
+
+```bash
+gsd-t parallel --help                           # Usage, flags, gates, contract ref
+gsd-t parallel --dry-run                        # Plan table + worker count + mode (no spawn)
+gsd-t parallel --mode in-session --dry-run      # 85% orchestrator-CW ceiling; N=1 floor
+gsd-t parallel --mode unattended --dry-run      # 60% per-worker ceiling; > 60% → task_split
+gsd-t parallel --milestone M44 --domain m44-d2-parallel-cli --dry-run
+```
+
+**Flags:**
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--mode in-session\|unattended` | auto | auto-detect: `GSD_T_UNATTENDED=1` → unattended, else in-session. Explicit flag overrides env. |
+| `--milestone Mxx` | active | Milestone filter |
+| `--domain <name>` | all | Domain filter |
+| `--dry-run` | false | Print plan table + exit; never spawns workers |
+| `--help / -h` | — | Usage + flags + gates |
+
+**Three upstream gates** (strict sequence before any fan-out):
+1. **D4 depgraph validation** — every task's `Dependencies:` must be `done`; otherwise `gate_veto{gate:"deps"}` → sequential.
+2. **D5 file-disjointness** — tasks' `Touches:` sets must have empty intersection; overlap → `gate_veto{gate:"disjointness"}` for every pair (both sequential).
+3. **D6 economics estimator** — per-task CW footprint prediction from the token-usage corpus; informs but never vetoes on its own.
+
+**Mode-aware final gate:**
+
+| Mode | Threshold | Math | On exceed |
+|------|-----------|------|-----------|
+| in-session | 85% orchestrator-CW | `ctxPct + N × summarySize ≤ 85` | Reduce `N` to fit; floor `N=1` (never refuses) — emits `parallelism_reduced` |
+| unattended | 60% per-worker CW | `estimatedCwPct ≤ 60` | `split=true`; caller slices into iters — emits `task_split` |
+
+**Contract:** `.gsd-t/contracts/wave-join-contract.md` v1.1.0 (§Mode-Aware Gating Math) is the authoritative reference for thresholds, fallback behavior, and event schemas.
+
+---
+
 ## Key Principles
 
 1. **Contracts are the source of truth.** Code implements contracts, not the other way around. If code and contract disagree, fix one or the other — never leave them inconsistent.