switchboard-cli 0.1.0-alpha.3 → 0.1.0-alpha.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard-cli",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.4",
   "description": "Switchboard CLI — portable governance substrate for AI workflows",
   "license": "MIT",
   "bin": { "sb": "bin/switchboard.mjs", "switchboard": "bin/switchboard.mjs" },
@@ -8,8 +8,6 @@
   "engines": { "node": ">=18" },
   "bundleDependencies": ["@switchboard/core", "@switchboard/projections"],
   "dependencies": {
-    "@switchboard/core": "file:node_modules/@switchboard/core",
-    "@switchboard/projections": "file:node_modules/@switchboard/projections",
     "commander": "^13.1.0",
     "tsx": "^4.19.3",
     "yaml": "^2.7.0",

package/src/autoagent/boundary-check.spec.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect } from "vitest";
+import { buildBoundarySpec, checkBoundaryViolation } from "./boundary-check";
+import type { AutoAgentTier } from "./types";
+
+describe("buildBoundarySpec", () => {
+  const contract = {
+    task_clauses: {
+      scope_out: ["Live trading", "Multi-exchange"],
+    },
+    non_goals: ["Not a portfolio manager", "Not live-trading by default"],
+  };
+
+  it("code tier allows src/ only", () => {
+    const spec = buildBoundarySpec("code", contract as any);
+    expect(spec.modifiable).toContain("src/**");
+    expect(spec.frozen).toContain(".switchboard/**");
+    expect(spec.frozen).toContain("package.json");
+  });
+
+  it("harness tier allows src/ and config", () => {
+    const spec = buildBoundarySpec("harness", contract as any);
+    expect(spec.modifiable).toContain("src/**");
+    expect(spec.modifiable).toContain("*.config.*");
+  });
+
+  it("full tier allows most files", () => {
+    const spec = buildBoundarySpec("full", contract as any);
+    expect(spec.modifiable).toContain("src/**");
+    expect(spec.modifiable).toContain("package.json");
+  });
+
+  it("all tiers freeze contract and autoagent config", () => {
+    for (const tier of ["code", "harness", "full"] as AutoAgentTier[]) {
+      const spec = buildBoundarySpec(tier, contract as any);
+      expect(spec.frozen).toContain(".switchboard/project/contract.yaml");
+      expect(spec.frozen).toContain(".switchboard/autoagent/program.md");
+      expect(spec.frozen).toContain(".switchboard/autoagent/score.ts");
+    }
+  });
+});
+
+describe("checkBoundaryViolation", () => {
+  it("returns null when files are within boundary", () => {
+    const spec = {
+      tier: "code" as const,
+      modifiable: ["src/**"],
+      frozen: [".switchboard/**"],
+      contractNonGoals: [],
+    };
+    const result = checkBoundaryViolation(["src/index.ts", "src/lib/utils.ts"], spec);
+    expect(result).toBeNull();
+  });
+
+  it("returns violation when frozen file is touched", () => {
+    const spec = {
+      tier: "code" as const,
+      modifiable: ["src/**"],
+      frozen: [".switchboard/**", "package.json"],
+      contractNonGoals: [],
+    };
+    const result = checkBoundaryViolation(["src/index.ts", "package.json"], spec);
+    expect(result).not.toBeNull();
+    expect(result).toContain("package.json");
+  });
+
+  it("returns violation when file is outside modifiable scope", () => {
+    const spec = {
+      tier: "code" as const,
+      modifiable: ["src/**"],
+      frozen: [".switchboard/**"],
+      contractNonGoals: [],
+    };
+    const result = checkBoundaryViolation(["scripts/deploy.sh"], spec);
+    expect(result).not.toBeNull();
+    expect(result).toContain("scripts/deploy.sh");
+  });
+});

package/src/autoagent/boundary-check.ts

@@ -0,0 +1,102 @@
+import type { AutoAgentTier, BoundarySpec } from "./types";
+
+// ---------------------------------------------------------------------------
+// Build boundary spec from tier + contract
+// ---------------------------------------------------------------------------
+
+export function buildBoundarySpec(
+  tier: AutoAgentTier,
+  contract: { task_clauses?: { scope_out?: string[] }; non_goals?: string[] },
+): BoundarySpec {
+  // Files that are ALWAYS frozen regardless of tier
+  const alwaysFrozen = [
+    ".switchboard/project/contract.yaml",
+    ".switchboard/autoagent/program.md",
+    ".switchboard/autoagent/score.ts",
+    ".switchboard/autoagent/results.tsv",
+    "**/*.spec.ts",
+    "**/*.test.ts",
+  ];
+
+  let modifiable: string[];
+  let frozen: string[];
+
+  switch (tier) {
+    case "code":
+      modifiable = ["src/**"];
+      frozen = [...alwaysFrozen, ".switchboard/**", "package.json", "*.config.*", "tsconfig.json"];
+      break;
+
+    case "harness":
+      modifiable = ["src/**", "*.config.*", "tsconfig.json"];
+      frozen = [...alwaysFrozen, ".switchboard/**", "package.json"];
+      break;
+
+    case "full":
+      modifiable = ["src/**", "*.config.*", "tsconfig.json", "package.json"];
+      frozen = [...alwaysFrozen, ".switchboard/project/**", ".switchboard/autoagent/**"];
+      break;
+  }
+
+  const contractNonGoals = contract.non_goals ?? [];
+
+  return { tier, modifiable, frozen, contractNonGoals };
+}
+
+// ---------------------------------------------------------------------------
+// Check if changed files violate boundary
+// ---------------------------------------------------------------------------
+
+export function checkBoundaryViolation(
+  changedFiles: string[],
+  spec: BoundarySpec,
+): string | null {
+  const violations: string[] = [];
+
+  for (const file of changedFiles) {
+    // Check frozen files
+    if (matchesAny(file, spec.frozen)) {
+      violations.push(file);
+      continue;
+    }
+
+    // Check if file is within modifiable scope
+    if (!matchesAny(file, spec.modifiable)) {
+      violations.push(file);
+    }
+  }
+
+  if (violations.length === 0) return null;
+  return `Boundary violation: ${violations.join(", ")} are outside the ${spec.tier} tier scope`;
+}
+
+// ---------------------------------------------------------------------------
+// Simple glob matching (** = any path, * = any segment)
+// ---------------------------------------------------------------------------
+
+function matchesAny(file: string, patterns: string[]): boolean {
+  return patterns.some(pattern => matchGlob(file, pattern));
+}
+
+function matchGlob(file: string, pattern: string): boolean {
+  // Exact match
+  if (file === pattern) return true;
+
+  // ** matches any path depth
+  if (pattern.endsWith("/**")) {
+    const prefix = pattern.slice(0, -3);
+    return file.startsWith(prefix + "/") || file === prefix;
+  }
+  if (pattern.startsWith("**/")) {
+    const suffix = pattern.slice(3);
+    return file.endsWith(suffix) || file.includes("/" + suffix);
+  }
+
+  // * matches within a single segment
+  if (pattern.startsWith("*.")) {
+    const ext = pattern.slice(1);
+    return file.endsWith(ext) || file.includes(ext + ".");
+  }
+
+  return false;
+}

package/src/autoagent/loop.ts

@@ -0,0 +1,327 @@
+import { execSync } from "child_process";
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import type { AutoAgentConfig, AutoAgentState, IterationResult, BoundarySpec, ScoreResult } from "./types";
+import { DEFAULT_CONFIG } from "./types";
+import { buildBoundarySpec, checkBoundaryViolation } from "./boundary-check";
+import { ResultsLedger } from "./results";
+import { runTests, runScore, getChangedFiles, getShortCommit, gitRevert, gitCommit } from "./runner";
+import * as out from "../lib/output";
+
+// ---------------------------------------------------------------------------
+// AutoAgent Loop — the core iteration engine
+// ---------------------------------------------------------------------------
+
+export class AutoAgentLoop {
+  private config: AutoAgentConfig;
+  private repoRoot: string;
+  private state: AutoAgentState;
+  private ledger: ResultsLedger;
+  private boundary: BoundarySpec;
+  private programMd: string;
+  private stopped = false;
+
+  constructor(repoRoot: string, config: Partial<AutoAgentConfig>, contract: any) {
+    this.repoRoot = repoRoot;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.ledger = new ResultsLedger(join(repoRoot, ".switchboard", "autoagent", "results.tsv"));
+    this.boundary = buildBoundarySpec(this.config.tier, contract);
+
+    const programPath = join(repoRoot, ".switchboard", "autoagent", "program.md");
+    if (!existsSync(programPath)) {
+      throw new Error("Missing .switchboard/autoagent/program.md — write the directive first.");
+    }
+    this.programMd = readFileSync(programPath, "utf-8");
+
+    // Write boundary spec for subagent reference
+    const boundaryPath = join(repoRoot, ".switchboard", "autoagent", "boundaries.md");
+    mkdirSync(join(repoRoot, ".switchboard", "autoagent"), { recursive: true });
+    writeFileSync(boundaryPath, formatBoundaryDoc(this.boundary), "utf-8");
+
+    this.state = {
+      startedAt: Date.now(),
+      iteration: 0,
+      bestScore: 0,
+      bestCommit: "",
+      currentScore: 0,
+      results: [],
+      status: "running",
+    };
+  }
+
+  stop(): void {
+    this.stopped = true;
+  }
+
+  getState(): AutoAgentState {
+    return { ...this.state };
+  }
+
+  async run(): Promise<AutoAgentState> {
+    // Run initial score to establish baseline
+    out.info("Establishing baseline score...");
+    const baselineScore = await runScore(this.config.scoreCommand, this.repoRoot);
+    this.state.bestScore = baselineScore.score;
+    this.state.currentScore = baselineScore.score;
+    this.state.bestCommit = await getShortCommit(this.repoRoot);
+    out.success(`Baseline score: ${baselineScore.score.toFixed(4)} — ${baselineScore.summary}`);
+
+    while (!this.shouldStop()) {
+      this.state.iteration++;
+      out.heading(`Iteration ${this.state.iteration}`);
+
+      const iterStart = Date.now();
+
+      try {
+        const result = await this.runIteration();
+        result.durationMs = Date.now() - iterStart;
+        this.state.results.push(result);
+        this.ledger.append(result);
+
+        if (result.status === "keep") {
+          out.success(`KEEP: ${result.description} (${result.prevScore.toFixed(4)} → ${result.score.toFixed(4)})`);
+          this.state.currentScore = result.score;
+          if (result.score > this.state.bestScore) {
+            this.state.bestScore = result.score;
+            this.state.bestCommit = result.commit;
+          }
+        } else {
+          out.warn(`DISCARD: ${result.description} (${result.status})`);
+        }
+      } catch (err: any) {
+        out.fail(`Iteration error: ${err.message}`);
+        this.ledger.append({
+          iteration: this.state.iteration,
+          commit: await getShortCommit(this.repoRoot),
+          score: this.state.currentScore,
+          prevScore: this.state.currentScore,
+          testsPass: false,
+          testSummary: "error",
+          status: "crash",
+          description: err.message.slice(0, 100),
+          filesChanged: [],
+          timestamp: Date.now(),
+          durationMs: Date.now() - iterStart,
+        });
+      }
+    }
+
+    return this.state;
+  }
+
+  private async runIteration(): Promise<IterationResult> {
+    const prevScore = this.state.currentScore;
+
+    // 1. DIAGNOSE — read previous results, find what to improve
+    const diagnosis = this.buildDiagnosis();
+
+    // 2. MODIFY — dispatch subagent to make one change
+    out.info("Dispatching modification subagent...");
+    const modPrompt = this.buildModifyPrompt(diagnosis);
+
+    // Execute modification via a shell command that invokes Claude
+    // For now, write the prompt to a file and let the caller handle dispatch
+    const promptPath = join(this.repoRoot, ".switchboard", "autoagent", "current-prompt.md");
+    writeFileSync(promptPath, modPrompt, "utf-8");
+
+    // The actual modification happens via the subagent dispatched by the CLI command
+    // For the loop module, we simulate by checking if files changed
+    out.info("Subagent should modify files based on the prompt at:");
+    out.info(promptPath);
+    out.info("Waiting for changes...");
+
+    // In practice, the CLI command's action handler dispatches the Agent tool
+    // and this loop continues after the agent returns. For now, return a
+    // placeholder that the CLI command fills in.
+    return {
+      iteration: this.state.iteration,
+      commit: "",
+      score: 0,
+      prevScore,
+      testsPass: false,
+      testSummary: "",
+      status: "discard",
+      description: "placeholder — filled by CLI orchestrator",
+      filesChanged: [],
+      timestamp: Date.now(),
+      durationMs: 0,
+    };
+  }
+
+  // Called by the CLI command after the subagent completes
+  async evaluateChanges(description: string): Promise<IterationResult> {
+    const prevScore = this.state.currentScore;
+    const iterStart = Date.now();
+
+    // 3. BOUNDARY CHECK
+    const changedFiles = await getChangedFiles(this.repoRoot);
+    const violation = checkBoundaryViolation(changedFiles, this.boundary);
+    if (violation) {
+      out.fail(`Boundary violation: ${violation}`);
+      await gitRevert(this.repoRoot);
+      return {
+        iteration: this.state.iteration,
+        commit: await getShortCommit(this.repoRoot),
+        score: prevScore,
+        prevScore,
+        testsPass: false,
+        testSummary: "boundary-violation",
+        status: "boundary-violation",
+        description: violation.slice(0, 100),
+        filesChanged: changedFiles,
+        timestamp: Date.now(),
+        durationMs: Date.now() - iterStart,
+      };
+    }
+
+    // 4. TEST — hard gate
+    out.info("Running tests...");
+    const testResult = await runTests(this.config.testCommand, this.repoRoot);
+    if (!testResult.passed) {
+      out.fail("Tests failed — discarding");
+      await gitRevert(this.repoRoot);
+      return {
+        iteration: this.state.iteration,
+        commit: await getShortCommit(this.repoRoot),
+        score: prevScore,
+        prevScore,
+        testsPass: false,
+        testSummary: "FAIL",
+        status: "discard",
+        description: `tests failed: ${description}`,
+        filesChanged: changedFiles,
+        timestamp: Date.now(),
+        durationMs: Date.now() - iterStart,
+      };
+    }
+
+    // 5. SCORE
+    out.info("Running score function...");
+    const scoreResult = await runScore(this.config.scoreCommand, this.repoRoot);
+
+    // 6. DECIDE — keep or discard
+    const improved = scoreResult.score > prevScore;
+    const equal = Math.abs(scoreResult.score - prevScore) < 0.0001;
+    const simpler = changedFiles.length === 0; // equal score + no extra code = simpler
+    const keep = improved || (equal && simpler);
+
+    const commit = await gitCommit(
+      this.repoRoot,
+      `autoagent: iteration ${this.state.iteration} — ${keep ? "keep" : "discard"}: ${description}`,
+    );
+
+    if (!keep) {
+      await gitRevert(this.repoRoot);
+    }
+
+    return {
+      iteration: this.state.iteration,
+      commit,
+      score: scoreResult.score,
+      prevScore,
+      testsPass: true,
+      testSummary: "PASS",
+      status: keep ? "keep" : "discard",
+      description,
+      filesChanged: changedFiles,
+      timestamp: Date.now(),
+      durationMs: Date.now() - iterStart,
+    };
+  }
+
+  private buildDiagnosis(): string {
+    const results = this.ledger.readAll();
+    if (results.length === 0) {
+      return "This is the first iteration. No previous results to diagnose.";
+    }
+
+    const kept = results.filter(r => r.status === "keep");
+    const discarded = results.filter(r => r.status === "discard");
+    const lines: string[] = [];
+
+    lines.push(`Previous iterations: ${results.length} (${kept.length} kept, ${discarded.length} discarded)`);
+    lines.push(`Current score: ${this.state.currentScore.toFixed(4)}`);
+    lines.push(`Best score: ${this.state.bestScore.toFixed(4)}`);
+
+    if (discarded.length > 0) {
+      lines.push("\nRecent discarded (avoid repeating):");
+      for (const r of discarded.slice(-3)) {
+        lines.push(`  - ${r.description} (score: ${r.score.toFixed(4)})`);
+      }
+    }
+
+    if (kept.length > 0) {
+      lines.push("\nRecent kept (build on these):");
+      for (const r of kept.slice(-3)) {
+        lines.push(`  - ${r.description} (score: ${r.score.toFixed(4)})`);
+      }
+    }
+
+    return lines.join("\n");
+  }
+
+  private buildModifyPrompt(diagnosis: string): string {
+    return `# AutoAgent Modification Request
+
+## Directive
+${this.programMd}
+
+## Current State
+${diagnosis}
+
+## Boundary Rules (TIER: ${this.config.tier})
+You may ONLY modify files matching these patterns:
+${this.boundary.modifiable.map(p => `  - ${p}`).join("\n")}
+
+You must NOT modify:
+${this.boundary.frozen.map(p => `  - ${p}`).join("\n")}
+
+## Contract Non-Goals (do NOT introduce these)
+${this.boundary.contractNonGoals.map(g => `  - ${g}`).join("\n")}
+
+## Instructions
+1. Make ONE targeted change that you believe will improve the score.
+2. Do not make broad refactors — one hypothesis, one modification.
+3. Commit your change with a descriptive message.
+4. Describe what you changed and why in 1-2 sentences.
+`;
+  }
+
+  private shouldStop(): boolean {
+    if (this.stopped) {
+      this.state.status = "stopped";
+      return true;
+    }
+    if (this.config.maxIterations > 0 && this.state.iteration >= this.config.maxIterations) {
+      this.state.status = "max-iterations";
+      return true;
+    }
+    if (this.config.maxTimeMs > 0 && (Date.now() - this.state.startedAt) >= this.config.maxTimeMs) {
+      this.state.status = "max-time";
+      return true;
+    }
+    if (this.config.scoreTarget > 0 && this.state.currentScore >= this.config.scoreTarget) {
+      this.state.status = "target-reached";
+      return true;
+    }
+    return false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Format boundary doc for subagent
+// ---------------------------------------------------------------------------
+
+function formatBoundaryDoc(spec: BoundarySpec): string {
+  return `# AutoAgent Boundary Spec (Tier: ${spec.tier})
+
+## Modifiable Files
+${spec.modifiable.map(p => `- ${p}`).join("\n")}
+
+## Frozen Files (NEVER modify)
+${spec.frozen.map(p => `- ${p}`).join("\n")}
+
+## Contract Non-Goals
+${spec.contractNonGoals.map(g => `- ${g}`).join("\n")}
+`;
+}

package/src/autoagent/results.spec.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { ResultsLedger } from "./results";
+import { existsSync, unlinkSync, readFileSync } from "fs";
+import type { IterationResult } from "./types";
+
+const TEST_PATH = "/tmp/autoagent-test-results.tsv";
+
+describe("ResultsLedger", () => {
+  let ledger: ResultsLedger;
+
+  beforeEach(() => {
+    if (existsSync(TEST_PATH)) unlinkSync(TEST_PATH);
+    ledger = new ResultsLedger(TEST_PATH);
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_PATH)) unlinkSync(TEST_PATH);
+  });
+
+  it("creates file with header on first append", () => {
+    const result: IterationResult = {
+      iteration: 1,
+      commit: "a1b2c3d",
+      score: 0.72,
+      prevScore: 0.65,
+      testsPass: true,
+      testSummary: "26/26",
+      status: "keep",
+      description: "raised min APR threshold",
+      filesChanged: ["src/config/strategy.ts"],
+      timestamp: Date.now(),
+      durationMs: 45000,
+    };
+
+    ledger.append(result);
+
+    const content = readFileSync(TEST_PATH, "utf-8");
+    const lines = content.trim().split("\n");
+
+    expect(lines[0]).toContain("iteration");
+    expect(lines[1]).toContain("a1b2c3d");
+    expect(lines[1]).toContain("0.72");
+    expect(lines[1]).toContain("keep");
+  });
+
+  it("reads all results back", () => {
+    ledger.append({
+      iteration: 1, commit: "aaa", score: 0.5, prevScore: 0, testsPass: true,
+      testSummary: "ok", status: "keep", description: "first",
+      filesChanged: [], timestamp: Date.now(), durationMs: 1000,
+    });
+    ledger.append({
+      iteration: 2, commit: "bbb", score: 0.6, prevScore: 0.5, testsPass: true,
+      testSummary: "ok", status: "keep", description: "second",
+      filesChanged: [], timestamp: Date.now(), durationMs: 2000,
+    });
+
+    const results = ledger.readAll();
+    expect(results).toHaveLength(2);
+    expect(results[0]!.commit).toBe("aaa");
+    expect(results[1]!.score).toBe(0.6);
+  });
+
+  it("getBest returns highest scoring keep result", () => {
+    ledger.append({ iteration: 1, commit: "aaa", score: 0.5, prevScore: 0, testsPass: true, testSummary: "ok", status: "keep", description: "first", filesChanged: [], timestamp: Date.now(), durationMs: 1000 });
+    ledger.append({ iteration: 2, commit: "bbb", score: 0.8, prevScore: 0.5, testsPass: true, testSummary: "ok", status: "keep", description: "best", filesChanged: [], timestamp: Date.now(), durationMs: 1000 });
+    ledger.append({ iteration: 3, commit: "ccc", score: 0.6, prevScore: 0.8, testsPass: true, testSummary: "ok", status: "discard", description: "worse", filesChanged: [], timestamp: Date.now(), durationMs: 1000 });
+
+    const best = ledger.getBest();
+    expect(best?.commit).toBe("bbb");
+    expect(best?.score).toBe(0.8);
+  });
+});

package/src/autoagent/results.ts

@@ -0,0 +1,68 @@
+import { appendFileSync, readFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import type { IterationResult } from "./types";
+
+const HEADER = "iteration\tcommit\tscore\tprev_score\ttests\tstatus\tdescription";
+
+export class ResultsLedger {
+  private path: string;
+
+  constructor(path: string) {
+    this.path = path;
+    const dir = dirname(path);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+
+  append(result: IterationResult): void {
+    if (!existsSync(this.path)) {
+      appendFileSync(this.path, HEADER + "\n", "utf-8");
+    }
+
+    const line = [
+      result.iteration,
+      result.commit,
+      result.score.toFixed(4),
+      result.prevScore.toFixed(4),
+      result.testSummary,
+      result.status,
+      result.description,
+    ].join("\t");
+
+    appendFileSync(this.path, line + "\n", "utf-8");
+  }
+
+  readAll(): IterationResult[] {
+    if (!existsSync(this.path)) return [];
+
+    const lines = readFileSync(this.path, "utf-8").trim().split("\n");
+    if (lines.length <= 1) return [];
+
+    return lines.slice(1).filter(Boolean).map(line => {
+      const parts = line.split("\t");
+      return {
+        iteration: parseInt(parts[0]!, 10),
+        commit: parts[1]!,
+        score: parseFloat(parts[2]!),
+        prevScore: parseFloat(parts[3]!),
+        testsPass: true,
+        testSummary: parts[4]!,
+        status: parts[5]! as IterationResult["status"],
+        description: parts[6]!,
+        filesChanged: [],
+        timestamp: 0,
+        durationMs: 0,
+      };
+    });
+  }
+
+  getBest(): IterationResult | null {
+    const kept = this.readAll().filter(r => r.status === "keep");
+    if (kept.length === 0) return null;
+    return kept.reduce((best, r) => r.score > best.score ? r : best);
+  }
+
+  format(): string {
+    if (!existsSync(this.path)) return "No results yet.";
+    return readFileSync(this.path, "utf-8");
+  }
+}

package/src/autoagent/runner.spec.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from "vitest";
+import { runTests, runScore, getChangedFiles, getShortCommit } from "./runner";
+
+describe("runner", () => {
+  it("runTests returns pass/fail and summary", async () => {
+    const result = await runTests("echo '3 tests passed'", process.cwd());
+    expect(result.passed).toBe(true);
+    expect(result.output).toContain("3 tests passed");
+  });
+
+  it("runTests detects failure from non-zero exit", async () => {
+    const result = await runTests("exit 1", process.cwd());
+    expect(result.passed).toBe(false);
+  });
+
+  it("getShortCommit returns 7-char hash", async () => {
+    const hash = await getShortCommit(process.cwd());
+    expect(hash.length).toBe(7);
+  });
+});