dw-kit 1.9.2 → 1.10.0

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; }
+}