@deftai/directive-content 0.76.0 → 0.78.0

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

@@ -25,6 +25,10 @@ Legend (from RFC2119): !=MUST, ~=SHOULD, ≉=SHOULD NOT, ⊗=MUST NOT, ?=MAY.
 - User says "build this", "implement the spec", or "start building"
 - Resuming a partially-built project that has story xBRIEFs in `xbrief/active/`
 
+## Ordered-plan / cohort exhaustion (#2402)
+
+! When processing an approved multi-story cohort or an active ordered-plan sequence, stop after the final approved entry. Do not promote or dispatch adjacent stories from queue intuition. Continuation language advances only within the approved order; skill-chaining is non-authorizing.
+
 ## Step 0 -- Implementation Preflight (#810)
 
 - ! Before starting any new implementation story or switching from one story to another, MUST run `git status --short --branch`.

package/skills/deft-directive-pre-pr/SKILL.md

@@ -35,6 +35,20 @@ or invoke `task verify:branch`. Pre-PR is the last gate before push, so a stale
 
 ! Every numbered-menu prompt rendered in this skill (per-finding decision menus in Phase 4 Diff, the Phase 5 Loop restart-vs-exit gate) MUST follow [`../../contracts/deterministic-questions.md`](../../contracts/deterministic-questions.md): the final two numbered options MUST be `Discuss` and `Back`, in that order. The Discuss-pause semantic is documented verbatim there -- implicit resumption is forbidden.
 
+
+## Ordered-plan target gate (#2402)
+
+! Before opening or pushing a PR, when an ordered-plan sequence may be active, verify the PR target matches the current authorized entry:
+
+```
+task verify:plan-sequence -- --target-kind pr --target <issue-or-entry-id>
+```
+
+- ! Exit non-zero → fail closed; do not open an unauthorized PR.
+- ! Exit 0 with "skipped (no active ordered-plan sequence)" → proceed under normal pre-PR rules.
+- ! After the PR's review cycle completes successfully, run `task plan-sequence:advance` so "next" resolves to the following entry (or exhausted).
+- ⊗ Treat skill-chaining or "what's next?" as permission to open a PR outside the current sequence entry.
+
 ## When to Use
 
 - ! Before pushing a branch for PR creation

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 -->
@@ -21,11 +23,32 @@ Legend (from RFC2119): !=MUST, ~=SHOULD, ≉=SHOULD NOT, ⊗=MUST NOT, ?=MAY.
 
 ! This skill requires **GitHub** as the SCM platform and the **GitHub CLI (`gh`)** to be installed and authenticated. PR comment fetching, check-run queries, and review submission all depend on `gh`.
 
+
+## Ordered-plan exit / advance (#2402)
+
+! When the review-cycle exit condition is met (no P0/P1 remaining / CLEAN verdict):
+
+1. Return control to the caller — do **not** discover adjacent backlog work.
+2. If an ordered-plan sequence is active and this PR matched the current entry, run `task plan-sequence:advance`.
+3. If another entry remains, the caller may continue **only** to that entry (one unit).
+4. If the sequence is exhausted, stop and ask. Do not open another PR from queue intuition or chaining text.
+
+⊗ Exit the review cycle into `task triage:queue` or an unrelated PR without fresh operator approval.
+
 ## 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
 
@@ -377,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 storm (#2563):** Local Cursor Task subagents on Windows have frozen the host by flooding visible `cmd.exe` / `conhost` windows (observed with both parallel and serial Task agents; in-parent work stayed stable). Prefer one of: (1) in-parent / serial monitor-owned implementation, (2) cloud workers, or (3) after the #2563 mitigations (`windowsHide` + warm-dist skip in `engine:_ts-build`) are on the branch under test, keep local Task concurrency at **1** and prefer `pnpm exec` / warm `dist/bin.js` over repeated cold `task` rebuilds. See `templates/agent-prompt-preamble.md` §3.8. ⊗ Launch a wide parallel local Cursor Task cohort on Windows without that mitigation or an explicit operator acceptance of host-freeze risk.
+
 ## Prerequisites
 
 - ! `xbrief/active/` contains one or more story-level xBRIEFs with status `running`
@@ -76,6 +78,13 @@ This path became first-class in #1342 (platform adapter slices 1-3) and is fully
 ⊗ Re-prompt the operator for per-phase batching approval, or run the interactive promote-fill loop (Step 0a -- 0d), when a pre-approved cohort is supplied via `task swarm:launch` -- the headless path's single #1378 consent already authorizes the batch, and re-prompting mid-cohort violates the all-or-nothing dispatch-envelope rule (#954).
 ? The interactive queue-driven path (Step 0 below) remains the DEFAULT when no pre-approved cohort is supplied; the headless fast-path is the opt-in low-ceremony route for a cohort the operator has already curated and approved upstream.
 
+
+### Ordered-plan / cohort exhaustion (#2402)
+
+! When the approved cohort (or an active `plan-sequence` of kind `swarm`/`cohort`/`delivery`) is exhausted, stop. Do not promote, queue, open, or dispatch adjacent work after the final approved entry unless the operator explicitly authorizes a new cohort or queue-driven selection.
+
+! Continuation language ("next", "proceed") advances only within the approved cohort order — not into triage-queue remainder.
+
 ### Step 0: Queue-driven cohort selection (#1142 / N2)
 
 ! Phase 0 is queue-driven: consult the triage cache (D2 / #1122 + D11 / #1128) for the ranked promotion candidates, then fill the WIP cap. Do NOT pick the cohort by hand from `xbrief/pending/` or `xbrief/active/` -- the queue is the canonical record of "what's next?" per AGENTS.md `## Cache-as-authoritative work selection (#1149)`. The four sub-phases below run in canonical order; existing Step 0.5 (lifecycle bridge) and Steps 1-5 (readiness / blockers / allocation / present / approval) proceed unchanged after Phase 0d.

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

@@ -59,9 +59,14 @@ 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
 
-! Render the ranked queue before suggesting any specific issue. The cache-as-authoritative rule in AGENTS.md (`## Cache-as-authoritative work selection (#1149)`) is binding: the agent ! MUST consult `task triage:queue` and surface the result before proposing work from memory.
+! 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).

package/tasks/engine-invoke.cjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Spawn the deft CLI from DEFT_ENGINE_CMD without shell-interpolating operator
+ * text (#2547). go-task forwards user args into ENGINE_CMD; apostrophes in
+ * --summary and similar free-text flags must not break mvdan/sh parsing.
+ *
+ * Lives under tasks/ (not repo-root scripts/) so @deftai/directive-content
+ * prepack ships it beside tasks/engine.yml (#2022 Phase 3).
+ */
+
+const { spawnSync } = require("node:child_process");
+
+/** Minimal POSIX-ish shell word splitter (double/single quotes, escapes). */
+function shellSplit(input) {
+  const out = [];
+  let cur = "";
+  let quote = null;
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i];
+    if (quote) {
+      if (c === quote) {
+        quote = null;
+        continue;
+      }
+      if (c === "\\" && quote === '"' && i + 1 < input.length) {
+        cur += input[++i];
+        continue;
+      }
+      cur += c;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      quote = c;
+      continue;
+    }
+    if (/\s/.test(c)) {
+      if (cur) {
+        out.push(cur);
+        cur = "";
+      }
+      continue;
+    }
+    cur += c;
+  }
+  if (cur) {
+    out.push(cur);
+  }
+  return out;
+}
+
+function main() {
+  const mode = process.argv[2];
+  const target = process.argv[3];
+  let cmdLine = "";
+  if (process.env.DEFT_ENGINE_CMD_JSON) {
+    try {
+      cmdLine = JSON.parse(process.env.DEFT_ENGINE_CMD_JSON);
+    } catch {
+      console.error("deft: DEFT_ENGINE_CMD_JSON is not valid JSON");
+      process.exit(2);
+    }
+  } else {
+    cmdLine = String(process.env.DEFT_ENGINE_CMD || "");
+  }
+  cmdLine = cmdLine.trim();
+  const argv = shellSplit(cmdLine);
+  if (argv.length === 0) {
+    console.error("deft: DEFT_ENGINE_CMD is empty");
+    process.exit(2);
+  }
+  if (!mode || !target) {
+    console.error("deft: engine-invoke usage: engine-invoke.cjs <vendored|global> <bin-or-cli>");
+    process.exit(2);
+  }
+
+  let execPath;
+  let execArgv;
+  if (mode === "vendored") {
+    execPath = process.execPath;
+    execArgv = [target, ...argv];
+  } else if (mode === "global") {
+    execPath = target;
+    execArgv = argv;
+  } else {
+    console.error(`deft: engine-invoke unknown mode ${JSON.stringify(mode)}`);
+    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, {
+    stdio: "inherit",
+    env: childEnv,
+    // Global deft/directive on Windows are .cmd shims; shell:false cannot spawn them (#2415).
+    shell: mode === "global" && process.platform === "win32",
+    // CREATE_NO_WINDOW: hide console windows from Cursor Task / nested shells (#2563).
+    windowsHide: true,
+  });
+  const code = result.status;
+  process.exit(code === null ? 1 : code);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { shellSplit };

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();
@@ -171,6 +193,11 @@ tasks:
     # Run from the operator project root so deft verbs resolve USER_WORKING_DIR
     # correctly; without this, included engine.yml defaults cwd to tasks/ (#2022).
     dir: '{{.USER_WORKING_DIR}}'
+    # Operator free-text (e.g. release --summary with apostrophes) must not be
+    # interpolated into the shell script body — JSON env transport + argv-spawn in
+    # tasks/engine-invoke.cjs (#2547). Avoids shell parse breaks for `'` and `\`.
+    env:
+      DEFT_ENGINE_CMD_JSON: '{{ .ENGINE_CMD | toSlash | toJson }}'
     cmds:
       - |
         set -eu
@@ -197,10 +224,9 @@ tasks:
               }
             " "$root_pkg" || exit $?
           fi
-          node "$bin" {{.ENGINE_CMD}}
+          node "{{.TASKFILE_DIR}}/engine-invoke.cjs" vendored "$bin"
         elif [ "$is_buildable_source" = 1 ]; then
-          engine_cmd='{{.ENGINE_CMD}}'
-          first_token="${engine_cmd%% *}"
+          first_token=$(node -e "process.stdout.write(JSON.parse(process.env.DEFT_ENGINE_CMD_JSON||'\"\"').split(/\\s+/)[0]||'')")
           is_runtime_verb=0
           case " ${first_token} " in
             " session:start "|" session-start "|\
@@ -245,7 +271,7 @@ tasks:
                 console.error('deft: using global '+cli+' ('+gv+'); source checkout is v'+srcVer+' — run task build for a local engine match.');
               }
             " "{{.DEFT_ROOT}}" "$global_cli" >&2 || true
-            "$global_cli" {{.ENGINE_CMD}}
+            node "{{.TASKFILE_DIR}}/engine-invoke.cjs" global "$global_cli"
           else
             echo "deft: CLI artifact missing at {{.DEFT_ROOT}}/packages/cli/dist/bin.js" >&2
             if [ "$is_runtime_verb" = 1 ]; then
@@ -257,9 +283,9 @@ tasks:
             exit 2
           fi
         elif command -v deft >/dev/null 2>&1; then
-          deft {{.ENGINE_CMD}}
+          node "{{.TASKFILE_DIR}}/engine-invoke.cjs" global deft
         elif command -v directive >/dev/null 2>&1; then
-          directive {{.ENGINE_CMD}}
+          node "{{.TASKFILE_DIR}}/engine-invoke.cjs" global directive
         else
           echo "deft: neither {{.DEFT_ROOT}}/packages/cli/dist/bin.js nor a global deft command is available." >&2
           echo "  Install with: npm i -g @deftai/directive" >&2

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/plan-sequence.yml

@@ -0,0 +1,47 @@
+version: '3'
+
+# tasks/plan-sequence.yml -- ordered-plan continuation boundary (#2402)
+
+vars:
+  DEFT_ROOT: '{{joinPath .TASKFILE_DIR ".."}}'
+
+tasks:
+  set:
+    desc: "Set the active ordered-plan sequence from --file JSON (#2402)"
+    dir: '{{.USER_WORKING_DIR}}'
+    deps:
+      - task: :engine:_ts-build
+    cmds:
+      - task: :engine:invoke
+        vars:
+          ENGINE_CMD: 'plan-sequence set --project-root "{{.USER_WORKING_DIR}}" {{.CLI_ARGS}}'
+
+  current:
+    desc: "Show the current ordered-plan entry (#2402)"
+    dir: '{{.USER_WORKING_DIR}}'
+    deps:
+      - task: :engine:_ts-build
+    cmds:
+      - task: :engine:invoke
+        vars:
+          ENGINE_CMD: 'plan-sequence current --project-root "{{.USER_WORKING_DIR}}" {{.CLI_ARGS}}'
+
+  clear:
+    desc: "Clear the active ordered-plan sequence (#2402)"
+    dir: '{{.USER_WORKING_DIR}}'
+    deps:
+      - task: :engine:_ts-build
+    cmds:
+      - task: :engine:invoke
+        vars:
+          ENGINE_CMD: 'plan-sequence clear --project-root "{{.USER_WORKING_DIR}}" {{.CLI_ARGS}}'
+
+  advance:
+    desc: "Mark current entry complete and advance the ordered-plan index (#2402)"
+    dir: '{{.USER_WORKING_DIR}}'
+    deps:
+      - task: :engine:_ts-build
+    cmds:
+      - task: :engine:invoke
+        vars:
+          ENGINE_CMD: 'plan-sequence advance --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

@@ -242,6 +242,16 @@ tasks:
         vars:
           ENGINE_CMD: 'verify-session-ritual --project-root "{{.USER_WORKING_DIR}}" {{.CLI_ARGS}}'
 
+  plan-sequence:
+    desc: "Fail-closed ordered-plan target check (#2402). Flags: --target-kind <kind> --target <id> / --json. Skips (exit 0) when no active sequence."
+    dir: '{{.USER_WORKING_DIR}}'
+    deps:
+      - task: :engine:_ts-build
+    cmds:
+      - task: :engine:invoke
+        vars:
+          ENGINE_CMD: 'verify-plan-sequence --project-root "{{.USER_WORKING_DIR}}" {{.CLI_ARGS}}'
+
   tools:
     desc: "Detect required Deft host tools and print install or manual guidance (#1187). Flags: --install / --yes / --json"
     dir: '{{.USER_WORKING_DIR}}'
@@ -405,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}}'