dw-kit 1.9.3 → 1.10.0

package/.dw/core/schemas/overnight-digest.schema.json

@@ -0,0 +1,113 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/dv-workflow/dv-workflow/schemas/overnight-digest.schema.json",
+  "title": "DW Read-Contract: overnight-digest@v1",
+  "description": "Machine-readable summary of one Overnight Autopilot run (ADR-0023). The human-facing OVERNIGHT.md is rendered from this shape; external dashboards/adapters consume it. Produced by summarizeRun() over .dw/events-global.jsonl.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "counts", "stopReason"],
+  "properties": {
+    "schema_version": { "type": "string", "const": "overnight-digest@v1" },
+    "date": { "type": "string", "description": "ISO date (YYYY-MM-DD) of the run" },
+    "goal": { "type": ["string", "null"], "description": "Goal id/title the run pursued" },
+    "counts": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["done", "parked", "hardStops", "autoApproved"],
+      "properties": {
+        "done": { "type": "integer", "minimum": 0 },
+        "parked": { "type": "integer", "minimum": 0 },
+        "hardStops": { "type": "integer", "minimum": 0 },
+        "autoApproved": { "type": "integer", "minimum": 0 }
+      }
+    },
+    "stopReason": {
+      "type": "string",
+      "description": "Why the run stopped",
+      "examples": ["budget", "done", "no-progress", "unknown"]
+    },
+    "wrapupSeen": {
+      "type": "boolean",
+      "description": "Whether an overnight_wrapup event was present (false = run may have crashed)"
+    },
+    "done": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "subtask": { "type": "string" },
+          "commit": { "type": "string" },
+          "summary": { "type": "string" }
+        }
+      }
+    },
+    "autoApproved": {
+      "type": "array",
+      "description": "Gates Trust Mode waved (event: gate_auto_approved)",
+      "items": {
+        "type": "object",
+        "properties": {
+          "gate": { "type": "string" },
+          "task": { "type": ["string", "null"] },
+          "reason": { "type": "string" },
+          "evidence": {
+            "type": "object",
+            "description": "EVD verify — the basis cited for the auto-approval, not just the outcome",
+            "properties": {
+              "tests": {
+                "type": "object",
+                "properties": {
+                  "command": { "type": "string" },
+                  "passed": { "type": "integer" },
+                  "failed": { "type": "integer" },
+                  "exit": { "type": "integer" }
+                }
+              },
+              "review": {
+                "type": "object",
+                "properties": {
+                  "critical": { "type": "integer", "minimum": 0 },
+                  "warning": { "type": "integer", "minimum": 0 },
+                  "suggestion": { "type": "integer", "minimum": 0 }
+                }
+              },
+              "diff": {
+                "type": "object",
+                "properties": {
+                  "files": { "type": "integer" },
+                  "insertions": { "type": "integer" },
+                  "deletions": { "type": "integer" },
+                  "within_scope": { "type": "boolean" }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "parked": {
+      "type": "array",
+      "description": "Decisions the agent refused to guess on — the human acts on these",
+      "items": {
+        "type": "object",
+        "properties": {
+          "item": { "type": "string" },
+          "question": { "type": "string" },
+          "options": { "type": "array", "items": { "type": "string" } }
+        }
+      }
+    },
+    "hardStops": {
+      "type": "array",
+      "description": "Guard / Critical blocks that fired",
+      "items": {
+        "type": "object",
+        "properties": {
+          "gate": { "type": "string" },
+          "blocker": { "type": "string" },
+          "reason": { "type": "string" }
+        }
+      }
+    }
+  }
+}

package/.dw/core/templates/autopilot-cron.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Overnight Autopilot recipe (ADR-0023). Scheduling lives in YOUR cron/CI — the
+# toolkit ships no daemon (ADR-0021). Copy, set the two vars, add to crontab:
+#   0 1 * * *  /path/to/autopilot-cron.sh >> ~/dw-autopilot.log 2>&1
+set -euo pipefail
+
+PROJECT_DIR="${PROJECT_DIR:-$HOME/your-project}"
+GOAL_ID="${GOAL_ID:-G-your-goal}"
+MAX_ITER="${MAX_ITER:-8}"
+
+cd "$PROJECT_DIR"
+
+# INPUT contract — refuse to start in an unsafe state (dirty tree, no budget, …).
+if ! dw autopilot preflight --goal "$GOAL_ID" --max-iter "$MAX_ITER"; then
+  echo "autopilot: preflight failed — not running tonight."
+  exit 0
+fi
+
+# Drive the goal unattended with Trust Mode. Gates auto-approve per your config;
+# Guards + Critical findings + GATE B still hard-stop. Safe-park on ambiguity.
+dw goal --auto=full --trust --max-iter "$MAX_ITER" "$GOAL_ID" || true
+
+# OUTPUT contract — verify the end-state, then render the morning digest.
+dw autopilot postflight --require-wrapup || true   # verdict is still written below
+dw overnight digest --goal "$GOAL_ID"
+
+# NEVER push here. Local commits only — review OVERNIGHT.md and push yourself.
+echo "autopilot: done — review OVERNIGHT.md in $PROJECT_DIR"

package/README.md

@@ -1,6 +1,6 @@
 # dw-kit
 
-🇬🇧 **English** · [🇻🇳 Tiếng Việt](README.vi.md)
+🇬🇧 **English** · [🇻🇳 Tiếng Việt](README-vi.md)
 
 [![npm version](https://img.shields.io/npm/v/dw-kit?color=cb3837&logo=npm)](https://www.npmjs.com/package/dw-kit)
 [![downloads](https://img.shields.io/npm/dm/dw-kit?color=blue)](https://www.npmjs.com/package/dw-kit)
@@ -172,6 +172,8 @@ dw upgrade [--check]    # update toolkit files (keeps your customizations)
 dw task new <name>      # scaffold a v3 task doc
 dw task show [name]     # ANSI snapshot of a task
 dw goal status          # Goals → Key Results progress
+dw trust status         # Trust Mode — opt-in gate auto-approval (ADR-0022, off by default)
+dw autopilot preflight  # gate an unattended overnight run (ADR-0023); + `dw overnight digest`
 dw security-scan        # AI-native supply-chain guard (OSV + heuristics)
 dw dashboard            # active tasks + ADRs + telemetry summary
 dw metrics              # local-only telemetry (opt out: DW_NO_TELEMETRY=1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dw-kit",
-  "version": "1.9.3",
+  "version": "1.10.0",
   "description": "AI development workflow toolkit — structured, quality-assured, team-ready. From requirements to dashboard.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -219,6 +219,69 @@ export function run(argv) {
       await decisionIndexCommand(opts);
     });
 
+  const trustCmd = program
+    .command('trust')
+    .description('Trust Mode (ADR-0022): opt-in auto-approval for dw:flow convenience gates — Guards + Critical never relaxed');
+
+  trustCmd
+    .command('status')
+    .description('Show resolved Trust Mode state for this project')
+    .action(async () => {
+      const { trustStatusCommand } = await import('./commands/trust.mjs');
+      await trustStatusCommand();
+    });
+
+  trustCmd
+    .command('gate <name>')
+    .description('Deterministic gate decision (scope|plan|changes|arch). Exit 0 = auto-approve, 10 = manual stop')
+    .option('--trust <gates>', 'One-shot trust for this call: true | comma-separated gate ids')
+    .option('--critical', 'A Critical review finding exists (forces GATE D manual)')
+    .option('--task <name>', 'Task the gate belongs to (recorded in the audit event)')
+    .option('--evidence <json>', 'EVD verify: JSON basis, e.g. {"tests":{"exit":0},"review":{"critical":0}}')
+    .option('--run-count <n>', 'Auto-approvals so far this run (enforces workflow.trust.max_auto_subtasks)')
+    .action(async (name, opts) => {
+      const { trustGateCommand } = await import('./commands/trust.mjs');
+      await trustGateCommand(name, opts);
+    });
+
+  const autopilotCmd = program
+    .command('autopilot')
+    .description('Overnight Autopilot contract (ADR-0023): preflight (INPUT) + postflight (OUTPUT) assertions');
+
+  autopilotCmd
+    .command('preflight')
+    .description('Assert it is safe to START an unattended run (clean tree · budget · trust bounded · tests · goal). Exit 0 = clear, 1 = blocked')
+    .option('--goal <id>', 'Goal id the run will pursue')
+    .option('--max-iter <n>', 'Iteration budget for this run')
+    .action(async (opts) => {
+      const { autopilotPreflightCommand } = await import('./commands/autopilot.mjs');
+      await autopilotPreflightCommand(opts);
+    });
+
+  autopilotCmd
+    .command('postflight')
+    .description('Assert the run ended in a safe, reviewable state (digest written · wrap-up · local-only). Exit 0 = clean, 1 = unsafe')
+    .option('--require-wrapup', 'Treat a missing overnight_wrapup event as a blocking failure')
+    .action(async (opts) => {
+      const { autopilotPostflightCommand } = await import('./commands/autopilot.mjs');
+      await autopilotPostflightCommand(opts);
+    });
+
+  const overnightCmd = program
+    .command('overnight')
+    .description('Overnight Autopilot (ADR-0023): morning-review digest for unattended runs');
+
+  overnightCmd
+    .command('digest')
+    .description('Render OVERNIGHT.md from recent .dw/events-global.jsonl run events')
+    .option('--stdout', 'Print to stdout instead of writing OVERNIGHT.md')
+    .option('--limit <n>', 'How many recent events to scan (default 500)')
+    .option('--goal <id>', 'Goal id/title the run pursued (for the header)')
+    .action(async (opts) => {
+      const { overnightDigestCommand } = await import('./commands/overnight.mjs');
+      await overnightDigestCommand(opts);
+    });
+
   const agentCmd = program
     .command('agent')
     .description('Agent OS multi-agent orchestration (ADR-0009): claim · release · renew · expire · claims · reports · conflicts · check-staged · verify');

package/src/commands/autopilot.mjs

@@ -0,0 +1,65 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { header, ok, warn, err, log } from '../lib/ui.mjs';
+import { loadConfigWithLocal } from '../lib/config.mjs';
+import { checkPreconditions, checkPostconditions } from '../lib/autopilot-contract.mjs';
+import { readGoalEvents } from '../lib/goal-events.mjs';
+
+function loadProjectConfig(projectDir) {
+  const configDir = join(projectDir, '.dw', 'config');
+  if (!existsSync(join(configDir, 'dw.config.yml'))) return null;
+  return loadConfigWithLocal(configDir);
+}
+
+function renderChecks(checks) {
+  for (const c of checks) {
+    const mark = c.ok ? ok : (c.severity === 'block' ? err : warn);
+    mark(`[${c.severity}] ${c.id} — ${c.detail}`);
+  }
+}
+
+/**
+ * `dw autopilot preflight` — assert it is safe to START an unattended run
+ * (ADR-0023 INPUT contract). Exit 0 = clear to run, 1 = blocked.
+ */
+export async function autopilotPreflightCommand(opts = {}) {
+  const rootDir = process.cwd();
+  const config = loadProjectConfig(rootDir) || {};
+  const maxIter = opts.maxIter != null ? Number(opts.maxIter) : null;
+  const { ok: passed, checks } = checkPreconditions({ rootDir, config, goalId: opts.goal || null, maxIter });
+
+  header('Autopilot preflight (ADR-0023 INPUT contract)');
+  renderChecks(checks);
+  log('');
+  if (passed) {
+    ok('Preconditions met — clear to start an unattended run.');
+    process.exit(0);
+  }
+  err('Preconditions FAILED — do not start. Fix the [block] items above.');
+  process.exit(1);
+}
+
+/**
+ * `dw autopilot postflight` — assert the run ended in a safe, reviewable state
+ * (ADR-0023 OUTPUT contract). Exit 0 = clean, 1 = unsafe end-state.
+ */
+export async function autopilotPostflightCommand(opts = {}) {
+  const rootDir = process.cwd();
+  // Derive wrap-up presence from the event log unless caller asserts otherwise.
+  let wrapupSeen = null;
+  if (opts.requireWrapup) {
+    const events = readGoalEvents(rootDir, { limit: 500 });
+    wrapupSeen = events.some((e) => e && e.event === 'overnight_wrapup');
+  }
+  const { ok: passed, checks } = checkPostconditions({ rootDir, wrapupSeen });
+
+  header('Autopilot postflight (ADR-0023 OUTPUT contract)');
+  renderChecks(checks);
+  log('');
+  if (passed) {
+    ok('Postconditions met — run ended in a reviewable state.');
+    process.exit(0);
+  }
+  err('Postconditions FAILED — inspect manually before resuming.');
+  process.exit(1);
+}

package/src/commands/doctor.mjs

@@ -3,7 +3,7 @@ import { createRequire } from 'node:module';
 import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { header, ok, warn, err, info, log } from '../lib/ui.mjs';
-import { loadConfig, getToolkitVersions, getReviewRendererConfig } from '../lib/config.mjs';
+import { loadConfig, loadConfigWithLocal, getToolkitVersions, getReviewRendererConfig, getTrustConfig } from '../lib/config.mjs';
 import { detectPlatform, platformLabel } from '../lib/platform.mjs';
 import { snapshotInfo } from '../lib/sc-sync.mjs';
 
@@ -275,6 +275,22 @@ export async function doctorCommand() {
     }
   }
 
+  info('Trust Mode (ADR-0022, opt-in)');
+  // Read the effective (base + local override) config — a privacy-conscious user
+  // may enable Trust Mode only in dw.config.local.yml. (review round 2: W-4)
+  const trustCfg = existsSync(configPath)
+    ? getTrustConfig(loadConfigWithLocal(join(projectDir, '.dw', 'config')) || {})
+    : getTrustConfig({});
+  if (!trustCfg.enabled) {
+    log('  Status      : OFF — all gates manual (default)');
+  } else {
+    const on = Object.entries(trustCfg.auto_approve).filter(([, v]) => v).map(([k]) => k);
+    warn(`Trust Mode ON — auto-approving: ${on.length ? on.join(', ') : '(none selected)'}`);
+    log(`  Max subtasks: ${trustCfg.max_auto_subtasks === 0 ? 'unbounded' : trustCfg.max_auto_subtasks}`);
+    log('  Never relaxed: Guards, GATE D on Critical, GATE B (TL arch)');
+    warnings++;
+  }
+
   console.log();
   header('Diagnosis');
   if (issues === 0 && warnings === 0) {

package/src/commands/overnight.mjs

@@ -0,0 +1,35 @@
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { header, ok, log } from '../lib/ui.mjs';
+import { readGoalEvents } from '../lib/goal-events.mjs';
+import { buildDigest, buildDigestData, writeDigest, summarizeRun } from '../lib/overnight-digest.mjs';
+
+/**
+ * `dw overnight digest` — render OVERNIGHT.md from recent run events (ADR-0023).
+ * Sourced deterministically from .dw/events-global.jsonl so the morning digest
+ * is reproducible, not free-form narration.
+ */
+export async function overnightDigestCommand(opts = {}) {
+  const rootDir = process.cwd();
+  const limit = Number.isInteger(Number(opts.limit)) ? Number(opts.limit) : 500;
+  const events = readGoalEvents(rootDir, { limit });
+
+  const content = buildDigest({ events, goal: opts.goal || null });
+
+  if (opts.stdout) {
+    process.stdout.write(content + '\n');
+    process.exit(0);
+  }
+
+  const target = writeDigest(rootDir, content);
+  // Also emit the machine-readable read-contract (overnight-digest@v1) so
+  // dashboards/adapters consume the run without parsing markdown (ADR-0023).
+  const data = buildDigestData({ events, goal: opts.goal || null });
+  writeFileSync(join(rootDir, 'OVERNIGHT.json'), JSON.stringify(data, null, 2), 'utf8');
+  const s = summarizeRun(events);
+  header('Overnight digest');
+  ok(`Wrote ${target} + OVERNIGHT.json`);
+  log(`✅ ${s.counts.done} done · ⏸ ${s.counts.parked} parked · 🛑 ${s.counts.hardStops} hard-stops · ⚡ ${s.counts.autoApproved} auto-approved`);
+  if (s.counts.parked > 0) log('⏸ Parked items need your call — see the "Parked for you" section.');
+  process.exit(0);
+}

package/src/commands/trust.mjs

@@ -0,0 +1,79 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { header, ok, warn, info, log } from '../lib/ui.mjs';
+import { loadConfigWithLocal, getTrustConfig } from '../lib/config.mjs';
+import { resolveGate, logTrustEvent, GATES } from '../lib/trust.mjs';
+
+function loadProjectConfig(projectDir) {
+  const configDir = join(projectDir, '.dw', 'config');
+  if (!existsSync(join(configDir, 'dw.config.yml'))) return null;
+  return loadConfigWithLocal(configDir);
+}
+
+/**
+ * `dw trust status` — show the resolved Trust Mode state (ADR-0022).
+ */
+export async function trustStatusCommand() {
+  const config = loadProjectConfig(process.cwd());
+  const trust = getTrustConfig(config || {});
+
+  header('Trust Mode (ADR-0022)');
+  if (!trust.enabled) {
+    log('Status      : OFF — every gate is manual (default).');
+    log('Enable      : set workflow.trust.enabled: true in .dw/config/dw.config.yml');
+    log('Or one-shot : /dw:flow --trust <task>');
+    process.exit(0);
+  }
+
+  warn('Status      : ON — some convenience gates auto-approve.');
+  if (trust.profile) log(`Profile     : ${trust.profile}`);
+  log(`Scope (A/Q1): ${trust.auto_approve.scope ? 'auto-approve' : 'manual'}`);
+  log(`Plan  (C)   : ${trust.auto_approve.plan ? 'auto-approve' : 'manual'}`);
+  log(`Changes (D) : ${trust.auto_approve.changes ? 'auto-approve (never on Critical)' : 'manual'}`);
+  log(`Max subtasks: ${trust.max_auto_subtasks === 0 ? 'unbounded' : trust.max_auto_subtasks}`);
+  log(`Require evid: ${trust.require_evidence ? 'yes — GATE D needs --evidence' : 'no'}`);
+  info('Never relaxed');
+  log('Guards (privacy-block, secret-scan), GATE D on Critical, GATE B (TL arch).');
+  process.exit(0);
+}
+
+/**
+ * `dw trust gate <name>` — deterministic gate decision the skill can call.
+ * Exit 0 = auto-approve, exit 10 = manual stop required.
+ */
+export async function trustGateCommand(gate, opts = {}) {
+  const name = String(gate || '').toLowerCase();
+  if (!GATES[name]) {
+    warn(`Unknown gate "${gate}". Known: ${Object.keys(GATES).join(', ')}`);
+    process.exit(2);
+  }
+  const config = loadProjectConfig(process.cwd());
+  const evidence = parseEvidence(opts.evidence);
+  const runCount = opts.runCount != null && Number.isInteger(Number(opts.runCount)) ? Number(opts.runCount) : undefined;
+  const decision = resolveGate({
+    gate: name,
+    config: config || {},
+    flag: opts.trust,
+    hasCritical: opts.critical === true,
+    evidence,
+    runCount,
+  });
+
+  if (decision.autoApprove) {
+    // Invariant 4 (ADR-0022): every auto-approval is logged. This is the only
+    // code path that auto-approves, so the audit record is written HERE.
+    const res = logTrustEvent({ gate: name, task: opts.task || null, reason: decision.reason, evidence }, process.cwd());
+    ok(`${name}: AUTO-APPROVE — ${decision.reason}`);
+    if (!res.ok) warn(`(audit log failed: ${res.error?.message || 'unknown'} — proceeding)`);
+    process.exit(0);
+  }
+  warn(`${name}: MANUAL — ${decision.reason}`);
+  process.exit(10);
+}
+
+// Evidence is passed as a JSON string (EVD verify, ADR-0023 §evidence). Tolerant:
+// bad/absent JSON → undefined (the gate then falls back to its no-evidence rule).
+function parseEvidence(raw) {
+  if (!raw) return undefined;
+  try { return JSON.parse(raw); } catch { return undefined; }
+}

package/src/lib/autopilot-contract.mjs

@@ -0,0 +1,97 @@
+// Input/Output contract for unattended autopilot runs (ADR-0023, review round 2).
+//
+// ADR-0023's "run contract" was prose in the skill — i.e. it held only if the
+// LLM remembered it. This module makes the INPUT half (preconditions) and the
+// OUTPUT half (postconditions) machine-checkable so an unattended run REFUSES to
+// start in an unsafe state and its end-state is verified, not narrated.
+
+import { execSync } from 'node:child_process';
+import { existsSync as fileExists, statSync as fileStat } from 'node:fs';
+import { join } from 'node:path';
+import { getTrustConfig } from './config.mjs';
+
+function git(args, rootDir) {
+  try {
+    return execSync(`git ${args}`, { cwd: rootDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function check(id, severity, ok, detail) {
+  return { id, severity, ok, detail };
+}
+
+/**
+ * INPUT contract — assert it is safe to START an unattended run.
+ * @returns {{ ok: boolean, checks: object[] }}  ok=false if any `block` check fails
+ */
+export function checkPreconditions({ rootDir = process.cwd(), config = {}, goalId = null, maxIter = null } = {}) {
+  const checks = [];
+  const trust = getTrustConfig(config);
+
+  // 1. clean tree — a dirty tree makes the night's diff un-attributable.
+  const porcelain = git('status --porcelain', rootDir);
+  checks.push(check(
+    'clean-tree', 'block', porcelain === '',
+    porcelain === '' ? 'working tree clean' : `uncommitted changes present:\n${(porcelain || '(git unavailable)').split('\n').slice(0, 5).join('\n')}`,
+  ));
+
+  // 2. budget set — an unbounded unattended run is the footgun (ADR-0023 Force 3).
+  const bounded = (Number.isInteger(maxIter) && maxIter > 0) || trust.max_auto_subtasks > 0;
+  checks.push(check(
+    'budget-set', 'block', bounded,
+    bounded ? `bounded (--max-iter=${maxIter ?? 'unset'}, max_auto_subtasks=${trust.max_auto_subtasks})` : 'no --max-iter and max_auto_subtasks=0 — run is unbounded',
+  ));
+
+  // 3. trust not blanket-unbounded — the "trust everything, forever" misconfig.
+  const blanket = trust.enabled && trust.auto_approve.scope && trust.auto_approve.plan && trust.auto_approve.changes;
+  const dangerous = blanket && trust.max_auto_subtasks === 0;
+  checks.push(check(
+    'trust-bounded', 'block', !dangerous,
+    dangerous ? 'all gates trusted AND unbounded — set max_auto_subtasks or narrow trust' : 'trust scope is bounded',
+  ));
+
+  // 4. tests configured — establishes the green baseline the OUTPUT contract preserves.
+  const testCmd = config?.quality?.test_command || '';
+  checks.push(check(
+    'tests-configured', 'warn', !!testCmd,
+    testCmd ? `quality.test_command = "${testCmd}"` : 'no quality.test_command — cannot assert a green baseline',
+  ));
+
+  // 5. goal defined — safe-park needs a definition of "done" to judge ambiguity.
+  checks.push(check(
+    'goal-defined', 'warn', !!goalId,
+    goalId ? `goal: ${goalId}` : 'no goal id passed — pursuit loop has no measurable target',
+  ));
+
+  const ok = checks.filter((c) => c.severity === 'block').every((c) => c.ok);
+  return { ok, checks };
+}
+
+/**
+ * OUTPUT contract — assert the run ended in a safe, reviewable state.
+ * @returns {{ ok: boolean, checks: object[] }}
+ */
+export function checkPostconditions({ rootDir = process.cwd(), wrapupSeen = null } = {}) {
+  const checks = [];
+
+  // 1. digest written — the cold-review artifact must exist and be non-empty.
+  const digest = join(rootDir, 'OVERNIGHT.md');
+  const digestOk = fileExists(digest) && fileStat(digest).size > 0;
+  checks.push(check('digest-written', 'block', digestOk, digestOk ? 'OVERNIGHT.md present' : 'OVERNIGHT.md missing/empty — run did not produce a review'));
+
+  // 2. graceful wrap-up — a missing wrap-up means the loop may have crashed.
+  if (wrapupSeen !== null) {
+    checks.push(check('graceful-wrapup', 'block', wrapupSeen === true, wrapupSeen ? 'overnight_wrapup event recorded' : 'NO overnight_wrapup — run may have crashed mid-step'));
+  }
+
+  // 3. local-only — commits exist but nothing pushed beyond upstream (best-effort).
+  const ahead = git('rev-list --count @{upstream}..HEAD', rootDir);
+  if (ahead !== null) {
+    checks.push(check('local-commits', 'warn', true, `${ahead} local commit(s) ahead of upstream — push is the human's job`));
+  }
+
+  const ok = checks.filter((c) => c.severity === 'block').every((c) => c.ok);
+  return { ok, checks };
+}

package/src/lib/config.mjs

@@ -61,6 +61,15 @@ export function buildConfig({ projectName, language, depth, roles }) {
     },
     workflow: {
       default_depth: depth,
+      // Trust Mode (ADR-0022) — opt-in gate auto-approval. Off by default;
+      // present so the shape is discoverable. Guards + Critical findings are
+      // never relaxed regardless of these flags.
+      trust: {
+        enabled: false,
+        auto_approve: { scope: false, plan: false, changes: false },
+        max_auto_subtasks: 0,
+        require_evidence: false,
+      },
     },
     team: {
       roles: roles,
@@ -103,6 +112,53 @@ export function getToolkitVersions(config) {
   };
 }
 
+// Named trust profiles (ADR-0023 follow-up) — a profile is a bundle of defaults
+// answering "what does this run's trust posture look like?" Explicit keys still
+// override the profile, so it's purely a convenience layer.
+export const TRUST_PROFILES = {
+  // Vibe-coder overnight default: trust all convenience gates, bounded, and
+  // require evidence on GATE D so the unattended changes-approval is backed by
+  // a real test/review basis (safe path = easy path for the overnight audience).
+  'solo-night': { enabled: true, auto_approve: { scope: true, plan: true, changes: true }, max_auto_subtasks: 8, require_evidence: true },
+  // Team velocity without waiving diff review: plan auto, every diff still human.
+  'reviewed-team': { enabled: true, auto_approve: { scope: true, plan: true, changes: false }, max_auto_subtasks: 4 },
+};
+
+/**
+ * Trust Mode config for `dw:flow` gate auto-approval (ADR-0022).
+ * Off by default and back-compat: absent keys → fully manual gates, i.e.
+ * byte-for-byte today's behaviour. A `profile` supplies defaults that explicit
+ * keys override. Falls back to safe defaults so older config keeps working.
+ */
+export function getTrustConfig(config) {
+  const t = config?.workflow?.trust || {};
+  const profile = t.profile && TRUST_PROFILES[t.profile] ? t.profile : null;
+  const base = profile ? TRUST_PROFILES[profile] : { enabled: false, auto_approve: {}, max_auto_subtasks: 0 };
+  const a = t.auto_approve || {};
+  const baseA = base.auto_approve || {};
+  // explicit `enabled` wins; else the profile's; else off.
+  const enabled = t.enabled !== undefined ? t.enabled === true : base.enabled === true;
+  // explicit gate key wins; else the profile's; else off. Honoured only when enabled.
+  const gate = (key) => enabled && (a[key] !== undefined ? a[key] === true : baseA[key] === true);
+  return {
+    enabled,
+    profile,
+    auto_approve: {
+      scope: gate('scope'), // GATE A / Q1
+      plan: gate('plan'), // GATE C
+      changes: gate('changes'), // GATE D (never when Critical)
+    },
+    // 0 = unbounded once enabled; >0 caps an unattended run's length.
+    max_auto_subtasks: Number.isInteger(t.max_auto_subtasks) && t.max_auto_subtasks > 0
+      ? t.max_auto_subtasks
+      : (base.max_auto_subtasks || 0),
+    // When true, GATE D refuses to auto-approve without an --evidence object —
+    // makes the safe (evidence-backed) outcome the default for `changes`.
+    // Explicit key wins; else the profile's default; else off.
+    require_evidence: t.require_evidence !== undefined ? t.require_evidence === true : base.require_evidence === true,
+  };
+}
+
 /**
  * Renderer config for /dw:review --visual + `dw review render` (ADR-0007).
  * Falls back to defaults when keys are absent so existing projects work

package/src/lib/event-schema.mjs

@@ -205,6 +205,34 @@ export const EVENT_CATALOGUE = {
     required: { goal_id: 'string', task_id: 'string' },
     optional: {},
   },
+
+  // §5.6 Trust Mode & Overnight Autopilot (ADR-0022/0023) — written to
+  // events-global.jsonl; consumed by the morning digest (overnight-digest@v1).
+  gate_auto_approved: {
+    category: 'trust-autopilot',
+    required: { gate: 'string', actor: 'string' },
+    optional: { task: 'any', reason: 'any', evidence: 'any' },
+  },
+  subtask_completed: {
+    category: 'trust-autopilot',
+    required: { subtask: 'string' },
+    optional: { commit: 'string', summary: 'string' },
+  },
+  parked: {
+    category: 'trust-autopilot',
+    required: { item: 'string', question: 'string' },
+    optional: { options: 'string[]' },
+  },
+  hard_stop: {
+    category: 'trust-autopilot',
+    required: { reason: 'string' },
+    optional: { gate: 'string', blocker: 'string' },
+  },
+  overnight_wrapup: {
+    category: 'trust-autopilot',
+    required: { stop_reason: 'string' },
+    optional: {},
+  },
 };
 
 export const KNOWN_EVENTS = Object.freeze(Object.keys(EVENT_CATALOGUE));