dw-kit 1.2.1 → 1.3.0

package/src/commands/metrics.mjs

@@ -0,0 +1,165 @@
+import { readEvents, summarize } from '../lib/telemetry.mjs';
+import { analyze, THRESHOLDS } from '../lib/cut-analysis.mjs';
+import { banner, log, info, warn, ok, err } from '../lib/ui.mjs';
+import chalk from 'chalk';
+
+export async function metricsCommand(opts) {
+  const sub = opts.sub || 'show';
+
+  if (sub === 'show') {
+    return showMetrics(opts);
+  }
+  if (sub === 'cut-analysis') {
+    return cutAnalysisReport(opts);
+  }
+  if (sub === 'clear') {
+    warn('Use `rm .dw/metrics/events.jsonl` to clear manually. Telemetry is append-only.');
+    return;
+  }
+  warn(`Unknown subcommand: ${sub}. Available: show | cut-analysis | clear`);
+}
+
+function showMetrics(opts) {
+  banner('dw-kit Telemetry — Local Events');
+
+  if (process.env.DW_NO_TELEMETRY === '1' || process.env.DW_NO_TELEMETRY === 'true') {
+    warn('Telemetry is disabled (DW_NO_TELEMETRY=1).');
+    log('No events are being collected.');
+    return;
+  }
+
+  const events = readEvents(process.cwd(), {
+    since: opts.since,
+    filterName: opts.skill,
+  });
+
+  if (events.length === 0) {
+    info('No telemetry events recorded yet.');
+    log('Events will be logged as you use dw-kit skills and hooks.');
+    log('Storage: .dw/metrics/events.jsonl (local, append-only, zero network)');
+    return;
+  }
+
+  const s = summarize(events);
+  log('');
+  log(chalk.bold(`Total events: ${s.totalEvents}`));
+  if (s.dateRange) {
+    log(`Range: ${s.dateRange.from.slice(0, 10)} → ${s.dateRange.to.slice(0, 10)}`);
+  }
+  log('');
+
+  if (Object.keys(s.bySkill).length > 0) {
+    log(chalk.bold('Skills invoked:'));
+    const skillsSorted = Object.entries(s.bySkill).sort((a, b) => b[1] - a[1]);
+    for (const [name, count] of skillsSorted) {
+      log(`  ${count.toString().padStart(4)}× /${name}`);
+    }
+    log('');
+  }
+
+  if (Object.keys(s.byHook).length > 0) {
+    log(chalk.bold('Hooks fired:'));
+    const hooksSorted = Object.entries(s.byHook).sort((a, b) => b[1] - a[1]);
+    for (const [name, count] of hooksSorted) {
+      log(`  ${count.toString().padStart(4)}× ${name}`);
+    }
+    log('');
+  }
+
+  if (Object.keys(s.byTask).length > 0) {
+    log(chalk.bold('Task actions:'));
+    for (const [action, count] of Object.entries(s.byTask)) {
+      log(`  ${count.toString().padStart(4)}× ${action}`);
+    }
+    log('');
+  }
+
+  info('Privacy: all data is local. Set DW_NO_TELEMETRY=1 to disable.');
+}
+
+function cutAnalysisReport(opts) {
+  banner('dw-kit Cut-Analysis — ADR-0001 Cut Criteria Matrix');
+
+  if (process.env.DW_NO_TELEMETRY === '1' || process.env.DW_NO_TELEMETRY === 'true') {
+    warn('Telemetry disabled — no data to analyze.');
+    return;
+  }
+
+  const events = readEvents(process.cwd(), { since: opts.since });
+  if (events.length === 0) {
+    info('No telemetry events recorded — nothing to analyze.');
+    return;
+  }
+
+  const result = analyze(events);
+  const { coverage, skills, hooks, candidates } = result;
+
+  log('');
+  log(chalk.bold('Coverage'));
+  const covMsg = `  days=${coverage.days}  unique_sessions=${coverage.sessions}`;
+  log(covMsg);
+  if (!coverage.coverageOk) {
+    warn(`coverage_days=${coverage.days} < ${THRESHOLDS.skill.minCoverageDays} — skill cuts NOT recommended yet`);
+  } else {
+    ok(`coverage_days ≥ ${THRESHOLDS.skill.minCoverageDays} — eligible for skill evaluation`);
+  }
+  if (!coverage.devsOk) {
+    warn(`devs=${coverage.sessions} < ${THRESHOLDS.skill.minDevs} — skill cuts NOT recommended yet (session-hash is a proxy; may undercount)`);
+  }
+
+  log('');
+  log(chalk.bold('Skills (sorted by uses/week/dev, ascending)'));
+  if (skills.length === 0) {
+    log('  (no skill events)');
+  } else {
+    for (const r of skills) {
+      const rate = r.stats.usesPerWeekPerDev.toFixed(2);
+      const tag = r.qualify
+        ? chalk.red('CUT CANDIDATE')
+        : r.critical
+        ? chalk.cyan('protected')
+        : r.perProject
+        ? chalk.dim('per-project')
+        : chalk.green('keep');
+      log(`  ${tag.padEnd(24)} /${r.name.padEnd(24)} uses/wk/dev=${rate}  total=${r.stats.count}`);
+      for (const reason of r.reasons) log(chalk.dim(`      └─ ${reason}`));
+    }
+  }
+
+  log('');
+  log(chalk.bold('Hooks (sorted by fires/session, descending)'));
+  if (hooks.length === 0) {
+    log('  (no hook events)');
+  } else {
+    for (const r of hooks) {
+      const fires = r.stats.firesPerSession.toFixed(1);
+      const lat = r.stats.avgLatency !== null ? `${r.stats.avgLatency.toFixed(0)}ms` : 'n/a';
+      const tag = r.qualify ? chalk.red('CUT CANDIDATE') : chalk.green('keep');
+      log(`  ${tag.padEnd(24)} ${r.name.padEnd(24)} fires/session=${fires}  avg_latency=${lat}`);
+      for (const reason of r.reasons) log(chalk.dim(`      └─ ${reason}`));
+    }
+  }
+
+  log('');
+  log(chalk.bold('Summary'));
+  const skillCount = candidates.skills.length;
+  const hookCount = candidates.hooks.length;
+  if (skillCount === 0 && hookCount === 0) {
+    ok('No cut candidates — keep current surface.');
+  } else {
+    log(`  Skills flagged: ${skillCount}`);
+    log(`  Hooks flagged: ${hookCount}`);
+    log('');
+    info('Next steps:');
+    log('  1. Run team survey for qualitative check on flagged items (avoid false-positives).');
+    log('  2. For each confirmed cut → write ADR (`/dw:decision "Remove <name>"`).');
+    log('  3. Remove from .claude/hooks/ or .claude/skills/ + update .claude/settings.json.');
+    log('  4. Document in MIGRATION-v1.4.md with rollback instructions.');
+  }
+  log('');
+  info('Thresholds (from ADR-0001 Cut Criteria Matrix):');
+  log(`  Skill: uses/wk/dev < ${THRESHOLDS.skill.minUsesPerWeekPerDev} AND devs ≥ ${THRESHOLDS.skill.minDevs} AND coverage ≥ ${THRESHOLDS.skill.minCoverageDays}d`);
+  log(`  Hook:  avg_latency > ${THRESHOLDS.hook.maxAvgLatencyMs}ms OR fires/session > ${THRESHOLDS.hook.maxFiresPerSession}`);
+  log('');
+  info('Caveat: "devs" proxied by unique session hashes — undercounts real headcount.');
+}

package/src/lib/active-index.mjs

@@ -0,0 +1,87 @@
+import { readdirSync, readFileSync, existsSync, writeFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+const TASKS_DIR = '.dw/tasks';
+const ACTIVE_FILE = join(TASKS_DIR, 'ACTIVE.md');
+const EXCLUDE = new Set(['archive', 'ACTIVE.md']);
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const lines = match[1].split('\n');
+  const fm = {};
+  for (const line of lines) {
+    const kv = line.match(/^(\w+):\s*(.+)$/);
+    if (kv) fm[kv[1]] = kv[2].trim();
+  }
+  return fm;
+}
+
+function readTaskStatus(taskDir) {
+  const fullPath = join(TASKS_DIR, taskDir);
+  if (!statSync(fullPath).isDirectory()) return null;
+
+  const trackingV2 = join(fullPath, 'tracking.md');
+  if (existsSync(trackingV2)) {
+    const fm = parseFrontmatter(readFileSync(trackingV2, 'utf8'));
+    return {
+      name: taskDir,
+      status: fm.status || 'unknown',
+      lastUpdated: fm.last_updated || fm.started || '—',
+      blockers: fm.blockers || 'none',
+      format: 'v2',
+    };
+  }
+
+  const progressV1 = join(fullPath, `${taskDir}-progress.md`);
+  if (existsSync(progressV1)) {
+    const content = readFileSync(progressV1, 'utf8');
+    const statusMatch = content.match(/Trạng thái:\s*([^\n]+)/);
+    return {
+      name: taskDir,
+      status: statusMatch ? statusMatch[1].trim() : 'unknown',
+      lastUpdated: '—',
+      blockers: 'none',
+      format: 'v1',
+    };
+  }
+
+  return { name: taskDir, status: 'no-tracking', lastUpdated: '—', blockers: '—', format: 'unknown' };
+}
+
+export function generateActiveIndex(rootDir = process.cwd()) {
+  const tasksPath = join(rootDir, TASKS_DIR);
+  if (!existsSync(tasksPath)) return '';
+
+  const entries = readdirSync(tasksPath).filter((e) => !EXCLUDE.has(e));
+  const tasks = entries.map(readTaskStatus).filter(Boolean);
+
+  const today = new Date().toISOString().slice(0, 10);
+  const lines = [
+    '# ACTIVE Tasks',
+    '',
+    `Auto-generated ${today}. Run \`dw active\` to refresh.`,
+    '',
+    'Format: `{task-name} · {status} · {last-updated} · {blockers}`',
+    '',
+    '## Current',
+    '',
+    ...tasks.map(
+      (t) => `- \`${t.name}\` · ${t.status} · ${t.lastUpdated} · ${t.blockers}`
+    ),
+    '',
+    '## Archive',
+    '',
+    `Completed tasks: \`.dw/tasks/archive/\``,
+    '',
+  ];
+
+  return lines.join('\n');
+}
+
+export function writeActiveIndex(rootDir = process.cwd()) {
+  const content = generateActiveIndex(rootDir);
+  const target = join(rootDir, ACTIVE_FILE);
+  writeFileSync(target, content, 'utf8');
+  return target;
+}

package/src/lib/cut-analysis.mjs

@@ -0,0 +1,161 @@
+// Cut Criteria Matrix — implements ADR-0001 v1.4 decision gate.
+// Consumes telemetry events, emits cut candidates with evidence.
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+// Never-cut: skills that are the workflow's load-bearing verbs.
+export const CRITICAL_SKILLS = new Set([
+  'dw:flow', 'dw:task-init', 'dw:commit', 'dw:handoff',
+  'dw:execute', 'dw:plan', 'dw:research', 'dw:thinking',
+  'dw:review', 'dw:debug', 'dw:decision',
+]);
+
+// Per-project skills — evaluated separately (low cadence is expected).
+export const PER_PROJECT_SKILLS = new Set([
+  'dw:onboard', 'dw:retroactive', 'dw:config-init', 'dw:upgrade', 'dw:rollback',
+]);
+
+// Cut thresholds (ADR-0001 Cut Criteria Matrix)
+export const THRESHOLDS = {
+  skill: {
+    minUsesPerWeekPerDev: 5,
+    minDevs: 5,
+    minCoverageDays: 21,
+  },
+  hook: {
+    maxAvgLatencyMs: 500,
+    maxFiresPerSession: 10,
+  },
+};
+
+function coverageDays(events) {
+  if (events.length === 0) return 0;
+  const first = new Date(events[0].ts).getTime();
+  const last = new Date(events[events.length - 1].ts).getTime();
+  return Math.max(1, Math.round((last - first) / MS_PER_DAY));
+}
+
+function uniqueSessions(events) {
+  return new Set(events.map((e) => e.session).filter(Boolean)).size;
+}
+
+// Group events by (event type, name)
+function groupByNameAndType(events) {
+  const groups = { skill: {}, hook: {} };
+  for (const e of events) {
+    if (e.event !== 'skill' && e.event !== 'hook') continue;
+    const bucket = groups[e.event];
+    if (!bucket[e.name]) bucket[e.name] = [];
+    bucket[e.name].push(e);
+  }
+  return groups;
+}
+
+function skillStats(events, totalSessions, totalDays) {
+  const count = events.length;
+  const weeks = Math.max(1, totalDays / 7);
+  const devs = Math.max(1, totalSessions); // session-hash as dev proxy (undercounts real devs)
+  const usesPerWeekPerDev = count / weeks / devs;
+  return { count, usesPerWeekPerDev, weeks, devs };
+}
+
+function hookStats(events, totalSessions) {
+  const count = events.length;
+  const sessions = Math.max(1, totalSessions);
+  const firesPerSession = count / sessions;
+  const latencies = events.map((e) => e.latency_ms).filter((n) => typeof n === 'number');
+  const avgLatency =
+    latencies.length > 0 ? latencies.reduce((a, b) => a + b, 0) / latencies.length : null;
+  return { count, firesPerSession, avgLatency };
+}
+
+function evaluateSkill(name, events, totalSessions, totalDays) {
+  const s = skillStats(events, totalSessions, totalDays);
+  const reasons = [];
+  let critical = false;
+  let perProject = false;
+
+  if (CRITICAL_SKILLS.has(name)) {
+    critical = true;
+    reasons.push('critical path — protected');
+  }
+  if (PER_PROJECT_SKILLS.has(name)) {
+    perProject = true;
+    reasons.push('per-project cadence — evaluated separately');
+  }
+
+  const usesBelow = s.usesPerWeekPerDev < THRESHOLDS.skill.minUsesPerWeekPerDev;
+  const devsOk = totalSessions >= THRESHOLDS.skill.minDevs;
+  const coverageOk = totalDays >= THRESHOLDS.skill.minCoverageDays;
+
+  let qualify = false;
+  if (!critical && !perProject) {
+    if (usesBelow && devsOk && coverageOk) {
+      qualify = true;
+      reasons.push(
+        `uses/week/dev=${s.usesPerWeekPerDev.toFixed(2)} < ${THRESHOLDS.skill.minUsesPerWeekPerDev}`
+      );
+    } else {
+      if (!usesBelow) reasons.push(`uses/week/dev=${s.usesPerWeekPerDev.toFixed(2)} (above threshold)`);
+      if (!devsOk) reasons.push(`devs=${totalSessions} < ${THRESHOLDS.skill.minDevs}`);
+      if (!coverageOk) reasons.push(`coverage=${totalDays}d < ${THRESHOLDS.skill.minCoverageDays}d`);
+    }
+  }
+
+  return { name, type: 'skill', qualify, stats: s, reasons, critical, perProject };
+}
+
+function evaluateHook(name, events, totalSessions) {
+  const s = hookStats(events, totalSessions);
+  const reasons = [];
+  let qualify = false;
+
+  const latencyExceed =
+    s.avgLatency !== null && s.avgLatency > THRESHOLDS.hook.maxAvgLatencyMs;
+  const firesExceed = s.firesPerSession > THRESHOLDS.hook.maxFiresPerSession;
+
+  if (latencyExceed) {
+    qualify = true;
+    reasons.push(`avg_latency=${s.avgLatency.toFixed(0)}ms > ${THRESHOLDS.hook.maxAvgLatencyMs}ms`);
+  }
+  if (firesExceed) {
+    qualify = true;
+    reasons.push(
+      `fires/session=${s.firesPerSession.toFixed(1)} > ${THRESHOLDS.hook.maxFiresPerSession}`
+    );
+  }
+  if (!latencyExceed && !firesExceed) {
+    reasons.push(
+      `fires/session=${s.firesPerSession.toFixed(1)}, avg_latency=${s.avgLatency !== null ? s.avgLatency.toFixed(0) + 'ms' : 'n/a'} (within limits)`
+    );
+  }
+
+  return { name, type: 'hook', qualify, stats: s, reasons };
+}
+
+export function analyze(events) {
+  const totalSessions = uniqueSessions(events);
+  const totalDays = coverageDays(events);
+  const coverageOk = totalDays >= THRESHOLDS.skill.minCoverageDays;
+  const devsOk = totalSessions >= THRESHOLDS.skill.minDevs;
+
+  const groups = groupByNameAndType(events);
+
+  const skillResults = Object.entries(groups.skill)
+    .map(([name, evts]) => evaluateSkill(name, evts, totalSessions, totalDays))
+    .sort((a, b) => a.stats.usesPerWeekPerDev - b.stats.usesPerWeekPerDev);
+
+  const hookResults = Object.entries(groups.hook)
+    .map(([name, evts]) => evaluateHook(name, evts, totalSessions))
+    .sort((a, b) => b.stats.firesPerSession - a.stats.firesPerSession);
+
+  return {
+    coverage: { days: totalDays, sessions: totalSessions, coverageOk, devsOk },
+    skills: skillResults,
+    hooks: hookResults,
+    candidates: {
+      skills: skillResults.filter((r) => r.qualify),
+      hooks: hookResults.filter((r) => r.qualify),
+    },
+  };
+}

package/src/lib/telemetry.mjs

@@ -0,0 +1,80 @@
+import { appendFileSync, existsSync, readFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { createHash } from 'node:crypto';
+
+const METRICS_DIR = '.dw/metrics';
+const EVENTS_FILE = 'events.jsonl';
+
+function isDisabled() {
+  return process.env.DW_NO_TELEMETRY === '1' || process.env.DW_NO_TELEMETRY === 'true';
+}
+
+function sessionHash() {
+  const pid = process.pid;
+  const start = process.env.DW_SESSION_START || Date.now();
+  return createHash('sha256').update(`${pid}:${start}`).digest('hex').slice(0, 8);
+}
+
+function ensureMetricsDir(rootDir) {
+  const dir = join(rootDir, METRICS_DIR);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return join(dir, EVENTS_FILE);
+}
+
+export function logEvent(event, rootDir = process.cwd()) {
+  if (isDisabled()) return false;
+
+  try {
+    const enriched = {
+      ts: new Date().toISOString(),
+      session: sessionHash(),
+      ...event,
+    };
+    const target = ensureMetricsDir(rootDir);
+    appendFileSync(target, JSON.stringify(enriched) + '\n', 'utf8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function readEvents(rootDir = process.cwd(), { since, filterName, eventType } = {}) {
+  const target = join(rootDir, METRICS_DIR, EVENTS_FILE);
+  if (!existsSync(target)) return [];
+
+  const lines = readFileSync(target, 'utf8').split('\n').filter(Boolean);
+  const events = [];
+  for (const line of lines) {
+    try {
+      const evt = JSON.parse(line);
+      if (since && evt.ts < since) continue;
+      if (filterName && evt.name !== filterName) continue;
+      if (eventType && evt.event !== eventType) continue;
+      events.push(evt);
+    } catch {
+      // skip malformed
+    }
+  }
+  return events;
+}
+
+export function summarize(events) {
+  const bySkill = {};
+  const byHook = {};
+  const byTask = {};
+
+  for (const e of events) {
+    if (e.event === 'skill') bySkill[e.name] = (bySkill[e.name] || 0) + 1;
+    else if (e.event === 'hook') byHook[e.name] = (byHook[e.name] || 0) + 1;
+    else if (e.event === 'task') byTask[e.action || 'unknown'] = (byTask[e.action || 'unknown'] || 0) + 1;
+  }
+
+  return {
+    totalEvents: events.length,
+    bySkill,
+    byHook,
+    byTask,
+    dateRange:
+      events.length > 0 ? { from: events[0].ts, to: events[events.length - 1].ts } : null,
+  };
+}

package/.claude/rules/dw-core.md

@@ -1,100 +0,0 @@
-<!-- dw-kit | core: 1.2 -->
-# dw Workflow
-
-Config: `.dw/config/dw.config.yml`
-Full methodology: `.dw/core/WORKFLOW.md` · `.dw/core/THINKING.md` · `.dw/core/QUALITY.md` · `.dw/core/ROLES.md`
-
----
-
-## Override
-
-If the prompt contains `--no-dw`: ignore all dw instructions, work as plain Claude Code. Applies only to that request.
-
----
-
-## Depth Routing
-
-Read `workflow.default_depth` from config. Assess per task based on facts (file count, API changes, git blame) — not assumptions:
-
-| Scope | Depth | Approach |
-|-------|-------|----------|
-| ≤2 files, hotfix, familiar module | quick | Understand → Execute → Close |
-| 3–5 files, new module | standard | Full 6-phase |
-| 6+ files, API/DB/security changes | thorough | Full + arch-review + test-plan |
-
-When unsure → default to `standard`.
-
----
-
-## Session Start
-
-1. Read `.dw/config/dw.config.yml` — depth, roles, quality commands
-2. Check `.dw/tasks/` for active tasks; if one is in progress, resume from its `[task]-progress.md`
-
-> `session-init` hook auto-injects active task context — no manual action needed.
-
----
-
-## Task Docs
-
-For tasks spanning 3+ files, research → plan → approve → execute gives better outcomes.
-
-```
-.dw/tasks/[task-name]/
-├── [name]-context.md    # Research findings
-├── [name]-plan.md       # Implementation plan
-└── [name]-progress.md   # Progress + handoff notes
-```
-
----
-
-## Commit Format
-
-```
-<type>(<scope>): <description ≤72 chars>
-```
-
-Types: `feat` `fix` `refactor` `test` `docs` `chore` `style` `perf`
-
----
-
-## Hooks (v1.2)
-
-Auto-run — no user action needed:
-
-| Hook | Trigger | Effect |
-|------|---------|--------|
-| `session-init` | Session start | Inject active task context |
-| `scout-block` | Read/Glob | Block node_modules/, dist/, .git/ etc. |
-| `privacy-block` | Read | Block .env*, *.pem, credentials* |
-| `pre-commit-gate` | Bash (git commit) | Quality check + sensitive data scan |
-| `safety-guard` | Bash | Block destructive commands |
-| `post-write` | Write/Edit | Lint reminder |
-| `stop-check` | Stop | Warn on uncommitted changes + in-progress tasks |
-
----
-
-## Agent Reports (v1.2)
-
-For multi-phase tasks (standard/thorough), create reports for audit trail:
-
-```
-.dw/tasks/[task-name]/reports/[YYMMDD-HHMM]-from-[role]-to-[role]-[desc].md
-```
-
-Status: `DONE | DONE_WITH_CONCERNS | BLOCKED | NEEDS_CONTEXT`
-Template: `.claude/templates/agent-report.md` · Guide: `.dw/core/AGENTS.md`
-
----
-
-## Config Local Override (v1.2)
-
-`.dw/config/dw.config.local.yml` (gitignored) for machine-specific settings:
-
-```yaml
-claude:
-  models:
-    plan: "claude-opus-4-6"
-quality:
-  test_command: "npm test"
-```

package/.claude/rules/dw-skills.md

@@ -1,53 +0,0 @@
-<!-- dw-kit | core: 1.2 -->
-# dw Skills
-
-Invoke via Claude Code slash commands. Availability governed by config flags and `workflow.default_depth`.
-
-## Core Workflow
-
-| Skill | Description | Depth |
-|-------|-------------|-------|
-| `/dw-flow [task]` | Full workflow shortcut | all |
-| `/dw-task-init [name]` | Init task docs | all |
-| `/dw-research [name]` | Survey codebase | all |
-| `/dw-plan [name]` | Design plan (waits for approval) | standard+ |
-| `/dw-execute [name]` | Implement per plan (TDD) | all |
-| `/dw-commit [msg]` | Smart commit + quality gates | all |
-| `/dw-handoff` | Session handoff | all |
-
-## Dev
-
-| Skill | Description |
-|-------|-------------|
-| `/dw-debug [issue]` | Investigate → diagnose → fix |
-| `/dw-review` | Code review with checklist |
-| `/dw-thinking [question]` | Apply thinking framework |
-| `/dw-prompt [desc]` | Build structured prompt |
-| `/dw-docs-update` | Update living docs |
-
-## Role-Specific
-
-| Skill | Role | Description |
-|-------|------|-------------|
-| `/dw-requirements` | BA | Requirements + user stories |
-| `/dw-test-plan` | QC | Test plan + regression |
-| `/dw-arch-review` | TechLead | Architecture review |
-| `/dw-dashboard` | PM | Metrics report |
-| `/dw-sprint-review` | All | Retrospective |
-| `/dw-estimate [name]` | if enabled | Effort estimation |
-| `/dw-log-work [name]` | if enabled | Log actual effort |
-
-## Setup & Maintenance
-
-| Skill | Description |
-|-------|-------------|
-| `/dw-onboard` | Onboard dw to existing project (breadth-first scan) |
-| `/dw-retroactive [name]` | Document existing feature (depth-first) |
-| `/dw-config-init` | Initialize new config |
-| `/dw-config-validate` | Validate config file |
-| `/dw-upgrade` | Upgrade toolkit |
-| `/dw-rollback [name]` | Rollback task docs |
-| `/dw-archive [name]` | Archive completed task |
-| `/dw-kit-report [desc]` | Submit feedback/bug to GitHub |
-
-> **Maintainer-only** (TechLead, dw-kit repo): `/dw-kit-evolve [issue#]` · `/dw-kit-audit [days]`