dw-kit 1.9.3 → 1.10.0

package/.claude/rules/dw.md

@@ -1,7 +1,7 @@
 # dw Workflow (consolidated)
 
 Config: `.dw/config/dw.config.yml`
-Full methodology: `.dw/core/` (WORKFLOW · THINKING · QUALITY · ROLES · PILLARS)
+Full methodology: `.dw/core/` (WORKFLOW · THINKING · QUALITY · ROLES · HARNESS · AGENTS · PILLARS)
 
 ---
 
@@ -37,6 +37,17 @@ Default when unsure: `standard`.
 
 ---
 
+## Trust Mode & Overnight Autopilot (ADR-0022/0023)
+
+**Off by default** — every `dw:flow` gate is manual unless opted in.
+
+- **Trust Mode** — per-gate auto-approval for `dw:flow` convenience gates (scope/plan/changes). Safety hard-stops never relax (Guards, GATE D on a Critical finding, GATE B). Config `workflow.trust.{enabled,profile,auto_approve,max_auto_subtasks,require_evidence}`; one-shot `/dw:flow --trust`. Profiles: `solo-night`, `reviewed-team`.
+- **Overnight Autopilot** — `dw goal --auto=full` + Trust Mode (scheduled by your own cron/CI; recipe `.dw/core/templates/autopilot-cron.sh`). Safe-park on ambiguity, budget-bounded, **stop-before-push**.
+- **CLI:** `dw trust status|gate` · `dw autopilot preflight|postflight` · `dw overnight digest`.
+- Methodology behind it: `.dw/core/HARNESS.md` (multi-agent quality patterns).
+
+---
+
 ## Session Start
 
 1. Read `.dw/tasks/ACTIVE.md` — single source of truth for team state
@@ -97,11 +108,11 @@ dw agent release <claim-id>               # clean exit
 
 All dw skills invoke via `/dw:{name}` (colon namespace separator).
 
-Core workflow: `/dw:flow` · `/dw:task-init` · `/dw:research` · `/dw:plan` · `/dw:execute` · `/dw:commit` · `/dw:handoff`
+Core workflow: `/dw:flow` (`--trust` for Trust Mode gates) · `/dw:task-init` · `/dw:research` · `/dw:plan` · `/dw:execute` · `/dw:commit` · `/dw:handoff`
 
 `/dw:plan` includes **Quick Debate** (red/blue self-critique): default ON for `thorough`, auto-trigger on high-stakes signals for `standard`, off for `quick`. Override via `--debate` / `--no-debate` / `--debate-deep`.
 
-Goals (ADR-0010/0016): `/dw:goal` (outcome-driven pursuit loop — drive Goal tới KR, leo thang tư duy khi kẹt; `--auto` long-horizon) · `/dw:goal-sync` (reactive sync khi human pivot)
+Goals (ADR-0010/0016): `/dw:goal` (outcome-driven pursuit loop — drive Goal tới KR, leo thang tư duy khi kẹt; `--auto` long-horizon; `--auto=full` + Trust Mode = overnight autopilot, ADR-0023) · `/dw:goal-sync` (reactive sync khi human pivot)
 
 Decisions: `/dw:decision [title]` — create ADR
 

package/.claude/skills/dw-flow/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: dw:flow
 description: "Orchestrator: chạy toàn bộ workflow từ đầu đến cuối cho một task, tự động kết nối các phases, dừng tại các human checkpoints để confirm/feedback. Mạnh nhất khi bạn muốn AI tự drive cả task."
-argument-hint: "[task-name] hoặc DW_DEPTH=[depth] [task-name]"
+argument-hint: "[task-name] [--trust | --trust=scope,plan,changes] hoặc DW_DEPTH=[depth] [task-name]"
 ---
 
 # dw-flow — Full Task Workflow Orchestrator
@@ -113,9 +113,42 @@ Khi đọc và follow bất kỳ SKILL.md nào bên dưới, áp dụng các quy
 
 ---
 
+## Trust Mode (ADR-0022) — auto-approve convenience gates
+
+Trust Mode lets the user pre-authorize *convenience* gates so flow runs with less (or no) stopping. **OFF by default** — when off, behave exactly as before (stop at every gate).
+
+**At each gate, BEFORE stopping, ask the CLI for a deterministic decision:**
+
+```bash
+dw trust gate <name> [--trust "$FLAG"] [--task <task>] [--critical] [--evidence '<json>']
+#   <name>: scope (GATE A/Q1) · plan (GATE C) · changes (GATE D/Q2) · arch (GATE B)
+#   --trust: pass the run's --trust flag value if the user gave one (true | "scope,plan")
+#   --task:  the task name (recorded in the audit event)
+#   --critical: pass when GATE D and a Critical review finding exists
+#   --evidence: PREFERRED for GATE D — the basis (EVD verify), e.g.
+#               '{"tests":{"passed":385,"failed":2,"exit":0},"review":{"critical":0,"warning":1},"diff":{"files":2,"insertions":41,"deletions":7,"within_scope":true}}'
+#               When evidence is supplied, the CLI derives Critical/red-tests from it (stronger than --critical).
+# exit 0  → AUTO-APPROVE this gate
+# exit 10 → MANUAL stop required (show the gate as usual)
+```
+
+- **exit 0 (auto-approve):** do NOT stop. Print one line `⚡ auto-approved GATE <X> (trust) — <reason>` and continue. The CLI records the `gate_auto_approved` audit event (with your evidence) — you do NOT log it by hand.
+- **exit 10 (manual):** show the gate normally and wait, exactly as today.
+
+> **Honesty note (enforcement model):** `arch`/GATE B and the Guard hooks are *structural* — they can't be relaxed. The **Critical-on-changes** stop is *cooperative*: it only fires if you pass `--critical` or (better) an `--evidence` object that shows the real `review.critical` count. Always pass evidence for GATE D so the stop doesn't depend on you remembering a flag. Evidence is evaluated **only for GATE D (`changes`)** — it has no effect on `scope`/`plan` gates (those approve intent, not test results).
+
+**Never relaxed — these stay manual regardless of Trust Mode (the CLI enforces this, do not second-guess it):**
+- `arch` / GATE B (Tech Lead architecture sign-off) — always exit 10.
+- `changes` / GATE D when a **Critical** review finding exists — always exit 10. (Pass `--critical`.)
+- The Guard hooks (`privacy-block`, `pre-commit-gate` secret scan) run independently of gates and are never affected.
+
+> If the user passed `--trust` (or `--trust=scope,plan`) on this `/dw:flow` run, thread it into every `dw trust gate` call as the `--trust` value (one-shot, this run only). Otherwise the CLI falls back to `workflow.trust` config.
+
+---
+
 ## CHECKPOINTS (Human Gates)
 
-Tại mỗi GATE, **dừng lại** và hiển thị:
+Tại mỗi GATE, **dừng lại** (trừ khi Trust Mode auto-approve — xem trên) và hiển thị:
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

package/.claude/skills/dw-goal/SKILL.md

@@ -145,11 +145,32 @@ Tự chủ là một **núm xoay 3 nấc**, không phải bật/tắt. Bắt đ
 
 **Bất biến ở mọi nấc:**
 - Hard-stop của Termination Contract (irreversible boundary, no-progress guard, ladder L5, wait-gated) **không bao giờ bị nới**.
-- Việc task vẫn đi qua human gate của `dw:flow` (GATE C/D). Loop chỉ tự chủ ở tầng *chọn KR / leo bậc / đo đạc*.
+- Việc task đi qua human gate của `dw:flow` (GATE C/D) — TRỪ khi user bật **Trust Mode** (ADR-0022) thì các gate tiện lợi được auto-approve. Kể cả vậy, hard-stop an toàn (Guards, Critical, GATE B) vẫn dừng. Không bật Trust = loop vẫn dừng ở GATE C/D như cũ.
 - Càng lên nấc cao, journal `goal-loop.md` càng phải ghi đầy đủ (để human audit lại chuỗi quyết định đã tự chạy).
 
 **Lộ trình tự động hoá sâu hơn (P2/P3, telemetry-gated):** đo KR auto-measurable tự động qua CLI helper (`dw goal gap`), rồi tới adapter chạy `test_command`/đếm artifact và tự ghi `current` — giảm dần phần human phải đo tay. Xem ADR-0016 Phasing.
 
+## Overnight Autopilot — chạy đêm, review sáng (ADR-0023)
+
+Khi chạy `--auto=full` **kèm Trust Mode bật** (qua OS/CI cron của user, ví dụ `dw goal --auto=full --trust`), loop trở thành autopilot không người trông.
+
+**INPUT contract — chạy `dw autopilot preflight --goal <id> --max-iter <n>` TRƯỚC khi bắt đầu.** Exit ≠ 0 → KHÔNG chạy (tree bẩn / budget vô hạn / trust blanket-unbounded). Đây là "fail trước khi bắt đầu". (Preflight là *cooperative*: gọi `dw goal --auto=full` trực tiếp từ shell sẽ bỏ qua nó — cron template `.dw/core/templates/autopilot-cron.sh` là đường an toàn được khuyến nghị.) Khi gọi `dw trust gate` trong vòng lặp, truyền `--run-count <n>` (số gate đã auto-approve) để `max_auto_subtasks` được enforce thật.
+
+Áp thêm **run contract** trong lúc chạy:
+
+1. **Safe-park-on-ambiguity — KHÔNG đoán.** Gặp quyết định Trust Mode không bao trùm (Critical finding, thao tác irreversible/phá huỷ, hoặc design fork không có winner rõ) → **không tự quyết**. Ghi một event `parked` vào `.dw/events-global.jsonl`:
+   ```
+   {"event":"parked","item":"<chỗ kẹt>","question":"<câu cần human>","options":["A","B"]}
+   ```
+   rồi tiếp tục phần *an toàn* còn lại. Parked items là phần human xử lý buổi sáng.
+2. **Mỗi subtask xong → log** `{"event":"subtask_completed","subtask":"ST-x","commit":"<sha>","summary":"..."}`. Mỗi hard-stop → `{"event":"hard_stop","gate":"...","reason":"..."}`.
+3. **Budget bound → dừng graceful.** Chạm `--max-iter` / `workflow.trust.max_auto_subtasks` / hết ngân sách → ghi `{"event":"overnight_wrapup","stop_reason":"budget|done|no-progress"}`, KHÔNG chạy nóng để ép xong.
+4. **EVD verify ở GATE D.** Khi gọi `dw trust gate changes`, LUÔN kèm `--evidence '{"tests":{...},"review":{"critical":N,...},"diff":{...}}'` để quyết định auto-approve dựa trên *bằng chứng* (tests xanh, 0 Critical, diff trong scope), không phải lời hứa. Evidence được ghi vào digest dưới dạng "evidence card".
+5. **OUTPUT contract — cuối run:** chạy `dw autopilot postflight --require-wrapup` (kiểm digest tồn tại · có wrap-up · local-only) rồi `dw overnight digest` → tạo `OVERNIGHT.md` (đọc nguội buổi sáng: verdict · done+SHA · auto-approved+evidence · ⏸ parked-for-you · 🛑 hard-stops · review-next).
+6. **Dừng trước push.** Autopilot commit cục bộ; push/PR để human. (Kỷ luật no-auto-push.)
+
+> Scheduling KHÔNG nằm trong toolkit — user tự đặt cron/at/CI gọi lệnh autopilot (ADR-0021: không nhét daemon vào binary).
+
 ## State bền vững giữa các session — `goal-loop.md`
 
 Khi loop kéo dài nhiều session HOẶC chạy `--auto`, ghi annex `.dw/goals/{goal-id}/goal-loop.md`

package/.dw/config/config.schema.json

@@ -22,6 +22,30 @@
           "type": "string",
           "enum": ["quick", "standard", "thorough"],
           "default": "standard"
+        },
+        "trust": {
+          "type": "object",
+          "additionalProperties": false,
+          "description": "Trust Mode (ADR-0022) — opt-in auto-approval for dw:flow convenience gates. Off by default. Guards + Critical findings + GATE B are never relaxed.",
+          "properties": {
+            "profile": {
+              "type": "string",
+              "enum": ["solo-night", "reviewed-team"],
+              "description": "Named trust preset; explicit keys below override it (ADR-0023)"
+            },
+            "enabled": { "type": "boolean", "default": false },
+            "auto_approve": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "scope":   { "type": "boolean", "default": false },
+                "plan":    { "type": "boolean", "default": false },
+                "changes": { "type": "boolean", "default": false }
+              }
+            },
+            "max_auto_subtasks": { "type": "integer", "minimum": 0, "default": 0 },
+            "require_evidence": { "type": "boolean", "default": false, "description": "GATE D refuses to auto-approve without an --evidence object" }
+          }
         }
       }
     },

package/.dw/config/dw.config.yml

@@ -18,6 +18,20 @@ workflow:
   #   standard : 3-5 files, module mới, unfamiliar code
   #   thorough : 6+ files, API contract changes, DB schema, security
 
+  # Trust Mode (ADR-0022) — opt-in auto-approval for dw:flow convenience gates.
+  # OFF by default = every gate is manual (today's behaviour). Guards
+  # (privacy-block, secret-scan), Critical review findings, and GATE B (TL
+  # architecture sign-off) are NEVER relaxed. One-shot: `/dw:flow --trust`.
+  trust:
+    # profile: solo-night    # named preset (solo-night | reviewed-team); explicit keys below override it
+    enabled: false
+    auto_approve:
+      scope: false      # GATE A / Q1 — confirm scope
+      plan: false       # GATE C — approve plan
+      changes: false    # GATE D / Q2 — approve changes (never when Critical)
+    max_auto_subtasks: 0  # 0 = unbounded once enabled; >0 caps an unattended run
+    require_evidence: false  # when true, GATE D won't auto-approve without --evidence
+
 # --- Team -------------------------------------------------------------------
 team:
   roles:

package/.dw/core/HARNESS.md

@@ -0,0 +1,157 @@
+# HARNESS — multi-agent quality patterns
+
+A small playbook for using more than one agent (or one agent more than once) to reach a
+**better-verified** answer than a single pass — not a bigger one. Vendor- and runtime-neutral.
+
+The rule that governs all of it:
+
+> **Judge a harness by verified outcome per unit cost, not by sophistication.** Use a harness
+> only when an independent pass is likely to change a decision, catch a costly error, or produce
+> evidence a single pass would not. If the second pass only adds volume, ceremony, or confidence
+> theater — stop.
+
+These patterns improve **correctness and judgment**, not throughput. They do not, by themselves,
+make delivery faster.
+
+---
+
+## The patterns
+
+### 1. Fan-out → judge → review (decorrelated adjudication)
+Split an independent work-list (links, findings, files, candidates) across N agents, then run
+each result through a *second, independent* judge before committing it.
+- **When:** a set of items each needing an assessment, where a first-pass error is plausible.
+- **Cost:** N agents + a judge pass. Cheaper model for the finders, a stronger one for the judge.
+- **Requirement:** the judge must have access to the **source of truth** and must cite the
+  deciding fact. Do not adjudicate from summaries when the underlying artifact is inspectable —
+  artifact-first beats transcript-first.
+- **Why it pays:** the judge catches first-pass mistakes the producer can't see — e.g. flipping a
+  wrong "remove" verdict back to "keep", or accepting an item while flagging that its *underlying
+  data* is what's actually wrong.
+
+### 2. Cold review before done (fresh-context adversarial check)
+Before reporting substantive work complete, run a fresh, read-only reviewer whose job is to
+**falsify the "done" claim** — using source, diff, build/test output, and the real user path.
+- **When:** any non-trivial change, before you say "done".
+- **Cost:** one agent. Almost always worth it.
+- **Why it pays:** a fresh context with an adversarial brief catches what the author rationalized
+  past. (Distinct from ordinary self-review: a *different* context with a falsification brief, not
+  the author re-reading their own work.)
+
+### 3. Evidence council for hard calls
+For a genuinely ambiguous, high-stakes decision, spawn N *independent* assessors — ideally across
+different models and **different briefs** — each reporting findings with reasoning.
+- **Votes are advisory; the orchestrator decides from evidence:** tests, source facts, user
+  impact, constraints, explicit uncertainty. A 2-1 vote with weak evidence should lose to one
+  dissenting finding backed by a reproducible failure.
+- **When:** the call is hard *and* expensive to get wrong. Reserve it.
+- **Why it pays:** decorrelates single-agent error — but only if the assessors are genuinely
+  independent. A majority vote over a shared, stale summary just amplifies a common blind spot.
+
+### 4. Outside-in dogfood (a release gate)
+Use the product exactly as a real user would — install it, drive it through an agent, check the
+answers are *useful*, not merely non-erroring — separate from the unit suite.
+- **When:** a release gate for installable tools and user-facing workflows; ongoing thereafter.
+- **Why it pays:** catches what unit tests structurally cannot — a broken install path, a
+  confusing first-run response, an empty-looking result. The failures users hit first.
+
+### 5. Lessons-as-memory (the learning loop)
+Record each notable failure with its **detection method, its fix, and the condition that would
+make the lesson obsolete**; recall and apply the accumulation next cycle. Prune what proves wrong.
+- **When:** always — the cheapest pattern here.
+- **Why it pays:** specific, sourced lessons compound. Vague ones ("use more agents") become
+  cargo-cult prompts; the valuable memory is "this exact failure escaped this exact gate."
+
+### 6. Handoff-as-continuity (for interrupted or multi-agent work)
+When a run may stop, hit a limit, or pass work to another agent, write a pickup-ready handoff:
+current state, the exact next command/action, files touched, verification already run, known
+blockers, and human-only gates.
+- **When:** long runs, usage-limit risk, or handing off to a peer.
+- **Why it pays:** it is what makes an interruption *recoverable*. A stopped or usage-limited
+  agent cannot be woken by a message — only its own runtime or a human resumes it; the handoff is
+  what lets that resumption be clean.
+
+---
+
+## The decision rule (read before spawning anything)
+
+1. **Prefer in-context fan-out over live peer-coordination.** A workflow that fans out agents
+   inside one orchestrated run is cheap, deterministic, and has no liveness gap. Coordinating two
+   independently-running agent *sessions* (a shared bus, claims) is expensive and fragile, and a
+   stopped peer can't be woken by a message. Use live peer-coordination only when you genuinely
+   need two running runtimes.
+2. **Match the pattern to the stakes.** Cold review for most things; a council only for the hard,
+   expensive-to-get-wrong calls. Every spawn costs.
+3. **Pick a task-specific conservative default before you start.** For deletion/curation,
+   uncertainty usually means *keep and flag*. For publish, credentials, privacy, security, and
+   destructive actions, uncertainty means *block or escalate*.
+4. **Have a stop condition.** If two independent passes converge with evidence and no unresolved
+   high-impact uncertainty, stop spawning. Passes past convergence are cost without signal.
+5. **Raise conservatism when you remove the human.** Auto-approval and unattended runs are
+   where a harness pays off most and where a wrong call is least recoverable. Keep a set of
+   hard-stops that autonomy cannot relax (secrets, destructive/irreversible ops, a Critical
+   finding), and on an ambiguous *irreversible* call, **park it with the question and the
+   options you see — do not guess.** Unattended should be *more* conservative than supervised,
+   not less.
+
+### Independence checklist
+Before treating agents as independent, check:
+- Did each pass inspect the source artifact, not only another agent's summary?
+- Did the reviewer have a different brief from the producer?
+- Are uncertainty and assumptions recorded?
+- Is there a conservative default for ambiguous cases?
+- Is there a stop condition to prevent review loops?
+
+### Do NOT use a harness when
+- The task is trivial and reversible.
+- The answer is mechanically testable with one command.
+- The extra agent cannot inspect better evidence than the first.
+- The decision is low-stakes and cheaper to fix later.
+- You are using more agents to avoid making a product or authority decision.
+
+---
+
+## Honest boundaries
+
+- **This is a *learning* harness, not a *self-evolving* one.** Lessons accumulate because a human
+  or agent curates them — there is no autonomous measure→fix loop running unattended. Don't
+  oversell autonomy; it rises only as a measured error-rate falls.
+- **The realtime multi-agent bus is out of scope for this doc.** Treat a shared-file bus as an
+  async coordination log and audit trail — not a scheduler, lock manager, or wake-up channel.
+  Turn-based agents can emit during a run and ingest at turn start; a stopped or usage-limited peer
+  will not react until its own runtime or a human resumes it. For more than one writer, require
+  per-agent worktrees **or** orchestrator-assigned disjoint write scopes (non-overlap is the
+  cheapest prevention; worktrees are the strongest). Before relying on a bus for active
+  coordination, add an enforced pre-write/pre-commit choke point for claimed paths, a serialized
+  event substrate such as SQLite-WAL — which fixes ordering/durability but **not** shared-tree
+  write races — turn-start ingest with cursors, and a separate liveness/supervisor story if
+  automatic reactivation is a goal.
+
+---
+
+## Where this sits in the 5-pillar model
+
+These patterns are **Records** (capture what was learned) and **Tunes** (knobs the team turns on
+per task). They deliver value without the heavier Surfaces/Bridges runtime — a single agent using
+**Cold review** + **Lessons-as-memory** is already better off.
+
+---
+
+## How dw-kit implements these (non-normative, repo-specific)
+
+> This appendix maps the neutral patterns above onto dw-kit features, for readers inside this
+> repo. It is **not** part of the portable playbook — a vendor-neutral export may delete it.
+
+| Pattern | dw-kit surface |
+|---------|----------------|
+| Fan-out → judge | Agent OS claims (`dw agent claim`, ADR-0009) cover the fan-out / disjoint-scope half (cooperative, post-hoc conflict detection, *not* enforcement); the judge pass is the orchestrator merge + `/dw:review` |
+| Cold review before done | `/dw:review` (fresh-context falsification pass), orchestrated as `/dw:flow`'s Review phase |
+| Evidence council | `/dw:plan` Quick Debate (red/blue) + `dw trust gate --evidence` (EVD, ADR-0022/0023) — votes advisory, evidence decides |
+| Outside-in dogfood | manual install-and-drive dogfood practice (e.g. the G-dogfood-v1.7 friction journal) — a discipline, not an automated gate |
+| Lessons-as-memory | `task.md` Section 5 Friction Journal + ADR "Consequences" + `.dw/research/` notes (the host auto-memory store is a Claude Code feature, not dw-kit) |
+| Handoff-as-continuity | `/dw:handoff` + `task.md` Section 5 + the overnight digest (ADR-0023) |
+| Raise conservatism off-human | Trust Mode non-relaxable hard-stops (ADR-0022) + overnight safe-park (ADR-0023) |
+
+**See also:** `QUALITY.md` — the 4-layer quality framework; HARNESS is the multi-agent
+mechanics behind its Layer 3 (Cross-Review) and Layer 4 (gates). `AGENTS.md` — agent
+report/handoff conventions used by pattern 6.

package/.dw/core/schemas/events/gate_auto_approved.schema.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/dv-workflow/dv-workflow/schemas/events/gate_auto_approved.schema.json",
+  "title": "DW Event: gate_auto_approved",
+  "description": "Category: trust-autopilot. See docs/specs/dw-event-schema-v1.0.md §5 for narrative.",
+  "type": "object",
+  "properties": {
+    "ts": {
+      "type": "string",
+      "format": "date-time",
+      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?Z$",
+      "description": "ISO 8601 UTC timestamp (envelope, set by writer)"
+    },
+    "event": {
+      "type": "string",
+      "const": "gate_auto_approved",
+      "description": "Event name (envelope)"
+    },
+    "gate": {
+      "type": "string"
+    },
+    "actor": {
+      "type": "string"
+    },
+    "task": {},
+    "reason": {},
+    "evidence": {}
+  },
+  "required": [
+    "ts",
+    "event",
+    "gate",
+    "actor"
+  ],
+  "additionalProperties": true
+}

package/.dw/core/schemas/events/hard_stop.schema.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/dv-workflow/dv-workflow/schemas/events/hard_stop.schema.json",
+  "title": "DW Event: hard_stop",
+  "description": "Category: trust-autopilot. See docs/specs/dw-event-schema-v1.0.md §5 for narrative.",
+  "type": "object",
+  "properties": {
+    "ts": {
+      "type": "string",
+      "format": "date-time",
+      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?Z$",
+      "description": "ISO 8601 UTC timestamp (envelope, set by writer)"
+    },
+    "event": {
+      "type": "string",
+      "const": "hard_stop",
+      "description": "Event name (envelope)"
+    },
+    "reason": {
+      "type": "string"
+    },
+    "gate": {
+      "type": "string"
+    },
+    "blocker": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "ts",
+    "event",
+    "reason"
+  ],
+  "additionalProperties": true
+}

package/.dw/core/schemas/events/index.json

@@ -4,14 +4,15 @@
   "title": "DW Event Schema v1.0 — Index",
   "description": "Generated from src/lib/event-schema.mjs EVENT_CATALOGUE by scripts/generate-event-schemas.mjs. Do not edit by hand; regenerate via 'npm run gen:event-schemas'.",
   "schema_version": "1.0.0",
-  "generated_at": "2026-05-27T17:18:00Z",
+  "generated_at": "2026-07-02T13:35:29Z",
   "spec_url": "https://github.com/dv-workflow/dv-workflow/blob/main/docs/specs/dw-event-schema-v1.0.md",
   "protocol_url": "https://github.com/dv-workflow/dv-workflow/blob/main/docs/specs/dw-adapter-protocol.md",
-  "total_events": 33,
+  "total_events": 38,
   "categories": [
     "debate",
     "goal",
     "session-lifecycle",
+    "trust-autopilot",
     "voice-action",
     "voice-orchestrator"
   ],
@@ -46,6 +47,11 @@
       "category": "debate",
       "file": "debate_started.schema.json"
     },
+    {
+      "name": "gate_auto_approved",
+      "category": "trust-autopilot",
+      "file": "gate_auto_approved.schema.json"
+    },
     {
       "name": "goal_archived",
       "category": "goal",
@@ -81,6 +87,11 @@
       "category": "goal",
       "file": "goal_task_unlinked.schema.json"
     },
+    {
+      "name": "hard_stop",
+      "category": "trust-autopilot",
+      "file": "hard_stop.schema.json"
+    },
     {
       "name": "orchestrator_cancelled",
       "category": "voice-action",
@@ -141,6 +152,16 @@
       "category": "voice-orchestrator",
       "file": "orchestrator_timeout.schema.json"
     },
+    {
+      "name": "overnight_wrapup",
+      "category": "trust-autopilot",
+      "file": "overnight_wrapup.schema.json"
+    },
+    {
+      "name": "parked",
+      "category": "trust-autopilot",
+      "file": "parked.schema.json"
+    },
     {
       "name": "reconciled",
       "category": "session-lifecycle",
@@ -180,6 +201,11 @@
       "name": "stopped",
       "category": "session-lifecycle",
       "file": "stopped.schema.json"
+    },
+    {
+      "name": "subtask_completed",
+      "category": "trust-autopilot",
+      "file": "subtask_completed.schema.json"
     }
   ]
 }

package/.dw/core/schemas/events/overnight_wrapup.schema.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/dv-workflow/dv-workflow/schemas/events/overnight_wrapup.schema.json",
+  "title": "DW Event: overnight_wrapup",
+  "description": "Category: trust-autopilot. See docs/specs/dw-event-schema-v1.0.md §5 for narrative.",
+  "type": "object",
+  "properties": {
+    "ts": {
+      "type": "string",
+      "format": "date-time",
+      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?Z$",
+      "description": "ISO 8601 UTC timestamp (envelope, set by writer)"
+    },
+    "event": {
+      "type": "string",
+      "const": "overnight_wrapup",
+      "description": "Event name (envelope)"
+    },
+    "stop_reason": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "ts",
+    "event",
+    "stop_reason"
+  ],
+  "additionalProperties": true
+}

package/.dw/core/schemas/events/parked.schema.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/dv-workflow/dv-workflow/schemas/events/parked.schema.json",
+  "title": "DW Event: parked",
+  "description": "Category: trust-autopilot. See docs/specs/dw-event-schema-v1.0.md §5 for narrative.",
+  "type": "object",
+  "properties": {
+    "ts": {
+      "type": "string",
+      "format": "date-time",
+      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?Z$",
+      "description": "ISO 8601 UTC timestamp (envelope, set by writer)"
+    },
+    "event": {
+      "type": "string",
+      "const": "parked",
+      "description": "Event name (envelope)"
+    },
+    "item": {
+      "type": "string"
+    },
+    "question": {
+      "type": "string"
+    },
+    "options": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "required": [
+    "ts",
+    "event",
+    "item",
+    "question"
+  ],
+  "additionalProperties": true
+}

package/.dw/core/schemas/events/subtask_completed.schema.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/dv-workflow/dv-workflow/schemas/events/subtask_completed.schema.json",
+  "title": "DW Event: subtask_completed",
+  "description": "Category: trust-autopilot. See docs/specs/dw-event-schema-v1.0.md §5 for narrative.",
+  "type": "object",
+  "properties": {
+    "ts": {
+      "type": "string",
+      "format": "date-time",
+      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?Z$",
+      "description": "ISO 8601 UTC timestamp (envelope, set by writer)"
+    },
+    "event": {
+      "type": "string",
+      "const": "subtask_completed",
+      "description": "Event name (envelope)"
+    },
+    "subtask": {
+      "type": "string"
+    },
+    "commit": {
+      "type": "string"
+    },
+    "summary": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "ts",
+    "event",
+    "subtask"
+  ],
+  "additionalProperties": true
+}