@slowdini/slow-powers-opencode 0.3.0 → 0.4.1

package/skills/evaluating-skills/runner/plugin-shadow.ts

@@ -1,201 +0,0 @@
-// Plugin-shadow detector (Claude Code). The runner stages eval skills into the
-// project-local `.claude/skills/` dir, but eval subagents are dispatched via the
-// Task tool and run in-process — so they ALSO inherit whatever skills the
-// orchestrator session loaded from installed plugins and the global skills dir.
-// When a staged skill name collides with one of those, both copies are
-// discoverable: the with/without comparison is contaminated and the control arm
-// is not truly skill-absent.
-//
-// The runner cannot unload a plugin from a running session (plugins load at
-// session start), so this module only *detects and reports* the overlap. It
-// reads declared settings as a best-effort proxy for what the session loaded —
-// it can't observe the live-loaded set, so a session that changed settings
-// without restarting may differ. Isolation itself is a launch-time concern; see
-// harness-details/claude.md → "Isolating from installed plugins".
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-export type ShadowSource =
-  | { kind: "plugin"; plugin: string; skill_name: string; path: string }
-  | { kind: "global-skill"; skill_name: string; path: string };
-
-export type PluginShadowReport = {
-  config_dir: string;
-  shadowed: ShadowSource[];
-};
-
-const ISOLATION_DOC =
-  'harness-details/claude.md → "Isolating from installed plugins"';
-
-/** The Claude Code config dir: `$CLAUDE_CONFIG_DIR` if set, else `~/.claude`. */
-export function resolveConfigDir(env: NodeJS.ProcessEnv = process.env): string {
-  const override = env.CLAUDE_CONFIG_DIR;
-  return override?.trim() ? override : join(homedir(), ".claude");
-}
-
-function readJsonSafe<T>(path: string): T | null {
-  if (!existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf8")) as T;
-  } catch {
-    return null;
-  }
-}
-
-type Settings = { enabledPlugins?: Record<string, boolean> };
-
-/**
- * Effective `enabledPlugins` map, honoring Claude Code's settings precedence
- * (local > project > user). User scope lives under the config dir; project and
- * local scope live under `<cwd>/.claude/`. Later sources override earlier keys,
- * so a project-scope `false` correctly masks a user-scope `true`.
- */
-export function resolveEnabledPlugins(opts: {
-  configDir: string;
-  cwd: string;
-}): Record<string, boolean> {
-  const sources = [
-    join(opts.configDir, "settings.json"),
-    join(opts.cwd, ".claude", "settings.json"),
-    join(opts.cwd, ".claude", "settings.local.json"),
-  ];
-  let merged: Record<string, boolean> = {};
-  for (const path of sources) {
-    const s = readJsonSafe<Settings>(path);
-    if (s?.enabledPlugins) merged = { ...merged, ...s.enabledPlugins };
-  }
-  return merged;
-}
-
-/** Names of skill folders (those holding a `SKILL.md`) directly under `dir`. */
-function skillFolderNames(dir: string): Array<{ name: string; path: string }> {
-  if (!existsSync(dir)) return [];
-  let entries: string[];
-  try {
-    entries = readdirSync(dir);
-  } catch {
-    return [];
-  }
-  const out: Array<{ name: string; path: string }> = [];
-  for (const name of entries) {
-    const skillDir = join(dir, name);
-    try {
-      if (!statSync(skillDir).isDirectory()) continue;
-    } catch {
-      continue;
-    }
-    if (existsSync(join(skillDir, "SKILL.md")))
-      out.push({ name, path: skillDir });
-  }
-  return out;
-}
-
-type InstalledPlugins = {
-  plugins?: Record<string, Array<{ installPath?: string }>>;
-};
-
-/** Skills exposed by currently-enabled installed plugins. */
-export function listEnabledPluginSkills(opts: {
-  configDir: string;
-  enabled: Record<string, boolean>;
-}): Array<{ plugin: string; skill_name: string; path: string }> {
-  const manifest = readJsonSafe<InstalledPlugins>(
-    join(opts.configDir, "plugins", "installed_plugins.json"),
-  );
-  const out: Array<{ plugin: string; skill_name: string; path: string }> = [];
-  if (!manifest?.plugins) return out;
-  for (const [key, installs] of Object.entries(manifest.plugins)) {
-    if (opts.enabled[key] !== true) continue; // only enabled plugins shadow
-    for (const inst of installs ?? []) {
-      if (!inst.installPath) continue;
-      for (const s of skillFolderNames(join(inst.installPath, "skills")))
-        out.push({ plugin: key, skill_name: s.name, path: s.path });
-    }
-  }
-  return out;
-}
-
-/** Skills under the global skills dir (`<configDir>/skills`). */
-export function listGlobalSkills(
-  configDir: string,
-): Array<{ skill_name: string; path: string }> {
-  return skillFolderNames(join(configDir, "skills")).map((s) => ({
-    skill_name: s.name,
-    path: s.path,
-  }));
-}
-
-/**
- * Which of `stagedSkillNames` are also discoverable from enabled plugins or the
- * global skills dir. Matches on the skill folder name (exact).
- */
-export function detectPluginShadows(opts: {
-  configDir: string;
-  cwd: string;
-  stagedSkillNames: string[];
-}): PluginShadowReport {
-  const staged = new Set(opts.stagedSkillNames);
-  const enabled = resolveEnabledPlugins({
-    configDir: opts.configDir,
-    cwd: opts.cwd,
-  });
-  const shadowed: ShadowSource[] = [];
-
-  for (const s of listEnabledPluginSkills({
-    configDir: opts.configDir,
-    enabled,
-  }))
-    if (staged.has(s.skill_name))
-      shadowed.push({
-        kind: "plugin",
-        plugin: s.plugin,
-        skill_name: s.skill_name,
-        path: s.path,
-      });
-
-  for (const s of listGlobalSkills(opts.configDir))
-    if (staged.has(s.skill_name))
-      shadowed.push({
-        kind: "global-skill",
-        skill_name: s.skill_name,
-        path: s.path,
-      });
-
-  return { config_dir: opts.configDir, shadowed };
-}
-
-function sourceLabel(s: ShadowSource): string {
-  return s.kind === "plugin"
-    ? `enabled plugin '${s.plugin}'`
-    : "the global skills dir";
-}
-
-/** One `validity_warnings` line per shadowed skill (for benchmark.json). */
-export function shadowValidityWarnings(report: PluginShadowReport): string[] {
-  return report.shadowed.map(
-    (s) =>
-      `staged skill '${s.skill_name}' is also provided by ${sourceLabel(s)} — ` +
-      `eval subagents could discover both copies, so with/without results may be ` +
-      `contaminated. Re-run from an isolated session (see ${ISOLATION_DOC}).`,
-  );
-}
-
-/** Build-time banner for the runner. Empty string when nothing is shadowed. */
-export function formatShadowBanner(report: PluginShadowReport): string {
-  if (report.shadowed.length === 0) return "";
-  const lines = report.shadowed.map(
-    (s) => `  • ${s.skill_name} — ${sourceLabel(s)}`,
-  );
-  return [
-    "",
-    "⚠ Plugin-shadow warning: skills staged for this eval are ALSO discoverable",
-    "  from your live environment:",
-    ...lines,
-    "  Eval subagents (dispatched via the Task tool) inherit this session's plugins,",
-    "  so both the staged copy and the installed copy are discoverable — the",
-    "  with/without comparison may be contaminated and the control arm is not truly",
-    "  skill-absent. The runner cannot unload a plugin from a running session.",
-    `  Re-run from an isolated session — see ${ISOLATION_DOC}.`,
-  ].join("\n");
-}

package/skills/evaluating-skills/runner/profiles/claude-code/plan-mode.md

@@ -1,11 +0,0 @@
-Plan mode is active. The user wants to review an approach before any code is written, so you must NOT execute yet: do not make any edits, do not run any non-read-only tool, and do not change configs or system state. The only file you may write is the plan file. This constraint supersedes any other instruction you have received this session.
-
-You are operating inside the harness's plan-mode workflow — a fixed, multi-phase procedure. Work through the phases in order:
-
-1. **Understand.** Read the relevant code and gather context with read-only tools until you can describe the change concretely. Reuse what already exists rather than proposing new code.
-2. **Design.** Decide the implementation approach and the trade-offs.
-3. **Review.** Re-check the design against the user's request and resolve open questions with the user before finalizing.
-4. **Write the plan.** Build the plan up incrementally in the plan file — this is the one file you are permitted to write. Name the files to change and how to verify the result.
-5. **Hand off.** Call ExitPlanMode to submit the plan for the user's approval.
-
-Terminal rail: your turn must end in exactly one of two ways — by asking the user a question, or by calling ExitPlanMode to present the finished plan. Do not stop for any other reason and do not begin implementation until the user has approved the plan. The plan-mode workflow already governs how you research, design, and present the work; stay on this rail through to ExitPlanMode.

package/skills/evaluating-skills/runner/promote-baseline.test.ts

@@ -1,281 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { PROMOTED_MARKER } from "./workspace-teardown";
-
-const FIXTURE_ROOT = join(tmpdir(), `slow-powers-promote-test-${process.pid}`);
-const PROMOTE_TS = join(import.meta.dir, "promote-baseline.ts");
-
-beforeAll(() => {
-  mkdirSync(FIXTURE_ROOT, { recursive: true });
-});
-
-afterAll(() => {
-  rmSync(FIXTURE_ROOT, { recursive: true, force: true });
-});
-
-function writeJson(path: string, value: unknown) {
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
-}
-
-describe("promote-baseline.ts (--skill-dir, isolated CWD)", () => {
-  test("copies benchmark + per-run gradings into the skill's committed baseline/", () => {
-    const root = join(FIXTURE_ROOT, "promote-basic");
-
-    // Skill dir + skill-under-test (detectRunContext validates SKILL.md exists).
-    const skillDir = join(root, "skill-dir");
-    const skillSub = join(skillDir, "mr-review");
-    mkdirSync(skillSub, { recursive: true });
-    writeFileSync(
-      join(skillSub, "SKILL.md"),
-      "---\nname: mr-review\ndescription: review MRs\n---\n\nbody\n",
-    );
-
-    // Working dir holding the workspace (mirrors workspaceRoot = <cwd>/skills-workspace).
-    const cwd = join(root, "work");
-    const iterationDir = join(
-      cwd,
-      "skills-workspace",
-      "mr-review",
-      "iteration-2",
-    );
-    mkdirSync(iterationDir, { recursive: true });
-
-    const timestamp = "2026-05-27T00:00:00.000Z";
-    writeJson(join(iterationDir, "conditions.json"), {
-      mode: "new-skill",
-      conditions: [
-        { name: "with_skill", skill_path: join(skillSub, "SKILL.md") },
-        { name: "without_skill", skill_path: null },
-      ],
-      timestamp,
-      harness: "claude-code",
-    });
-    writeJson(join(iterationDir, "benchmark.json"), {
-      run_summary: {
-        with_skill: { pass_rate: { mean: 0.83 } },
-        without_skill: { pass_rate: { mean: 0.33 } },
-      },
-      delta: { pass_rate: 0.5 },
-    });
-
-    const mkGrading = (evalId: string, cond: string, passRate: number) => {
-      const condDir = join(iterationDir, `eval-${evalId}`, cond);
-      mkdirSync(condDir, { recursive: true });
-      writeJson(join(condDir, "grading.json"), {
-        assertion_results: [
-          {
-            id: "a1",
-            passed: passRate > 0,
-            evidence: `${cond} evidence`,
-            confidence: 1,
-          },
-        ],
-        summary: { passed: 1, failed: 0, total: 1, pass_rate: passRate },
-      });
-    };
-    mkGrading("e1", "with_skill", 1);
-    mkGrading("e1", "without_skill", 0);
-
-    const res = Bun.spawnSync(
-      [
-        "bun",
-        "run",
-        PROMOTE_TS,
-        "--skill-dir",
-        skillDir,
-        "--skill",
-        "mr-review",
-        "--iteration",
-        "2",
-      ],
-      { cwd, stdout: "pipe", stderr: "pipe" },
-    );
-    expect(res.stderr.toString()).toBe("");
-    expect(res.exitCode).toBe(0);
-
-    const baselineDir = join(skillSub, "evals", "baseline");
-
-    // benchmark.json copied verbatim.
-    const benchmarkPath = join(baselineDir, "benchmark.json");
-    expect(existsSync(benchmarkPath)).toBe(true);
-    const benchmark = JSON.parse(readFileSync(benchmarkPath, "utf8")) as {
-      delta: { pass_rate: number };
-    };
-    expect(benchmark.delta.pass_rate).toBe(0.5);
-
-    // Per-run gradings copied under grading/<eval-id>__<condition>.json.
-    const withGrading = join(baselineDir, "grading", "e1__with_skill.json");
-    const withoutGrading = join(
-      baselineDir,
-      "grading",
-      "e1__without_skill.json",
-    );
-    expect(existsSync(withGrading)).toBe(true);
-    expect(existsSync(withoutGrading)).toBe(true);
-    const withParsed = JSON.parse(readFileSync(withGrading, "utf8")) as {
-      summary: { pass_rate: number };
-    };
-    expect(withParsed.summary.pass_rate).toBe(1);
-
-    // Provenance file records mode, iteration, harness, timestamp.
-    const provenancePath = join(baselineDir, "BASELINE.md");
-    expect(existsSync(provenancePath)).toBe(true);
-    const provenance = readFileSync(provenancePath, "utf8");
-    expect(provenance).toContain("new-skill");
-    expect(provenance).toContain("iteration-2");
-    expect(provenance).toContain("claude-code");
-    expect(provenance).toContain(timestamp);
-    // Model rows default to "unspecified" when no flags are passed.
-    expect(provenance).toContain("Agent model | unspecified");
-    expect(provenance).toContain("Judge model | unspecified");
-  });
-
-  test("drops a .promoted.json marker into the iteration dir for teardown", () => {
-    const root = join(FIXTURE_ROOT, "promote-marker");
-
-    const skillDir = join(root, "skill-dir");
-    const skillSub = join(skillDir, "mr-review");
-    mkdirSync(skillSub, { recursive: true });
-    writeFileSync(
-      join(skillSub, "SKILL.md"),
-      "---\nname: mr-review\ndescription: review MRs\n---\n\nbody\n",
-    );
-
-    const cwd = join(root, "work");
-    const iterationDir = join(
-      cwd,
-      "skills-workspace",
-      "mr-review",
-      "iteration-3",
-    );
-    mkdirSync(iterationDir, { recursive: true });
-    writeJson(join(iterationDir, "benchmark.json"), {
-      delta: { pass_rate: 0 },
-    });
-
-    const res = Bun.spawnSync(
-      [
-        "bun",
-        "run",
-        PROMOTE_TS,
-        "--skill-dir",
-        skillDir,
-        "--skill",
-        "mr-review",
-        "--iteration",
-        "3",
-      ],
-      { cwd, stdout: "pipe", stderr: "pipe" },
-    );
-    expect(res.stderr.toString()).toBe("");
-    expect(res.exitCode).toBe(0);
-
-    const markerPath = join(iterationDir, PROMOTED_MARKER);
-    expect(existsSync(markerPath)).toBe(true);
-    const marker = JSON.parse(readFileSync(markerPath, "utf8")) as {
-      promoted_at: string;
-      baseline_dir: string;
-    };
-    expect(marker.promoted_at).toBeTruthy();
-    expect(marker.baseline_dir).toBe(join(skillSub, "evals", "baseline"));
-  });
-
-  test("records agent and judge models in provenance when flags are passed", () => {
-    const root = join(FIXTURE_ROOT, "promote-models");
-
-    const skillDir = join(root, "skill-dir");
-    const skillSub = join(skillDir, "mr-review");
-    mkdirSync(skillSub, { recursive: true });
-    writeFileSync(
-      join(skillSub, "SKILL.md"),
-      "---\nname: mr-review\ndescription: review MRs\n---\n\nbody\n",
-    );
-
-    const cwd = join(root, "work");
-    const iterationDir = join(
-      cwd,
-      "skills-workspace",
-      "mr-review",
-      "iteration-1",
-    );
-    mkdirSync(iterationDir, { recursive: true });
-    writeJson(join(iterationDir, "conditions.json"), {
-      mode: "new-skill",
-      conditions: [
-        { name: "with_skill", skill_path: join(skillSub, "SKILL.md") },
-        { name: "without_skill", skill_path: null },
-      ],
-      timestamp: "2026-05-27T00:00:00.000Z",
-      harness: "claude-code",
-    });
-    writeJson(join(iterationDir, "benchmark.json"), {
-      delta: { pass_rate: 0 },
-    });
-
-    const res = Bun.spawnSync(
-      [
-        "bun",
-        "run",
-        PROMOTE_TS,
-        "--skill-dir",
-        skillDir,
-        "--skill",
-        "mr-review",
-        "--iteration",
-        "1",
-        "--agent-model",
-        "claude-haiku-4-5-20251001",
-        "--judge-model",
-        "claude-opus-4-7",
-      ],
-      { cwd, stdout: "pipe", stderr: "pipe" },
-    );
-    expect(res.stderr.toString()).toBe("");
-    expect(res.exitCode).toBe(0);
-
-    const provenance = readFileSync(
-      join(skillSub, "evals", "baseline", "BASELINE.md"),
-      "utf8",
-    );
-    expect(provenance).toContain("Agent model | claude-haiku-4-5-20251001");
-    expect(provenance).toContain("Judge model | claude-opus-4-7");
-  });
-
-  test("fails clearly when the iteration directory is missing", () => {
-    const root = join(FIXTURE_ROOT, "promote-missing");
-    const skillDir = join(root, "skill-dir");
-    const skillSub = join(skillDir, "mr-review");
-    mkdirSync(skillSub, { recursive: true });
-    writeFileSync(
-      join(skillSub, "SKILL.md"),
-      "---\nname: mr-review\ndescription: review MRs\n---\n\nbody\n",
-    );
-    const cwd = join(root, "work");
-    mkdirSync(cwd, { recursive: true });
-
-    const res = Bun.spawnSync(
-      [
-        "bun",
-        "run",
-        PROMOTE_TS,
-        "--skill-dir",
-        skillDir,
-        "--skill",
-        "mr-review",
-        "--iteration",
-        "9",
-      ],
-      { cwd, stdout: "pipe", stderr: "pipe" },
-    );
-    expect(res.exitCode).not.toBe(0);
-    expect(res.stderr.toString()).toContain("iteration-9");
-  });
-});

package/skills/evaluating-skills/runner/promote-baseline.ts

@@ -1,204 +0,0 @@
-#!/usr/bin/env bun
-import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { detectRunContext } from "./context";
-import type { ConditionsRecord } from "./types";
-import { PROMOTED_MARKER } from "./workspace-teardown";
-
-function die(msg: string): never {
-  console.error(`error: ${msg}`);
-  process.exit(1);
-}
-
-function ensureDir(path: string): void {
-  if (!existsSync(path)) mkdirSync(path, { recursive: true });
-}
-
-function gitHead(cwd: string): string {
-  try {
-    const res = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
-      cwd,
-      stdout: "pipe",
-      stderr: "ignore",
-    });
-    if (res.exitCode === 0) return res.stdout.toString().trim();
-  } catch {
-    // not a git repo / git unavailable — provenance still useful without it
-  }
-  return "unknown";
-}
-
-export type PromoteOptions = {
-  workspaceRoot: string;
-  skillName: string;
-  skillSubdir: string;
-  iteration: string;
-  harness: string;
-  label: string | null;
-  /**
-   * Operator-declared models for provenance. The runner never dispatches the
-   * agent/judge itself, so it cannot observe these — record what was used.
-   */
-  agentModel: string | null;
-  judgeModel: string | null;
-  /** Directory used to resolve the committing repo's git HEAD for provenance. */
-  gitCwd: string;
-};
-
-/**
- * Copies the durable, reference-worthy subset of a workspace iteration into the
- * skill's version-controlled `evals/baseline/` directory: the aggregate
- * `benchmark.json`, every per-run `grading.json` (judge rationales), and a
- * `BASELINE.md` provenance file. Ephemeral scaffolding (dispatch files, timing,
- * full run records, produced outputs, transcripts) is intentionally left behind
- * in the gitignored workspace.
- */
-export function promoteBaseline(opts: PromoteOptions): {
-  baselineDir: string;
-  gradingsCopied: number;
-} {
-  const iterationDir = join(
-    opts.workspaceRoot,
-    opts.skillName,
-    `iteration-${opts.iteration}`,
-  );
-  if (!existsSync(iterationDir)) {
-    die(
-      `not found: ${iterationDir} (build/grade iteration-${opts.iteration} first)`,
-    );
-  }
-
-  const benchmarkSrc = join(iterationDir, "benchmark.json");
-  if (!existsSync(benchmarkSrc)) {
-    die(
-      `missing benchmark.json in iteration-${opts.iteration} — run 'evals:aggregate' before promoting`,
-    );
-  }
-
-  const conditionsSrc = join(iterationDir, "conditions.json");
-  const conditions: ConditionsRecord | null = existsSync(conditionsSrc)
-    ? JSON.parse(readFileSync(conditionsSrc, "utf8"))
-    : null;
-
-  const baselineDir = join(opts.skillSubdir, "evals", "baseline");
-  const gradingDir = join(baselineDir, "grading");
-  ensureDir(gradingDir);
-
-  copyFileSync(benchmarkSrc, join(baselineDir, "benchmark.json"));
-
-  let gradingsCopied = 0;
-  for (const entry of readdirSync(iterationDir, { withFileTypes: true })) {
-    if (!entry.isDirectory() || !entry.name.startsWith("eval-")) continue;
-    const evalId = entry.name.slice("eval-".length);
-    const evalDir = join(iterationDir, entry.name);
-    for (const cond of readdirSync(evalDir, { withFileTypes: true })) {
-      if (!cond.isDirectory()) continue;
-      const gradingSrc = join(evalDir, cond.name, "grading.json");
-      if (!existsSync(gradingSrc)) continue;
-      copyFileSync(
-        gradingSrc,
-        join(gradingDir, `${evalId}__${cond.name}.json`),
-      );
-      gradingsCopied++;
-    }
-  }
-
-  const head = gitHead(opts.gitCwd);
-  const mode = conditions?.mode ?? "unknown";
-  const timestamp = conditions?.timestamp ?? "unknown";
-  const conditionNames = conditions?.conditions.map((c) => c.name) ?? [];
-  const provenance = [
-    `# Baseline — ${opts.skillName}`,
-    "",
-    "Committed reference output from a canonical eval run. Regenerate with",
-    "`bun run evals:promote-baseline -- --skill " +
-      `${opts.skillName} --iteration <N>` +
-      "` after aggregating. The ephemeral workspace (run records, timing,",
-    "dispatch files, produced outputs) stays gitignored under `skills-workspace/`",
-    "and is reclaimable by `evals:teardown` once promoted (this commit's marker).",
-    "",
-    "| Field | Value |",
-    "|-------|-------|",
-    `| Mode | ${mode} |`,
-    `| Iteration | iteration-${opts.iteration} |`,
-    `| Harness | ${opts.harness} |`,
-    `| Agent model | ${opts.agentModel ?? "unspecified"} |`,
-    `| Judge model | ${opts.judgeModel ?? "unspecified"} |`,
-    `| Conditions | ${conditionNames.join(", ") || "unknown"} |`,
-    `| Run timestamp | ${timestamp} |`,
-    `| Label | ${opts.label ?? "(none)"} |`,
-    `| Promoted from commit | ${head} |`,
-    "",
-    "Files:",
-    "- `benchmark.json` — aggregate pass-rate / duration / token deltas.",
-    "- `grading/<eval-id>__<condition>.json` — per-run assertion results and judge rationales.",
-    "",
-  ].join("\n");
-  writeFileSync(join(baselineDir, "BASELINE.md"), `${provenance}\n`);
-
-  // Mark the iteration as committed so `teardown` can safely reclaim its
-  // workspace — without this marker teardown preserves the iteration as
-  // uncommitted results.
-  writeFileSync(
-    join(iterationDir, PROMOTED_MARKER),
-    `${JSON.stringify(
-      {
-        promoted_at: new Date().toISOString(),
-        baseline_dir: baselineDir,
-        commit: head,
-      },
-      null,
-      2,
-    )}\n`,
-  );
-
-  return { baselineDir, gradingsCopied };
-}
-
-if (import.meta.main) {
-  const argv = Bun.argv.slice(2);
-  let ctx: ReturnType<typeof detectRunContext>;
-  try {
-    ctx = detectRunContext(argv);
-  } catch (err) {
-    die(err instanceof Error ? err.message : String(err));
-  }
-
-  const iterIdx = argv.indexOf("--iteration");
-  const iteration = iterIdx === -1 ? undefined : argv[iterIdx + 1];
-  if (!iteration) die("missing --iteration <N>");
-
-  const labelIdx = argv.indexOf("--label");
-  const label = labelIdx === -1 ? null : (argv[labelIdx + 1] ?? null);
-
-  const agentModelIdx = argv.indexOf("--agent-model");
-  const agentModel =
-    agentModelIdx === -1 ? null : (argv[agentModelIdx + 1] ?? null);
-
-  const judgeModelIdx = argv.indexOf("--judge-model");
-  const judgeModel =
-    judgeModelIdx === -1 ? null : (argv[judgeModelIdx + 1] ?? null);
-
-  const { baselineDir, gradingsCopied } = promoteBaseline({
-    workspaceRoot: ctx.workspaceRoot,
-    skillName: ctx.skillName,
-    skillSubdir: ctx.skillSubdir,
-    iteration,
-    harness: ctx.harness,
-    label,
-    agentModel,
-    judgeModel,
-    gitCwd: ctx.skillSubdir,
-  });
-
-  console.log(
-    `Promoted baseline for ${ctx.skillName} → ${baselineDir} (benchmark.json + ${gradingsCopied} grading file${gradingsCopied === 1 ? "" : "s"} + BASELINE.md)`,
-  );
-}