@harness-engineering/cli 1.24.3 → 1.25.1

package/dist/hooks/adoption-tracker.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+// adoption-tracker.js — Stop:* hook
+// Reads .harness/events.jsonl, reconstructs skill invocations,
+// appends SkillInvocationRecord entries to .harness/metrics/adoption.jsonl.
+// Exit codes: 0 = allow (always, log-only hook)
+
+import { readFileSync, mkdirSync, appendFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+
+/** Read and parse a JSON file, returning null on any error. */
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/** Check if adoption tracking is enabled in harness.config.json. */
+function isAdoptionEnabled(cwd) {
+  const config = readJsonSafe(join(cwd, 'harness.config.json'));
+  if (!config) return true; // default: enabled
+  if (config.adoption && config.adoption.enabled === false) return false;
+  return true;
+}
+
+/** Parse events.jsonl into an array of event objects. Skips malformed lines. */
+function parseEventsFile(eventsPath) {
+  let raw;
+  try {
+    raw = readFileSync(eventsPath, 'utf-8');
+  } catch {
+    return [];
+  }
+
+  const events = [];
+  const lines = raw.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed.skill && parsed.type && parsed.timestamp) {
+        events.push(parsed);
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+  return events;
+}
+
+/** Relevant event types for adoption tracking. */
+const RELEVANT_TYPES = new Set(['phase_transition', 'gate_result', 'handoff', 'error']);
+
+/** Derive outcome from a skill's events. */
+function deriveOutcome(events) {
+  const hasHandoff = events.some((e) => e.type === 'handoff');
+  const hasError = events.some((e) => e.type === 'error');
+
+  // Check for final phase (VALIDATE is the conventional final phase)
+  const phases = events
+    .filter((e) => e.type === 'phase_transition')
+    .map((e) => (e.data && e.data.to) || '')
+    .filter(Boolean);
+  const hasFinalPhase = phases.some(
+    (p) => p.toLowerCase() === 'validate' || p.toLowerCase() === 'complete'
+  );
+
+  if (hasHandoff || hasFinalPhase) return 'completed';
+  if (hasError) return 'failed';
+  return 'abandoned';
+}
+
+/** Derive phases reached from phase_transition events. */
+function derivePhasesReached(events) {
+  const phases = [];
+  const seen = new Set();
+  for (const event of events) {
+    if (event.type === 'phase_transition' && event.data && event.data.to) {
+      const phase = event.data.to;
+      if (!seen.has(phase)) {
+        seen.add(phase);
+        phases.push(phase);
+      }
+    }
+  }
+  return phases;
+}
+
+/** Derive duration in ms from first to last event timestamp. */
+function deriveDuration(events) {
+  if (events.length < 2) return 0;
+  const timestamps = events.map((e) => new Date(e.timestamp).getTime()).filter((t) => !isNaN(t));
+  if (timestamps.length < 2) return 0;
+  const min = Math.min(...timestamps);
+  const max = Math.max(...timestamps);
+  return max - min;
+}
+
+function main() {
+  let raw = '';
+  try {
+    raw = readFileSync(0, 'utf-8');
+  } catch {
+    process.exit(0);
+  }
+
+  if (!raw.trim()) {
+    process.exit(0);
+  }
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.stderr.write('[adoption-tracker] Could not parse stdin — skipping\n');
+    process.exit(0);
+  }
+
+  try {
+    const cwd = process.cwd();
+
+    // Check config
+    if (!isAdoptionEnabled(cwd)) {
+      process.stderr.write('[adoption-tracker] Adoption tracking disabled — skipping\n');
+      process.exit(0);
+    }
+
+    // Read events.jsonl
+    const eventsPath = join(cwd, '.harness', 'events.jsonl');
+    if (!existsSync(eventsPath)) {
+      process.stderr.write('[adoption-tracker] No events.jsonl found — skipping\n');
+      process.exit(0);
+    }
+
+    const allEvents = parseEventsFile(eventsPath);
+    // Filter to relevant event types
+    const relevantEvents = allEvents.filter((e) => RELEVANT_TYPES.has(e.type));
+    if (relevantEvents.length === 0) {
+      process.stderr.write('[adoption-tracker] No relevant skill events — skipping\n');
+      process.exit(0);
+    }
+
+    // Group events by skill
+    const skillGroups = new Map();
+    for (const event of relevantEvents) {
+      if (!skillGroups.has(event.skill)) {
+        skillGroups.set(event.skill, []);
+      }
+      skillGroups.get(event.skill).push(event);
+    }
+
+    // Reconstruct invocation records
+    const sessionId = input.session_id ?? 'unknown';
+    const metricsDir = join(cwd, '.harness', 'metrics');
+    mkdirSync(metricsDir, { recursive: true });
+    const adoptionFile = join(metricsDir, 'adoption.jsonl');
+
+    let written = 0;
+    for (const [skill, events] of skillGroups) {
+      // Use all events for this skill (including non-relevant) for timing
+      const allSkillEvents = allEvents.filter((e) => e.skill === skill);
+
+      const record = {
+        skill,
+        session: sessionId,
+        startedAt: allSkillEvents[0]?.timestamp ?? events[0].timestamp,
+        duration: deriveDuration(allSkillEvents.length > 0 ? allSkillEvents : events),
+        outcome: deriveOutcome(events),
+        phasesReached: derivePhasesReached(events),
+      };
+
+      appendFileSync(adoptionFile, JSON.stringify(record) + '\n');
+      written++;
+    }
+
+    process.stderr.write(
+      `[adoption-tracker] Wrote ${written} adoption record(s) for session ${sessionId}\n`
+    );
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(`[adoption-tracker] Failed: ${err.message}\n`);
+    process.exit(0);
+  }
+}
+
+main();

package/dist/hooks/block-no-verify.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+// block-no-verify.js — PreToolUse:Bash hook
+// Blocks git commands that use --no-verify to skip hooks.
+// Exit codes: 0 = allow, 2 = block
+
+import { readFileSync } from 'node:fs';
+import process from 'node:process';
+
+function main() {
+  let raw = '';
+  try {
+    raw = readFileSync(0, 'utf-8');
+  } catch {
+    // No stdin or read error — fail open
+    process.exit(0);
+  }
+
+  if (!raw.trim()) {
+    process.exit(0);
+  }
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    // Malformed JSON — fail open
+    process.exit(0);
+  }
+
+  try {
+    const command = input?.tool_input?.command ?? '';
+    if (typeof command !== 'string') {
+      process.exit(0);
+    }
+
+    if (/--no-verify/.test(command) || /\bgit\b.*\bcommit\b.*\s-n\b/.test(command)) {
+      process.stderr.write(
+        'BLOCKED: --no-verify flag detected. Hooks must not be bypassed.\n'
+      );
+      process.exit(2);
+    }
+
+    process.exit(0);
+  } catch {
+    // Unexpected error — fail open
+    process.exit(0);
+  }
+}
+
+main();

package/dist/hooks/cost-tracker.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+// cost-tracker.js — Stop:* hook
+// Appends token usage to .harness/metrics/costs.jsonl.
+// Exit codes: 0 = allow (always, log-only hook)
+
+import { readFileSync, mkdirSync, appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+
+function main() {
+  let raw = '';
+  try {
+    raw = readFileSync(0, 'utf-8');
+  } catch {
+    process.exit(0);
+  }
+
+  if (!raw.trim()) {
+    process.exit(0);
+  }
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.stderr.write('[cost-tracker] Could not parse stdin — skipping\n');
+    process.exit(0);
+  }
+
+  try {
+    const cwd = process.cwd();
+    const metricsDir = join(cwd, '.harness', 'metrics');
+
+    mkdirSync(metricsDir, { recursive: true });
+
+    const entry = {
+      timestamp: new Date().toISOString(),
+      session_id: input.session_id ?? null,
+      token_usage: input.token_usage ?? null,
+      model: input.model ?? null,
+    };
+
+    // Pass through cache token fields (prefer camelCase input, fall back to snake_case)
+    if (input.cacheCreationTokens != null) {
+      entry.cacheCreationTokens = input.cacheCreationTokens;
+    } else if (input.cache_creation_tokens != null) {
+      entry.cacheCreationTokens = input.cache_creation_tokens;
+    }
+    if (input.cacheReadTokens != null) {
+      entry.cacheReadTokens = input.cacheReadTokens;
+    } else if (input.cache_read_tokens != null) {
+      entry.cacheReadTokens = input.cache_read_tokens;
+    }
+
+    const costsFile = join(metricsDir, 'costs.jsonl');
+    appendFileSync(costsFile, JSON.stringify(entry) + '\n');
+
+    process.stderr.write(`[cost-tracker] Logged cost entry for session ${entry.session_id}\n`);
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(`[cost-tracker] Failed to log costs: ${err.message}\n`);
+    process.exit(0);
+  }
+}
+
+main();

package/dist/hooks/pre-compact-state.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+// pre-compact-state.js — PreCompact:* hook
+// Saves a compact session summary before context compaction.
+// Reads from .harness/state.json and .harness/sessions/ to gather context.
+// Writes to .harness/state/pre-compact-summary.json (overwrites on each run).
+// Fail-open: parse errors and unexpected exceptions log to stderr and exit 0.
+// Exit codes: 0 = allow (always, log-only hook)
+
+import { readFileSync, mkdirSync, writeFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function findActiveSession(sessionsDir) {
+  try {
+    const entries = readdirSync(sessionsDir, { withFileTypes: true });
+    // Look for the most recently modified session with an autopilot-state.json
+    let latest = null;
+    let latestMtime = 0;
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const statePath = join(sessionsDir, entry.name, 'autopilot-state.json');
+      try {
+        const stat = statSync(statePath);
+        if (stat.mtimeMs > latestMtime) {
+          latestMtime = stat.mtimeMs;
+          latest = { dir: entry.name, state: readJsonSafe(statePath) };
+        }
+      } catch {
+        // No autopilot-state.json in this session
+      }
+    }
+    return latest;
+  } catch {
+    return null;
+  }
+}
+
+function main() {
+  let raw = '';
+  try {
+    raw = readFileSync(0, 'utf-8');
+  } catch {
+    process.stderr.write('[pre-compact-state] Could not read stdin — allowing (fail-open)\n');
+    process.exit(0);
+  }
+
+  if (!raw.trim()) {
+    process.stderr.write('[pre-compact-state] Empty stdin — allowing (fail-open)\n');
+    process.exit(0);
+  }
+
+  try {
+    JSON.parse(raw); // validate stdin is JSON
+  } catch {
+    process.stderr.write('[pre-compact-state] Could not parse stdin — allowing (fail-open)\n');
+    process.exit(0);
+  }
+
+  try {
+    const cwd = process.cwd();
+    const harnessDir = join(cwd, '.harness');
+    const stateDir = join(harnessDir, 'state');
+
+    // Read harness state
+    const state = readJsonSafe(join(harnessDir, 'state.json'));
+
+    // Find active session
+    const session = findActiveSession(join(harnessDir, 'sessions'));
+
+    // Extract recent decisions (last 5)
+    const decisions = state?.decisions ?? [];
+    const recentDecisions = decisions.slice(-5).map((d) =>
+      typeof d === 'string' ? d : (d?.decision ?? d?.summary ?? JSON.stringify(d))
+    );
+
+    // Extract open questions / blockers
+    const openQuestions = state?.blockers ?? [];
+
+    // Determine current phase from session state
+    const currentPhase = session?.state?.currentState
+      ?? (state?.position?.phase ?? null);
+
+    // Build summary
+    const summary = {
+      timestamp: new Date().toISOString(),
+      sessionId: session?.dir ?? null,
+      activeStream: session?.state?.currentState ?? null,
+      recentDecisions,
+      openQuestions,
+      currentPhase,
+    };
+
+    mkdirSync(stateDir, { recursive: true });
+    writeFileSync(
+      join(stateDir, 'pre-compact-summary.json'),
+      JSON.stringify(summary, null, 2) + '\n'
+    );
+
+    process.stderr.write('[pre-compact-state] Saved pre-compact summary\n');
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(`[pre-compact-state] Failed to save summary: ${String(err?.message ?? err)}\n`);
+    process.exit(0);
+  }
+}
+
+main();

package/dist/hooks/profiles.ts

@@ -0,0 +1,48 @@
+/**
+ * Hook profile definitions.
+ *
+ * Profiles are additive: each higher tier includes all hooks from lower tiers.
+ * - minimal: safety floor (block-no-verify only)
+ * - standard: + protect-config, quality-gate, pre-compact-state (default)
+ * - strict: + cost-tracker, sentinel-pre, sentinel-post
+ */
+
+export type HookProfile = 'minimal' | 'standard' | 'strict';
+
+export interface HookScript {
+  /** Script filename without .js extension */
+  name: string;
+  /** Claude Code hook event */
+  event: 'PreToolUse' | 'PostToolUse' | 'PreCompact' | 'Stop';
+  /** Tool matcher pattern */
+  matcher: string;
+  /** Minimum profile tier that includes this hook */
+  minProfile: HookProfile;
+}
+
+export const HOOK_SCRIPTS: HookScript[] = [
+  { name: 'block-no-verify', event: 'PreToolUse', matcher: 'Bash', minProfile: 'minimal' },
+  { name: 'protect-config', event: 'PreToolUse', matcher: 'Write|Edit', minProfile: 'standard' },
+  { name: 'quality-gate', event: 'PostToolUse', matcher: 'Edit|Write', minProfile: 'standard' },
+  { name: 'pre-compact-state', event: 'PreCompact', matcher: '*', minProfile: 'standard' },
+  { name: 'adoption-tracker', event: 'Stop', matcher: '*', minProfile: 'standard' },
+  { name: 'telemetry-reporter', event: 'Stop', matcher: '*', minProfile: 'standard' },
+  { name: 'cost-tracker', event: 'Stop', matcher: '*', minProfile: 'strict' },
+  { name: 'sentinel-pre', event: 'PreToolUse', matcher: '*', minProfile: 'strict' },
+  { name: 'sentinel-post', event: 'PostToolUse', matcher: '*', minProfile: 'strict' },
+];
+
+const PROFILE_ORDER: HookProfile[] = ['minimal', 'standard', 'strict'];
+
+function hooksForProfile(profile: HookProfile): string[] {
+  const profileIndex = PROFILE_ORDER.indexOf(profile);
+  return HOOK_SCRIPTS.filter((h) => PROFILE_ORDER.indexOf(h.minProfile) <= profileIndex).map(
+    (h) => h.name
+  );
+}
+
+export const PROFILES: Record<HookProfile, string[]> = {
+  minimal: hooksForProfile('minimal'),
+  standard: hooksForProfile('standard'),
+  strict: hooksForProfile('strict'),
+};

package/dist/hooks/protect-config.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// protect-config.js — PreToolUse:Write/Edit hook
+// Blocks modifications to linter/formatter config files.
+// Fail-open: parse errors and unexpected exceptions log to stderr and exit 0.
+// Exit codes: 0 = allow, 2 = block
+
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+import process from 'node:process';
+
+// Protected config file patterns
+const PROTECTED_PATTERNS = [
+  /^\.eslintrc/,
+  /^eslint\.config\./,
+  /^\.prettierrc/,
+  /^prettier\.config\./,
+  /^biome\.json$/,
+  /^biome\.jsonc$/,
+  /^\.ruff\.toml$/,
+  /^ruff\.toml$/,
+  /^\.stylelintrc/,
+  /^\.markdownlint/,
+  /^deno\.json$/,
+];
+
+function isProtected(filePath) {
+  const base = basename(filePath);
+  return PROTECTED_PATTERNS.some((pattern) => pattern.test(base));
+}
+
+function main() {
+  let raw;
+  try {
+    raw = readFileSync(0, 'utf-8');
+  } catch {
+    process.stderr.write('[protect-config] Could not read stdin — allowing (fail-open)\n');
+    process.exit(0);
+  }
+
+  if (!raw.trim()) {
+    process.stderr.write('[protect-config] Empty stdin — allowing (fail-open)\n');
+    process.exit(0);
+  }
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.stderr.write('[protect-config] Could not parse stdin JSON — allowing (fail-open)\n');
+    process.exit(0);
+  }
+
+  try {
+    const filePath = input?.tool_input?.file_path;
+
+    if (typeof filePath !== 'string' || !filePath) {
+      process.stderr.write('[protect-config] Missing file_path in tool input — allowing (fail-open)\n');
+      process.exit(0);
+    }
+
+    if (isProtected(filePath)) {
+      process.stderr.write(
+        `BLOCKED: Modification to protected config file: ${basename(filePath)}. Linter/formatter configs must not be weakened.\n`
+      );
+      process.exit(2);
+    }
+
+    process.exit(0);
+  } catch {
+    process.stderr.write('[protect-config] Unexpected error — allowing (fail-open)\n');
+    process.exit(0);
+  }
+}
+
+main();

package/dist/hooks/quality-gate.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+// quality-gate.js — PostToolUse:Edit/Write hook
+// Runs project formatter/linter after edits and warns on violations.
+// Never blocks (always exits 0). Warnings go to stderr.
+// Exit codes: 0 = allow (always)
+
+import { readFileSync, accessSync } from 'node:fs';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import process from 'node:process';
+
+// Detection order: first match wins
+const DETECTORS = [
+  {
+    configs: ['biome.json', 'biome.jsonc'],
+    cmd: 'npx',
+    args: ['biome', 'check'],
+    name: 'Biome',
+  },
+  {
+    configs: [
+      '.prettierrc',
+      '.prettierrc.json',
+      '.prettierrc.yml',
+      '.prettierrc.yaml',
+      '.prettierrc.js',
+      '.prettierrc.cjs',
+      '.prettierrc.mjs',
+      'prettier.config.js',
+      'prettier.config.cjs',
+      'prettier.config.mjs',
+    ],
+    cmd: 'npx',
+    args: ['prettier', '--check'],
+    name: 'Prettier',
+  },
+  {
+    configs: ['.ruff.toml', 'ruff.toml'],
+    cmd: 'ruff',
+    args: ['check'],
+    name: 'Ruff',
+  },
+];
+
+function detectFormatter(cwd) {
+  for (const detector of DETECTORS) {
+    for (const config of detector.configs) {
+      try {
+        accessSync(join(cwd, config));
+        return detector;
+      } catch {
+        // Config not found, try next
+      }
+    }
+  }
+  return null;
+}
+
+function main() {
+  let raw = '';
+  try {
+    raw = readFileSync(0, 'utf-8');
+  } catch {
+    process.exit(0);
+  }
+
+  if (!raw.trim()) {
+    process.exit(0);
+  }
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  try {
+    const filePath = input?.tool_input?.file_path ?? '';
+    const cwd = process.cwd();
+
+    // Special case: .go files use gofmt
+    if (typeof filePath === 'string' && filePath.endsWith('.go')) {
+      try {
+        const result = execFileSync('gofmt', ['-l', filePath], {
+          encoding: 'utf-8',
+          cwd,
+          timeout: 10000,
+        });
+        if (result.trim()) {
+          process.stderr.write(
+            `[quality-gate] gofmt found formatting issues in: ${result.trim()}\n`
+          );
+        }
+      } catch {
+        // gofmt not available or failed — warn and continue
+        process.stderr.write('[quality-gate] gofmt check failed (tool may not be installed)\n');
+      }
+      process.exit(0);
+    }
+
+    const detector = detectFormatter(cwd);
+    if (!detector) {
+      // No formatter detected — nothing to check
+      process.exit(0);
+    }
+
+    try {
+      execFileSync(detector.cmd, detector.args, {
+        encoding: 'utf-8',
+        cwd,
+        timeout: 30000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      process.stderr.write(`[quality-gate] ${detector.name} check passed\n`);
+    } catch (err) {
+      // Formatter found violations or failed to run — warn only
+      const output = err.stdout || err.stderr || '';
+      process.stderr.write(
+        `[quality-gate] ${detector.name} check reported issues:\n${output.slice(0, 500)}\n`
+      );
+    }
+
+    process.exit(0);
+  } catch {
+    // Unexpected error — fail open
+    process.exit(0);
+  }
+}
+
+main();