@deftai/directive-content 0.77.0 → 0.79.0

package/scm/github.md

@@ -309,7 +309,7 @@ Phrasing from `deft policy:show --field=allowDirectCommitsToMaster`. When OFF (d
 
 ## Local git hooks (#747 / #2049)
 
-Project-root `.githooks/` enforce branch policy and encoding gates through the **`deft` CLI only** — no Python `scripts/*.py` dispatch (#2049). Hooks are installed idempotently via `deft setup` (`git config core.hooksPath .githooks`).
+Project-root `.githooks/` enforce branch policy and encoding gates through the **`deft` CLI only** — no Python `scripts/*.py` dispatch (#2049). `deft init` and `deft update` deposit hook files; `deft setup` / `task setup` wires `core.hooksPath=.githooks` and refuses when the directory is missing (#2530).
 
 | Hook | Dispatches | Purpose |
 |------|------------|---------|
@@ -318,7 +318,7 @@ Project-root `.githooks/` enforce branch policy and encoding gates through the *
 
 - ! Verify wiring after install or framework upgrade: `deft verify:hooks-installed` (also wired into `deft check`).
 - ! After upgrading the framework payload, run `deft update` from the project root to refresh `.githooks/` to the current TS-native templates (#2049). Stale hooks that still invoke `python scripts/preflight_branch.py` or other legacy paths fail `deft verify:hooks-installed`.
-- ~ Recovery when hooks are stale or broken: `deft setup` (re-installs hooks path) or `deft update` (refreshes hook files from the deposited payload).
+- ~ Recovery when hooks are stale or broken: `deft update` (deposits/refreshes hook files from the framework payload, including on an already-current deposit) then `deft setup` / `task setup` (wires `core.hooksPath` when files are present).
 
 ## Destructive gh verbs (#1019)
 

package/skills/deft-directive-build/SKILL.md

@@ -217,7 +217,8 @@ For each phase:
 2. ! **Test first** — write tests before implementation (TDD)
 3. ! **Implement** — make tests pass, following deft coding standards
 4. ! **Verify** — run `task check`, fix any issues
-5. ! **Checkpoint** — tell user what's done, what's next
+5. ! **Origin sync** — when this phase materially changed an origin-linked scope xBRIEF (`plan.references` includes `x-xbrief/github-issue`), run `task issue:sync-from-xbrief -- <path>` (or `--dry-run` to preview) so the linked GitHub issue receives a sync comment; if skipped, document why in the PR or session notes (#2540)
+6. ! **Checkpoint** — tell user what's done, what's next
 
 - ⊗ Move to next phase until current phase passes all checks
 

package/skills/deft-directive-refinement/SKILL.md

@@ -254,6 +254,14 @@ The task scans every xBRIEF with a GitHub-backed reference (whether the referenc
 ⊗ Auto-update xBRIEFs based on origin changes without user approval
 ⊗ Overwrite intentional divergence -- if a xBRIEF has been refined beyond the original issue, preserve the refinement
 
+### Origin sync after material xBRIEF edits (#2540)
+
+! When this refinement pass **materially updates** an origin-linked scope xBRIEF (AC, `plan.status`, or `plan.items` statuses/titles), run `task issue:sync-from-xbrief -- <path>` to post a sync comment on the linked GitHub issue so the human-facing tracker stays current. Use `--dry-run` to preview the comment without posting.
+
+! If sync is intentionally skipped (offline, issue frozen, divergence is deliberate), document the skip reason in the session notes or PR body — do not silently leave the origin stale.
+
+⊗ Materially edit an origin-linked xBRIEF without running `issue:sync-from-xbrief` or documenting why it was skipped
+
 ## Phase 4 -- Promote/Demote
 
 ! Move xBRIEFs between lifecycle folders using deterministic task commands. The status values below align with the canonical v0.6 Status enum (`draft | proposed | approved | pending | running | completed | blocked | failed | cancelled`) — note that `failed` is also a valid terminal transition for active work that could not complete.

package/skills/deft-directive-release/SKILL.md

@@ -113,13 +113,15 @@ The dry-run prints `[N/13] <step>... DRYRUN (would <action>)` for every pipeline
 
 ## Phase 3 — E2E sanity
 
-! Invoke `task release:e2e` against an auto-created+destroyed temp repo to verify the full pipeline shape works end-to-end before touching the real repo.
+! Invoke `task release:e2e` against an auto-created temp repo to verify the full pipeline shape works end-to-end before touching the real repo.
 
 ```
 task release:e2e
 ```
 
-The harness provisions `deftai/deftai-release-test-<ts>-<uuid6>`, runs the smoke-test rehearsal, and destroys the temp repo in a `try/finally` clause. Cleanup runs even if the rehearsal fails. If `gh repo delete` fails, surface the manual-cleanup hint to the user and continue.
+The harness provisions `deftai/deftai-release-test-<ts>-<uuid6>`, runs the smoke-test rehearsal, and **by default keeps** the temp repo (#2572). Stderr always includes the full `owner/slug` and a copy-pasteable manual-cleanup command (`gh repo delete <owner>/<slug> --yes`). Privileged environments (CI or an operator with `delete_repo`) MAY pass `task release:e2e -- --destroy-repo` to attempt auto-delete; destroy failure emits a WARN and does **not** block Phase 4 when the rehearsal succeeded.
+
+! After Phase 3, the agent MUST NOT retry or escalate temp-repo deletion. Include any leftover temp repo(s) in the phase summary for the operator to clean up manually.
 
 ! Treat a non-zero exit from `task release:e2e` as a hard refusal to proceed to Phase 4. Surface the diagnostic and ask whether to debug (return to Phase 1) or abort (`quit`).
 

package/skills/deft-directive-review-cycle/SKILL.md

@@ -1,9 +1,11 @@
 ---
 name: deft-directive-review-cycle
 description: >-
-  Greptile bot reviewer response workflow. Use when running a review cycle on
-  a PR -- to audit process prerequisites, fetch bot findings, fix all issues
-  in a single batch commit, and exit cleanly when no P0 or P1 issues remain.
+  Greptile / bot reviewer response and PR-shepherding workflow. Use when
+  running a review cycle or babysitting a PR to merge-ready -- audit process
+  prerequisites, fetch bot findings, fix all issues in a single batch commit,
+  and exit cleanly when no P0 or P1 issues remain. Supersedes Cursor global
+  babysit on Deft-managed repos (#2261).
 ---
 <!-- AUTO-GENERATED by task packs:render -- DO NOT EDIT MANUALLY -->
 <!-- Purpose: rendered skill -->
@@ -36,8 +38,17 @@ Legend (from RFC2119): !=MUST, ~=SHOULD, ≉=SHOULD NOT, ⊗=MUST NOT, ?=MAY.
 ## When to Use
 
 - User says "review cycle", "check reviews", or "run review cycle" on a PR
+- Operator asks to **babysit**, **shepherd**, or **watch** a PR -- including the Cursor product action **babysit-pull-request-in-cloud** (#2261 / #1862 intent-routing class)
 - A bot reviewer (Greptile) has posted findings on an open PR
-- Dispatching a cloud agent to monitor and resolve PR review findings
+- Dispatching a cloud or background agent to monitor and resolve PR review findings until merge-ready
+
+## Cursor global babysit supersession (#2261)
+
+On repos with `.deft/core/` installed, **PR shepherding intent** routes here -- not the Cursor-global `babysit` skill (`~/.cursor/skills-cursor/babysit/SKILL.md`). The product action **babysit-pull-request-in-cloud** shares the babysit name but MUST chain into this review-cycle surface on Deft-managed projects.
+
+- ! Orchestrators dispatching cloud/background workers for PR shepherding MUST include `templates/agent-prompt-preamble.md` (or reference it) and mandate reading this skill as the first workflow step.
+- ! Cloud babysit workers use `worker_role: review-monitor` (or `drive-to: merge-ready` implementation workers that own the review cycle) -- not a generic babysit loop without Phase 1 audit or Step 6 exit predicate (#1259).
+- ⊗ Route **babysit-pull-request-in-cloud** to Cursor global babysit when `.deft/core/` is present -- that bypasses xBRIEF preflight, `task check`, Greptile fail-closed exit, and CHANGELOG discipline (#2261 recurrence).
 
 ## Branch-Protection Policy Guard
 
@@ -389,6 +400,8 @@ task lifecycle:event -- emit plan:approved \
 
 ## Anti-Patterns
 
+- ⊗ Route PR shepherding to Cursor global `babysit` on Deft-managed repos when `.deft/core/` is installed -- use this review-cycle skill instead (#2261)
+- ⊗ Treat a passing SLizard/Greptile check run, a non-blocking review comment, or an ad hoc fix commit as the review-cycle exit predicate -- Step 6 fail-closed all-of (#1259) and multi-reviewer registry triage (#769) still apply
 - ⊗ Push individual fix commits per finding
 - ⊗ Start fixing before analyzing ALL findings
 - ⊗ Rely on the bot to catch syntax errors in structured data files

package/skills/deft-directive-setup/SKILL.md

@@ -482,7 +482,11 @@ omit = [
 
 - ~ After Phase 2 writes `PROJECT-DEFINITION.xbrief.json`, recommend `task triage:welcome` to the user as the single chained command for picking up the v0.27 triage surface. The N3 ritual (#1143) is the consolidating onboarding step for the #1119 governance swarm verbs (`task triage:bootstrap` / `task triage:scope` / `plan.policy.wipCap` writes / `task scope:demote --batch` relief / `task triage:summary`); without it consumers must learn each verb individually from the v0.27 release notes.
 - ~ `task triage:welcome` is idempotent and detection-bound -- each phase emits an informational stderr line and skips when its precondition is already satisfied, so a re-run after a partial completion resumes cleanly. The destructive phases (subscription / `wipCap` writes, optional WIP-relief invocation) are gated by numbered-menu prompts per [`../../contracts/deterministic-questions.md`](../../contracts/deterministic-questions.md). See [`../../UPGRADING.md`](../../UPGRADING.md) `## From v0.26.x -> v0.27` for the full walkthrough.
-- ? The recommendation is informational, not a hard gate -- consumers who plan to wire triage manually MAY skip the ritual and call the individual verbs in any order; the framework defaults stay fail-open per the umbrella `#1119 §12 framework-vs-consumer-config boundary`.
+### Consumer AGENTS always-pin recommendations (#2508)
+
+! After Phase 2 completes (or when closing a greenfield bootstrap), tell the consumer that process-critical directive skills should be named in their project's AGENTS.md **unmanaged header** when false-negative risk matters — full tier definitions: [`../../docs/skill-pin-policy.md`](../../docs/skill-pin-policy.md).
+~ Recommend the default consumer pin set for lifecycle work: `deft-directive-build` (implementation), `deft-directive-pre-pr` (before PR), `deft-directive-review-cycle` (bot review loop), and `deft-directive-swarm` when they plan parallel agents. Each is referenced by skill id + `.deft/core/.agents/skills/<id>/SKILL.md` path — not by pasting skill bodies.
+⊗ Recommend pinning entire `languages/`, `deployments/`, or other framework doc packs into AGENTS.md (#2508 anti-pattern).
 
 ---
 

package/skills/deft-directive-swarm/SKILL.md

@@ -57,6 +57,8 @@ This path became first-class in #1342 (platform adapter slices 1-3) and is fully
 
 ~ **Windows + Grok Build (#1353):** When issuing shell commands via `run_terminal_command` on this platform, avoid `|`, `>`, or `2>&1` in the command string — use Python `pathlib`/`subprocess` or plain `task` targets instead to avoid wrapper leakage. See `templates/agent-prompt-preamble.md` §3.5 for the full escape hatch list.
 
+! **Windows + Cursor Task-tool console windows (#2563):** Local Cursor Task swarms on Windows are first-class. Shipped mitigations (do not regress): `windowsHide: true` (CREATE_NO_WINDOW) on engine/spawn paths, and warm-dist skip via `tasks/ts-build-fresh.cjs` so `engine:_ts-build` does not cold-rebuild when `packages/cli/dist` is current. See `templates/agent-prompt-preamble.md` §3.8. ! Default to **local** Task workers on Windows (not cloud-for-Windows). Parallel cohorts are allowed — do not force concurrency=1 for #2563. ⊗ Drop or weaken those mitigations without a replacement that keeps Windows local swarm workable.
+
 ## Prerequisites
 
 - ! `xbrief/active/` contains one or more story-level xBRIEFs with status `running`

package/skills/deft-directive-triage/SKILL.md

@@ -1,12 +1,13 @@
 ---
 name: deft-directive-triage
 description: >-
-  Triage-cache hygiene and "what's next?" queue selection -- the agent-facing
-  playbook for syncing the triage cache, classifying candidates, presenting a
-  ranked queue, walking per-item decisions (accept / reject / defer / needs-ac
-  / mark-duplicate), and auditing the session. Use when the operator asks what
-  to work on next, wants to build a cohort, work the cache, or run a triage
-  hygiene pass.
+  Triage-cache hygiene and "what's next?" work selection (ordered plan or
+  ranked queue) -- the agent-facing playbook for syncing the triage cache,
+  classifying candidates, presenting a ranked queue or binding to an active
+  plan-sequence, walking per-item decisions (accept / reject / defer /
+  needs-ac / mark-duplicate), and auditing the session. Use when the operator
+  asks what to work on next, wants to build a cohort, work the cache, or run a
+  triage hygiene pass.
 triggers:
   - triage
   - triage hygiene
@@ -26,7 +27,7 @@ triggers:
 
 # Deft Directive Triage
 
-Triage-cache hygiene + "what's next?" queue selection. Operates against the unified `.deft-cache/github-issue/` mirror (#883 Story 2) and the append-only `xbrief/.eval/candidates.jsonl` audit log (#845 Story 2); writes only via the canonical `task triage:*` verbs.
+Triage-cache hygiene + "what's next?" work selection (ordered plan or ranked queue). Operates against the unified `.deft-cache/github-issue/` mirror (#883 Story 2) and the append-only `xbrief/.eval/candidates.jsonl` audit log (#845 Story 2); writes only via the canonical `task triage:*` verbs.
 
 Legend (from RFC2119): !=MUST, ~=SHOULD, ≉=SHOULD NOT, ⊗=MUST NOT, ?=MAY.
 
@@ -38,11 +39,17 @@ Legend (from RFC2119): !=MUST, ~=SHOULD, ≉=SHOULD NOT, ⊗=MUST NOT, ?=MAY.
 
 ! Every numbered-menu prompt rendered in this skill (Phase 2 candidate selection, Phase 3 per-item decision walk) ! MUST follow [`../../contracts/deterministic-questions.md`](../../contracts/deterministic-questions.md): render the canonical numbered menu in chat unless the host UI visibly preserves numeric option labels and returns numeric selections or exact displayed option text. The final two numbered options are `Discuss` and `Back`, in that order, and the Discuss-pause semantic from the contract applies verbatim -- on `Discuss` the agent halts the in-progress sequence and resumes only on an explicit user signal.
 
+## Work selection fork (#2542 / #2402)
+
+Directive does not guess your mix: **ordered plan** (`task plan-sequence:*`) when you know the next units in order, or **ranked queue** (`task triage:queue`) when picking from the backlog. Labels bias the queue; they do not override an active plan.
+
+! Before Phase 2 on bare "what's next?", run `task plan-sequence:current`. Active sequence → that entry only; exhausted → fail closed. Explicit "what's the queue?" / "build a cohort" → Phase 2. See `commands.md` § Backlog Triage → Two paths.
+
 ## Phase 0 -- Sync
 
 ! Probe cache freshness before doing any classification or selection. Stale cache reads produce stale decisions; the gate is the contract.
 
-1. ! Run `task verify:cache-fresh` (D5 / #1127). Exit 0 -> proceed to Phase 1. Exit 1 (stale or blocked) -> refresh per the printed remediation. Exit 2 (no bootstrap) -> run `task triage:bootstrap` first.
+1. ! Run `task verify:cache-fresh` (D5 / #1127). Exit 0 -> proceed to Phase 1. Exit 1 (stale or blocked) -> refresh per the printed remediation. Exit 2 (no bootstrap) -> run `task triage:bootstrap` first. When the cache has zero entries, read paths auto-fetch from GitHub first (#2575).
 2. ~ Refresh path: `task cache:fetch-all -- --source=github-issue --repo OWNER/NAME` for an already-bootstrapped project (idempotent, TTL-aware, re-applies the #883 scanner v2 quarantine rules); `task triage:bootstrap` for a first-time seed.
 3. ~ If `xbrief/active/*.xbrief.json` references are in play, run `task triage:refresh-active` to compare cached `meta.json.fetched_at` against live upstream `updatedAt` and surface drift before the queue is rendered.
 4. ~ When the one-liner emitted by the session-start ritual carries a `[scope-drift] N` segment (D14 / #1133), run `task triage:scope-drift` to see the per-label / per-milestone breakdown of upstream signals on cached open issues that fall outside the active `plan.policy.triageScope[]` subscription. The output documents both opt-in (`task triage:subscribe -- --label=<L>`) and opt-out (`task triage:scope-drift -- --ignore-label=<L>`) paths -- pick one before walking the queue so the cohort reflects the operator's current intent rather than a stale subscription.
@@ -59,14 +66,9 @@ Legend (from RFC2119): !=MUST, ~=SHOULD, ≉=SHOULD NOT, ⊗=MUST NOT, ?=MAY.
 5. ⊗ Re-classify items already terminally decided (accept / reject / mark-duplicate) without explicit operator approval -- the audit log is append-only and supersession runs through Layer 5 (`task triage:reset <N>`), not through silent re-walks.
 6. ⊗ Block issue creation solely because no label was selected, or invent ad hoc labels outside the repository's existing label set.
 
-
-## Ordered-plan precedence (#2402)
-
-! Before queue selection on bare "what's next?", run `task plan-sequence:current`. Active sequence → that entry only; exhausted → fail closed and ask. Explicit "what's the queue?" / "build a cohort" still use Phase 2. Chaining is non-authorizing. ⊗ Reuse triage `continuationNumbers`/`continuationOrder` for ordered-plan state.
-
 ## Phase 2 -- Present
 
-! When no ordered-plan is active, render `task triage:queue` before suggesting work (#1149). Active sequence yields to the ordered-plan entry (#2402).
+! Apply the Work selection fork gate (#2542): when no ordered-plan is active, render `task triage:queue` before suggesting work (#1149). Active sequence yields to the ordered-plan entry (#2402).
 
 1. ! Run `task triage:queue --limit=N` (D11 / #1128) -- default `N=10` per the umbrella Current Shape v3 WIP cap. Output is grouped `[RESUME]` -> `[URGENT]` -> untriaged -> other; within-group ordering follows the consumer-supplied `plan.policy.triageRankingLabels[]` (framework default empty per §12 boundary), tiebroken by `updated_at` descending.
 2. ! For per-item detail, run `task triage:show <N>` -- prints the cached upstream payload, the latest triage decision, the audit timeline, and the active-xBRIEF reference flag. Exit 0 on hit, 1 on cache miss (re-sync per Phase 0).
@@ -118,6 +120,7 @@ What would you like to do with this candidate?
 ## Anti-Patterns
 
 - ⊗ Recommend a specific issue without first consulting `task triage:queue` (binding under AGENTS.md `## Cache-as-authoritative work selection (#1149)`).
+- ⊗ Conclude "nothing to do" from `xbrief/{pending,active}` scans or live GitHub reads alone — `task triage:queue` is the ranked superset (#2576).
 - ⊗ Walk the queue against a stale cache (Phase 0 gate skipped).
 - ⊗ Reimplement audit-log append / `proposed/` write inline -- the `task triage:*` verbs own those surfaces (#845, #883).
 - ⊗ Treat `defer` / `needs-ac` as terminal -- they intentionally resurface on the next pass.

package/tasks/engine-invoke.cjs

@@ -88,20 +88,23 @@ function main() {
     process.exit(2);
   }
 
+  // Command transport is one-hop: a spawned CLI may invoke Task again with a
+  // different ENGINE_CMD, which must not be shadowed by this inherited value.
+  const childEnv = { ...process.env };
+  delete childEnv.DEFT_ENGINE_CMD_JSON;
+  delete childEnv.DEFT_ENGINE_CMD;
+
+  // stdio inherit (not pipe): piped stdout/stderr deadlocks when the child emits
+  // more than the OS pipe buffer before exit — observed as greenfield smoke
+  // hanging then CI SIGTERM exit 143 with no output (#2554 / #2547).
   const result = spawnSync(execPath, execArgv, {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-    env: process.env,
+    stdio: "inherit",
+    env: childEnv,
     // Global deft/directive on Windows are .cmd shims; shell:false cannot spawn them (#2415).
     shell: mode === "global" && process.platform === "win32",
-    maxBuffer: 16 * 1024 * 1024,
+    // CREATE_NO_WINDOW: hide console windows from Cursor Task / nested shells (#2563).
+    windowsHide: true,
   });
-  if (result.stdout) {
-    process.stdout.write(result.stdout);
-  }
-  if (result.stderr) {
-    process.stderr.write(result.stderr);
-  }
   const code = result.status;
   process.exit(code === null ? 1 : code);
 }

package/tasks/engine.yml

@@ -35,13 +35,16 @@ tasks:
           // Windows native Task often has no `sh` on PATH, so Corepack.cmd was
           // invisible after #2411. Prefer a direct spawn (POSIX / real binaries);
           // fall back to shell:true so PATHEXT resolves .cmd/.exe on win32.
+          // windowsHide (#2563): CREATE_NO_WINDOW so Cursor Task shells do not
+          // flood visible cmd.exe/conhost windows on every probe/build.
+          const spawnOpts=(extra)=>({stdio:'ignore',windowsHide:true,...extra});
           const hasCmd=(name)=>{
             try{
-              execFileSync(name,['--version'],{stdio:'ignore'});
+              execFileSync(name,['--version'],spawnOpts());
               return true;
             }catch{
               try{
-                execFileSync(name,['--version'],{stdio:'ignore',shell:true});
+                execFileSync(name,['--version'],spawnOpts({shell:true}));
                 return true;
               }catch{
                 return false;
@@ -49,7 +52,7 @@ tasks:
             }
           };
           const run=(cmd,args)=>{
-            execFileSync(cmd,args,{cwd:root,stdio:'inherit',shell:true});
+            execFileSync(cmd,args,{cwd:root,stdio:'inherit',shell:true,windowsHide:true});
           };
           const trySteps=(steps)=>{
             for(const [cmd,args] of steps){
@@ -98,6 +101,10 @@ tasks:
     # ships no packages/ tree (guard false -> no-op, #2126). Git-vendored-payload
     # repos may carry a stray packages/ under .deft/core without a root `build`
     # script — source-only presence must NOT run `pnpm run build` there.
+    #
+    # Warm-dist skip (#2563): when packages/cli/dist/bin.js is newer than
+    # packages/{cli,core,types} sources, skip rebuild. Override with
+    # DEFT_FORCE_TS_BUILD=1; force-skip with DEFT_SKIP_TS_BUILD=1.
     dir: '{{.USER_WORKING_DIR}}'
     cmds:
       - |
@@ -105,6 +112,9 @@ tasks:
         if [ -f "{{.DEFT_ROOT}}/packages/cli/package.json" ] \
            && [ -f "{{.DEFT_ROOT}}/package.json" ] \
            && node -e "const fs=require('fs');const j=JSON.parse(fs.readFileSync(process.argv[1],'utf8'));process.exit(j.scripts&&j.scripts.build?0:1)" "{{.DEFT_ROOT}}/package.json"; then
+          if node "{{.TASKFILE_DIR}}/ts-build-fresh.cjs" "{{.DEFT_ROOT}}"; then
+            exit 0
+          fi
           node -e "
             const {execFileSync}=require('child_process');
             const fs=require('fs');
@@ -116,13 +126,16 @@ tasks:
             // Windows native Task often has no `sh` on PATH, so Corepack.cmd was
             // invisible after #2411. Prefer a direct spawn (POSIX / real binaries);
             // fall back to shell:true so PATHEXT resolves .cmd/.exe on win32.
+            // windowsHide (#2563): CREATE_NO_WINDOW so Cursor Task shells do not
+            // flood visible cmd.exe/conhost windows on every probe/build.
+            const spawnOpts=(extra)=>({stdio:'ignore',windowsHide:true,...extra});
             const hasCmd=(name)=>{
               try{
-                execFileSync(name,['--version'],{stdio:'ignore'});
+                execFileSync(name,['--version'],spawnOpts());
                 return true;
               }catch{
                 try{
-                  execFileSync(name,['--version'],{stdio:'ignore',shell:true});
+                  execFileSync(name,['--version'],spawnOpts({shell:true}));
                   return true;
                 }catch{
                   return false;
@@ -130,12 +143,20 @@ tasks:
               }
             };
             const run=(cmd,args)=>{
-              execFileSync(cmd,args,{cwd:root,stdio:'inherit',shell:true});
+              execFileSync(cmd,args,{cwd:root,stdio:'inherit',shell:true,windowsHide:true});
+            };
+            const markWarm=()=>{
+              try{
+                const dist=root+'/packages/cli/dist';
+                fs.mkdirSync(dist,{recursive:true});
+                fs.writeFileSync(dist+'/.deft-ts-build-stamp',new Date().toISOString());
+              }catch{}
             };
             const trySteps=(steps)=>{
               for(const [cmd,args] of steps){
                 try{
                   run(cmd,args);
+                  markWarm();
                   process.exit(0);
                 }catch{
                   // fall through to Corepack / next resolver
@@ -145,6 +166,7 @@ tasks:
             const envPm=String(process.env.DEFT_PACKAGE_MANAGER||'').trim().toLowerCase();
             if(envPm==='npm'){
               run('npm',['run',script]);
+              markWarm();
               process.exit(0);
             }
             const pin=String(pkg.packageManager||'').trim();

package/tasks/eval.yml

@@ -30,3 +30,12 @@ tasks:
       - task: :engine:invoke
         vars:
           ENGINE_CMD: 'eval:report --project-root "{{.USER_WORKING_DIR}}" {{.CLI_ARGS}}'
+
+  triggers:
+    desc: "Trigger routing coverage for AGENTS.md / Skills Index (#1586). Offline skill-pi-trigger-eval compatible eval over evals/trigger-cases.jsonl vs REFERENCES.md. -- task eval:triggers [-- --json] [--project-root PATH]"
+    deps:
+      - task: :engine:_ts-build
+    cmds:
+      - task: :engine:invoke
+        vars:
+          ENGINE_CMD: 'eval:triggers --project-root "{{.USER_WORKING_DIR}}" {{.CLI_ARGS}}'

package/tasks/ts-build-fresh.cjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Decide whether engine:_ts-build can skip `pnpm run build` (#2563).
+ *
+ * Exit codes:
+ *   0 — dist is fresh enough (or DEFT_SKIP_TS_BUILD=1); skip rebuild
+ *   1 — rebuild required (missing dist, newer sources, or DEFT_FORCE_TS_BUILD=1)
+ *   2 — usage / config error
+ *
+ * Warm-dist skip avoids a full `tsc -b` (and its nested shell:true spawns) on
+ * every `task <verb>` when packages/cli/dist/bin.js is already up to date.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const SKIP_DIRS = new Set(["node_modules", "dist", "coverage", ".git"]);
+
+function walkSourceFiles(dir, out) {
+  if (!fs.existsSync(dir)) return;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const ent of entries) {
+    const full = path.join(dir, ent.name);
+    if (ent.isDirectory()) {
+      if (SKIP_DIRS.has(ent.name)) continue;
+      walkSourceFiles(full, out);
+      continue;
+    }
+    if (ent.isFile() && /\.(?:ts|tsx|json)$/.test(ent.name) && !ent.name.endsWith(".d.ts")) {
+      out.push(full);
+    }
+  }
+}
+
+function main() {
+  const root = process.argv[2];
+  if (!root) {
+    console.error("deft: ts-build-fresh usage: ts-build-fresh.cjs <DEFT_ROOT>");
+    process.exit(2);
+  }
+  if (process.env.DEFT_FORCE_TS_BUILD === "1") {
+    process.exit(1);
+  }
+  if (process.env.DEFT_SKIP_TS_BUILD === "1") {
+    process.exit(0);
+  }
+
+  const distDir = path.join(root, "packages", "cli", "dist");
+  const bin = path.join(distDir, "bin.js");
+  const stamp = path.join(distDir, ".deft-ts-build-stamp");
+  if (!fs.existsSync(bin)) {
+    process.exit(1);
+  }
+  // Prefer the post-build stamp (#2563): `tsc -b` incremental often leaves
+  // bin.js mtime unchanged even after a successful build when sources are
+  // newer than a previous emit. The stamp is written only after a completed
+  // engine:_ts-build, so it is the authoritative "warm dist" marker.
+  const marker = fs.existsSync(stamp) ? stamp : bin;
+  const markerMtime = fs.statSync(marker).mtimeMs;
+  const candidates = [];
+
+  for (const pkg of ["cli", "core", "types"]) {
+    const pkgRoot = path.join(root, "packages", pkg);
+    if (!fs.existsSync(pkgRoot)) continue;
+    walkSourceFiles(path.join(pkgRoot, "src"), candidates);
+    for (const name of ["package.json", "tsconfig.json", "tsconfig.build.json"]) {
+      const fp = path.join(pkgRoot, name);
+      if (fs.existsSync(fp)) candidates.push(fp);
+    }
+  }
+  for (const name of ["package.json", "tsconfig.json", "tsconfig.base.json", "pnpm-workspace.yaml"]) {
+    const fp = path.join(root, name);
+    if (fs.existsSync(fp)) candidates.push(fp);
+  }
+
+  for (const file of candidates) {
+    try {
+      if (fs.statSync(file).mtimeMs > markerMtime) {
+        process.exit(1);
+      }
+    } catch {
+      process.exit(1);
+    }
+  }
+  process.exit(0);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { walkSourceFiles };

package/tasks/verify.yml

@@ -415,6 +415,16 @@ tasks:
         vars:
           ENGINE_CMD: 'verify:eval-health-relocation --project-root "{{.USER_WORKING_DIR}}" {{.CLI_ARGS}}'
 
+  eval-triggers-relocation:
+    desc: "Fail-closed eval:triggers gate when AGENTS.md / REFERENCES.md / trigger cases change (#1586). Skips (exit 0) when the diff does not touch trigger-routing homes. -- task verify:eval-triggers-relocation [-- --base-ref <ref> | --staged] [--quiet]"
+    dir: '{{.USER_WORKING_DIR}}'
+    deps:
+      - task: :engine:_ts-build
+    cmds:
+      - task: :engine:invoke
+        vars:
+          ENGINE_CMD: 'verify:eval-triggers-relocation --project-root "{{.USER_WORKING_DIR}}" {{.CLI_ARGS}}'
+
   agents-md-advisory:
     desc: "ADVISORY (never fail-closing) consumer AGENTS.md legibility signal (#2155). Counts the UNMANAGED (project-authored) region only -- the framework-owned managed section is excluded -- and compares it against the SOFT, operator-adjustable budget plan.policy.agentsMdAdvisory.unmanagedSoftMaxLines (generous default when unset). Consumer companion to the maintainer-only #645 ratchet; deliberately NOT a check:consumer dependency (advise->observe->enforce per #1419). Default posture ALWAYS exits 0; the opt-in --enforce flag promotes an over-budget region to a hard cap (exit 1). Raising the field is the documented, no-friction way to accept growth and silence the nudge."
     dir: '{{.USER_WORKING_DIR}}'

package/templates/agent-prompt-preamble.md

@@ -211,6 +211,24 @@ PYTEST_ADDOPTS="--basetemp=$(mktemp -d)/pt" task check
 
 A clean result under an isolated basetemp is attributable to your change, not to the ambient shared-`/tmp` race. Do NOT point `--basetemp` at a static path shared across workers -- that re-introduces the collision. Solo / single-run invocations on a private worktree do not require this, but it is harmless to apply unconditionally.
 
+## 3.8 Windows Cursor Task-tool console windows (#2563)
+
+On Windows, Cursor Task-tool local subagents historically opened a visible `cmd.exe` / `conhost` window per shell turn. Framework source checkouts amplified this when every `task <verb>` cold-ran `engine:_ts-build` → `pnpm`/`tsc` via `shell: true`.
+
+**Shipped mitigations (keep; do not regress):**
+
+- `windowsHide: true` (CREATE_NO_WINDOW) on engine invoke / package-manager probe / `spawnCommandText` paths
+- Warm-dist skip via `tasks/ts-build-fresh.cjs` so `_ts-build` does not rebuild when `packages/cli/dist` is current (override with `DEFT_FORCE_TS_BUILD=1` / `DEFT_SKIP_TS_BUILD=1`)
+
+**Directive rule for orchestrators on Windows:**
+
+- ! Use **local** Cursor Task swarm workers as the default dispatch path — same as other platforms. Do not route to cloud solely because the host is Windows.
+- ! Parallel local cohorts are allowed; do not force concurrency=1 because of #2563.
+- ~ Prefer the normal warm `task` / `dist/bin.js` path; avoid unnecessary `DEFT_FORCE_TS_BUILD=1` across a parallel cohort.
+- ⊗ Drop or weaken the #2563 `windowsHide` / warm-dist mitigations without a replacement that keeps Windows local swarm workable.
+
+Reference: issue #2563; swarm skill Platform Requirements; env scrub + stdio inherit for nested Task recursion (#2554 / #2438).
+
 ## 4. pre-pr and review-cycle skills
 
 Before pushing any branch:
@@ -225,8 +243,55 @@ Anti-pattern: pushing without pre-pr and relying on Greptile to find issues. Tha
 The active host harness may expose its own review-labeled surfaces. On Cursor these are the `bugbot` and `security-review` Task **subagent types** and the `review-bugbot` / `review-security` **skills**; other harnesses may ship equivalents. A generic operator request to "review" / "get this reviewed" / "use sub-agents for reviews" must NOT be routed to those host-native tools as the review of record.
 
 - ! Route ALL review work through the canonical `skills/deft-directive-review-cycle/SKILL.md` surface. Map a generic review request to the review cycle **by intent**, not by literal keyword -- "review this", "get this reviewed", and "use sub-agents for reviews" all mean run `deft-directive-review-cycle` (extends the #1862 / #2261 intent-routing fix).
-- ~ Host review tools (Cursor `bugbot` / `security-review` subagent types, `review-bugbot` / `review-security` skills, or any future host equivalent) MAY be folded in as *advisory* finding sources INSIDE the review cycle -- the #2019 harness-aware-reviewer path -- with their findings batched alongside the Greptile / bot findings the cycle already processes.
-- ⊗ Substitute a host-native review subagent type or `review-*` skill for `deft-directive-review-cycle` as the review surface. The host tools are advisory inputs folded into the cycle, never a replacement for it. Reaching for them on a bare "review" request is the 3rd recurrence of the #1862 / #2261 wrong-review-surface class (see also #2019, #2018).
+- ! Map **PR shepherding intent** the same way: `babysit`, `babysit this PR`, `shepherd`, `watch the PR`, and the Cursor product action **babysit-pull-request-in-cloud** all mean run `deft-directive-review-cycle` on Deft-managed repos (`.deft/core/` installed) -- NOT the Cursor-global `babysit` skill (`~/.cursor/skills-cursor/babysit/SKILL.md`) (#2261).
+- ~ Host review tools (Cursor `babysit` / `bugbot` / `security-review` subagent types, `review-bugbot` / `review-security` skills, or any future host equivalent) MAY be folded in as *advisory* finding sources INSIDE the review cycle -- the #2019 harness-aware-reviewer path -- with their findings batched alongside the Greptile / bot findings the cycle already processes.
+- ⊗ Substitute a host-native review subagent type, Cursor global `babysit`, or `review-*` skill for `deft-directive-review-cycle` as the review surface. The host tools are advisory inputs folded into the cycle, never a replacement for it. Reaching for them on a bare "review" or "babysit" request is the #1862 / #2261 wrong-review-surface class (see also #2019, #2018).
+
+## 4.6 Cloud PR-shepherd dispatch -- review-monitor worked example (#2261)
+
+When an operator triggers **babysit-pull-request-in-cloud** (or equivalent PR-shepherding intent) on a Deft-managed repo, the orchestrator MUST dispatch a **review-monitor** worker with this preamble (or a reference to `templates/agent-prompt-preamble.md`) and an explicit mandate to read `skills/deft-directive-review-cycle/SKILL.md` before any PR mutation.
+
+Worked example (cloud background review-monitor on PR #1037):
+
+```markdown
+## Allocation context
+
+- dispatch_kind: solo
+- allocation_plan_id: null
+- batching_rationale: null
+- cohort_vbriefs: []
+- operator_approval_evidence: operator selected babysit-pull-request-in-cloud 2026-07-03
+
+## Worker metadata
+
+- dispatch_provider: cursor-cloud-agent
+- worker_role: review-monitor
+- selected_backend: cursor-cloud
+- routing_policy: null
+- resolved_model: null
+- model_source: harness-default explicit
+
+## Runtime and GitHub auth mode
+
+- runtime_mode: cloud-headless
+- github_auth_mode: injected-token
+
+## Unit of work
+
+drive-to: merge-ready on PR #1037 (repo: deftai/deftvisage, branch: fix/visage-repo-org-scoping)
+
+## Mandates
+
+1. First tool call: read AGENTS.md; confirm Deft alignment.
+2. Read `templates/agent-prompt-preamble.md` (binding) and `skills/deft-directive-review-cycle/SKILL.md` end-to-end -- NOT `~/.cursor/skills-cursor/babysit/SKILL.md`.
+3. Run review-cycle Phase 1 process audit before the fix loop; batch Phase 1 + Phase 2 fixes per review-cycle discipline.
+4. Poll terminal verdict via `task pr:watch -- <N>` when waiting on Greptile/SLizard (#1056).
+5. Exit only on review-cycle Step 6 fail-closed all-of (#1259) -- ad hoc SLizard P2 fixes without the exit predicate are insufficient.
+
+DONE: include PR URL, role review-monitor, and whether Step 6 CLEAN was reached.
+```
+
+Anti-pattern: dispatching `Task(environment=cloud)` with only the Cursor global babysit skill attached and no preamble / `deft-directive-review-cycle` path -- that is the #2261 recurrence class.
 
 ## 5. REST-by-default for read-only gh calls
 

package/templates/agents-consumer-header.md

@@ -10,6 +10,7 @@ Scoped work, ranked queue, and tracked bugs live in authoritative sources — no
 
 - Project identity → `xbrief/PROJECT-DEFINITION.xbrief.json`
 - Scoped work → `xbrief/` lifecycle folders
+- Work selection → default ranked queue (`deft triage:queue`); lock a short ordered plan (`deft plan-sequence:set`) when you want bounded delivery — see `deft/commands.md` § Backlog Triage → Two paths
 - Ranked queue → `deft triage:queue` / `deft triage:welcome`
 - Tracked bugs → GitHub issues
 

package/templates/agents-entry.md

@@ -27,9 +27,9 @@ Legacy `vbrief/` read-accepted; `deft migrate:xbrief` for `xbrief/` (v0.6→v0.8
 
 ## Cache-as-authoritative work selection (#1149)
 
-! "what next?" → ordered-plan first (#2402 / `deft plan-sequence:*`); else `deft triage:queue --limit=10` (D11) — `commands.md` § Backlog Triage.
+! "what next?" → two work-selection modes (#2402): **ordered plan** (`deft plan-sequence:*`) or **ranked queue** (`deft triage:queue`) — `commands.md` § Backlog Triage → Two paths. ordered-plan first; else `deft-directive-triage` + `deft triage:queue --limit=10` (D11). Empty cache auto-populates from GitHub (#2575).
 
-⊗ Recommend work without queue/plan consult; ⊗ widen past an exhausted plan.
+⊗ Recommend work without queue/plan consult; ⊗ widen past an exhausted plan; ⊗ conclude "nothing to do" from `xbrief/{pending,active}` folder scans or GitHub-only reads without `deft triage:queue` (#2576).
 
 ## Umbrella status reading (#1152 / #2066)
 
@@ -57,9 +57,15 @@ Legacy `vbrief/` read-accepted; `deft migrate:xbrief` for `xbrief/` (v0.6→v0.8
 
 ! **Skills Index** (Level-0) in `.deft/core/REFERENCES.md` — scan before improvising; read `SKILL.md` only on index match. `welcome` / `onboard triage` → `deft triage:welcome --onboard` (N3 / #1143); lessons → packs:slice.
 
+## Skill pin policy (#2508)
+
+! Process-critical skills with false-negative risk MUST be named in AGENTS.md (always-pin tier) — tier definitions: `.deft/core/docs/skill-pin-policy.md` (#2508).
+! **Default always-pins:** `deft-directive-build`, `deft-directive-pre-pr`, `deft-directive-review-cycle`, `deft-directive-swarm` — read each `SKILL.md` when that work type starts.
+⊗ Pin entire language packs, deployment docs, or framework bulk into AGENTS.md — pins are for false-negative-sensitive process gates only (#2508).
+
 ## Review-surface precedence (#2308)
 
-! Route review through `deft-directive-review-cycle` — `.deft/core/.agents/skills/deft-directive-review-cycle/SKILL.md`; host `bugbot` / `security-review` / `review-*` advisory-only (#2308).
+! Route PR shepherding / review work through `deft-directive-review-cycle` — `.deft/core/.agents/skills/deft-directive-review-cycle/SKILL.md`; host `babysit` / `bugbot` / `security-review` advisory-only (#2308 / #2261).
 
 ## Value feedback and attribution (#1709)
 
@@ -67,7 +73,7 @@ Legacy `vbrief/` read-accepted; `deft migrate:xbrief` for `xbrief/` (v0.6→v0.8
 
 ## Eval and framework health (#1703)
 
-! `deft eval:health` when orienting or after gate/policy changes (Tier 0; 4-hour debounce). Release: `deft eval:run` / `deft eval:report` (#1703).
+! `deft eval:health` when orienting or after gate/policy changes (Tier 0; 4-hour debounce). Release: `deft eval:run` / `deft eval:report`; skill routing: `deft eval:triggers` (#1586 / #1703).
 
 ## Branch policy & branch verification
 
@@ -79,7 +85,7 @@ Legacy `vbrief/` read-accepted; `deft migrate:xbrief` for `xbrief/` (v0.6→v0.8
 
 ## Contextual guardrails (runtime-detect lazy-load)
 
-! Lazy-load `.deft/core/scm/github.md` before risky ops (#2157 / #2369): PowerShell → `deft verify:encoding` (#798); TS capture (#1366); cascade → `deft pr:wait-mergeable-and-merge` (#1369); SCM → `deft verify:scm-boundary` (#884).
+! Detect OS/shell; use portable syntax or explicit shell (#2568). `.deft/core/scm/github.md` (#2157/#2369): PS→`deft verify:encoding`; TS capture; cascade→`deft pr:wait-mergeable-and-merge`; SCM→`deft verify:scm-boundary`.
 
 ## Development Process