self-bench 0.3.6 → 0.3.8

package/src/extensions/shared/schemas.ts

@@ -0,0 +1,101 @@
+import { Type } from "@sinclair/typebox";
+
+const environmentVariableName = Type.String({ pattern: "^[A-Za-z_][A-Za-z0-9_]*$" });
+const environmentVariables = Type.Record(environmentVariableName, Type.String());
+
+const service = Type.Object(
+  {
+    name: Type.String({ pattern: "^[a-z][a-z0-9_-]*$" }),
+    image: Type.String({ minLength: 1 }),
+    environmentVariables,
+    command: Type.Optional(Type.Array(Type.String())),
+    healthcheck: Type.Object(
+      {
+        test: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+        intervalSeconds: Type.Integer({ minimum: 1 }),
+        timeoutSeconds: Type.Integer({ minimum: 1 }),
+        retries: Type.Integer({ minimum: 1 }),
+        startPeriodSeconds: Type.Integer({ minimum: 0 }),
+      },
+      { additionalProperties: false },
+    ),
+  },
+  { additionalProperties: false },
+);
+
+export const environmentContract = Type.Object(
+  {
+    schemaVersion: Type.Literal(1),
+    baseImage: Type.String({ minLength: 1 }),
+    rootSetupCommand: Type.String({ minLength: 1 }),
+    setupCommand: Type.String({ minLength: 1 }),
+    smokeCommand: Type.String({ minLength: 1 }),
+    environmentVariables,
+    services: Type.Array(service),
+    source: Type.Union([
+      Type.Literal("repository-dockerfile"),
+      Type.Literal("devcontainer"),
+      Type.Literal("ci-adapted"),
+      Type.Literal("generated"),
+    ]),
+    evidence: Type.Array(
+      Type.Object(
+        { path: Type.String({ minLength: 1 }), reason: Type.String({ minLength: 1 }) },
+        { additionalProperties: false },
+      ),
+      { minItems: 1 },
+    ),
+  },
+  { additionalProperties: false },
+);
+
+export const taskTimeouts = Type.Object(
+  {
+    setupSeconds: Type.Integer({ minimum: 1 }),
+    agentSeconds: Type.Integer({ minimum: 1 }),
+    testsSeconds: Type.Integer({ minimum: 1 }),
+  },
+  { additionalProperties: false },
+);
+
+export const taskResources = Type.Object(
+  {
+    cpus: Type.Number({ exclusiveMinimum: 0 }),
+    memoryMb: Type.Integer({ minimum: 1 }),
+    storageMb: Type.Integer({ minimum: 1 }),
+  },
+  { additionalProperties: false },
+);
+
+export const taskDefinition = Type.Object(
+  {
+    schemaVersion: Type.Literal(2),
+    difficulty: Type.Union([Type.Literal("easy"), Type.Literal("medium"), Type.Literal("hard")]),
+    taskId: Type.String({ pattern: "^[A-Za-z0-9][A-Za-z0-9._-]*$" }),
+    repo: Type.String({ minLength: 1 }),
+    baseCommit: Type.String({ pattern: "^[0-9a-fA-F]{40}$" }),
+    workdir: Type.String({ minLength: 1 }),
+    testCommand: Type.String({ minLength: 1 }),
+    failToPass: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+    passToPass: Type.Array(Type.String({ minLength: 1 })),
+    testPaths: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+    sourcePr: Type.Integer({ minimum: 1 }),
+    sourceUrl: Type.String({ minLength: 1 }),
+    prompt: Type.String({ minLength: 1 }),
+    timeouts: taskTimeouts,
+    resources: taskResources,
+    environment: environmentContract,
+  },
+  { additionalProperties: false },
+);
+
+/** Definition fields a verification agent may change through /work/fix/definition.json. */
+export const FIX_FIELDS = [
+  "environment",
+  "testCommand",
+  "failToPass",
+  "passToPass",
+  "testPaths",
+  "timeouts",
+  "resources",
+] as const;

package/src/extensions/shared/static-check.ts

@@ -0,0 +1,103 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export interface CheckVerdict {
+  ok: boolean;
+  errors: { gate: string; message: string }[];
+  renderedDirectory?: string;
+}
+
+export interface ToolFailure {
+  content: { type: "text"; text: string }[];
+  details: Record<string, unknown>;
+  isError: true;
+}
+
+export interface StagedSubmission {
+  readonly directory: string;
+  readonly definitionJson: string;
+  dispose(): void;
+}
+
+export function requiredEnvironment(name: string): string {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`${name} is not configured`);
+  }
+  return value;
+}
+
+/** Writes definition.json, test.patch, and gold.patch to a private staging directory. */
+export function stageSubmission(
+  definition: unknown,
+  testPatch: string,
+  goldPatch: string,
+  prefix = "selfbench-submit-",
+): StagedSubmission {
+  const directory = mkdtempSync(join(tmpdir(), prefix));
+  const definitionJson = `${JSON.stringify(definition, null, 2)}\n`;
+  writeFileSync(join(directory, "definition.json"), definitionJson);
+  writeFileSync(join(directory, "test.patch"), testPatch);
+  writeFileSync(join(directory, "gold.patch"), goldPatch);
+  return {
+    directory,
+    definitionJson,
+    dispose: () => rmSync(directory, { recursive: true, force: true }),
+  };
+}
+
+/**
+ * Runs the bundled sandbox-check program (schema, policy, paths, audit, dry render) over a staged
+ * submission. The rendered tree lands under SELFBENCH_RENDER_OUTPUT (default /work) as rendered/.
+ */
+export interface PatchApplyTarget {
+  /** Git repository holding the base tree; defaults to SELFBENCH_REPO_DIRECTORY or /work/repo. */
+  readonly repository?: string;
+  /** Ref of the clean base tree in that repository. */
+  readonly base: string;
+}
+
+export function runStaticCheck(
+  staging: string,
+  extra: readonly string[] = [],
+  applyAgainst?: PatchApplyTarget,
+): CheckVerdict {
+  const program = requiredEnvironment("SELFBENCH_CHECK_PROGRAM");
+  const repository =
+    applyAgainst?.repository ?? process.env.SELFBENCH_REPO_DIRECTORY ?? "/work/repo";
+  const result = spawnSync(
+    process.execPath,
+    [
+      program,
+      join(staging, "definition.json"),
+      join(staging, "test.patch"),
+      join(staging, "gold.patch"),
+      process.env.SELFBENCH_RENDER_OUTPUT ?? "/work",
+      ...extra,
+      ...(applyAgainst ? ["--repository", repository, "--base", applyAgainst.base] : []),
+    ],
+    { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 },
+  );
+  if (result.status !== 0) {
+    throw new Error(
+      `static check program failed: ${(result.stderr || result.stdout).slice(-4_000)}`,
+    );
+  }
+  return JSON.parse(result.stdout) as CheckVerdict;
+}
+
+export function staticCheckFailure(verdict: CheckVerdict, subject: string): ToolFailure {
+  const lines = verdict.errors.map((error) => `- [${error.gate}] ${error.message}`).join("\n");
+  const rendered = verdict.renderedDirectory
+    ? `\nThe dry-rendered Harbor tree (as far as rendering succeeded) is under ${verdict.renderedDirectory}.`
+    : "";
+  return failure(
+    `The ${subject} failed the static check; nothing was recorded. Fix every item and try again:\n${lines}${rendered}`,
+  );
+}
+
+export function failure(text: string): ToolFailure {
+  return { content: [{ type: "text", text }], details: {}, isError: true };
+}

package/src/extensions/verifier.ts

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+
+function writeVerdict(verdict: Record<string, unknown>): void {
+  const root = requiredEnvironment("SELFBENCH_VERDICT_OUTPUT");
+  mkdirSync(root, { recursive: true });
+  const path = join(root, "verdict.json");
+  if (existsSync(path)) throw new Error("a verdict was already submitted this round");
+  writeFileSync(path, `${JSON.stringify(verdict, null, 2)}\n`, { flag: "wx" });
+}
+
+function requiredEnvironment(name: string): string {
+  const value = process.env[name];
+  if (!value) throw new Error(`${name} is required`);
+  return value;
+}
+
+/** The verifier is intentionally read-only: it can accept or advise the next authoring round. */
+export default function verifierExtension(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "accept_task",
+    label: "Accept SelfBench task",
+    description: "Accept a fair task after the latest report is GREEN.",
+    parameters: Type.Object(
+      {
+        reason: Type.String({ minLength: 1 }),
+        findings: Type.Array(
+          Type.Object(
+            {
+              artifact: Type.String({ minLength: 1 }),
+              disposition: Type.Union([
+                Type.Literal("base_contract"),
+                Type.Literal("prompt_contract"),
+                Type.Literal("external_contract"),
+                Type.Literal("not_contract"),
+              ]),
+              evidence: Type.String({ minLength: 1 }),
+            },
+            { additionalProperties: false },
+          ),
+        ),
+        counterexample: Type.String({ minLength: 1 }),
+      },
+      { additionalProperties: false },
+    ),
+    async execute(_toolCallId, input) {
+      writeVerdict({ kind: "accepted", ...input });
+      return { content: [{ type: "text", text: "Recorded the acceptance verdict." }], details: {} };
+    },
+  });
+
+  pi.registerTool({
+    name: "submit_suggestions",
+    label: "Submit authoring suggestions",
+    description:
+      "Submit concise, actionable suggestions for the next authoring agent. This verifier is read-only and must not edit task files.",
+    parameters: Type.Object(
+      {
+        summary: Type.String({ minLength: 1 }),
+        suggestions: Type.String({ minLength: 1 }),
+      },
+      { additionalProperties: false },
+    ),
+    async execute(_toolCallId, input) {
+      writeVerdict({ kind: "suggestions", ...input });
+      return {
+        content: [{ type: "text", text: "Recorded suggestions for the next authoring round." }],
+        details: {},
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "reject_task",
+    label: "Reject SelfBench task",
+    description: "Reject a task that cannot be made fair within the authoring workflow.",
+    parameters: Type.Object(
+      { reason: Type.String({ minLength: 1 }) },
+      { additionalProperties: false },
+    ),
+    async execute(_toolCallId, input) {
+      writeVerdict({ kind: "rejected", ...input });
+      return { content: [{ type: "text", text: "Recorded the rejection verdict." }], details: {} };
+    },
+  });
+}

package/src/skills/selfbench/SKILL.md

@@ -5,7 +5,7 @@ description: Author one private software-engineering benchmark task at an assign
 
 # SelfBench Task Authoring
 
-Create exactly one Harbor evaluation at the assigned easy, medium, or hard difficulty. Do not discover alternative pull requests. Do not run Harbor; centralized validation owns execution.
+Create exactly one Harbor evaluation at the assigned easy, medium, or hard difficulty. Do not discover alternative pull requests. Do not run Harbor; the worker compiles, builds, and measures your submission and sends the verification report back to this session. Your deliverable is the directory `/work/task/` with exactly four files: `definition.json` (with the environment contract), `instruction.md`, `test.patch`, and `gold.patch`. The `verify` and `submit_task` tools take no arguments; they read that directory.
 
 ## Integrity boundary
 
@@ -37,7 +37,7 @@ Every tier also requires one coherent behavioral requirement, held-out tests tha
 2. Inspect the complete diff and repository-native test setup.
 3. Classify changed paths as implementation, test, generated, documentation, or unrelated.
 4. Build `goldPatch` from only the implementation required for the requested behavior. Exclude tests, generated artifacts, formatting churn, and unrelated cleanup.
-5. Build `testPatch` from only held-out behavioral tests and minimal test fixtures. It must not overlap any path in `goldPatch`.
+5. Prefer reusing suitable PR tests. Record `testSelection` (`mode`: reused/augmented/authored/base-only, `reused`, `added`, `excluded` string arrays with test identities/reasons, and `coverage`). Add tests only for missing requested behavior. Base-only requires an empty `test.patch`, nonempty reused tests, and no added tests; unchanged base tests are visible, not secret. Build `testPatch` from only held-out behavioral tests and minimal test fixtures. It must not overlap any path in `goldPatch`.
    - Exercise a public API, command, persisted behavior, or existing extension seam. Do not import a
      private helper or new internal module introduced by the gold patch merely because it is easy to
      test directly.
@@ -62,28 +62,26 @@ Every tier also requires one coherent behavioral requirement, held-out tests tha
      implementation while leaving most of the request unverified.
 6. Select exact fail-to-pass and pass-to-pass test identifiers supported by one deterministic test command.
 7. Write a standalone prompt in the engineer's voice. Preserve required behavior, constraints, and acceptance criteria without leaking the completed solution.
-8. Choose only the toolchains the clean task environment needs.
-9. Call `submit_task` exactly once. Do not write an alternate task format.
+8. Author the environment contract from the pinned base commit: base image pinned by digest, root setup, dependency setup, smoke command, non-secret environment variables, services with health checks, and repository-file evidence. Derive it from the closest CI job, repository Dockerfile, devcontainer, lockfiles, and test scripts.
+9. Write the deliverable to `/work/task/`, call `verify` until it is green, then call `submit_task` once. If the verify budget runs out before a green report, submit your best deliverable anyway: the worker verifies it and a red result opens the next round with the report, whereas an unsubmitted round rejects the task. Both tools run the static check (files present, schema, environment policy, patch path safety, audit gates, dry render) immediately and return failures for you to fix in the same session; only a passing submission ends the round. Do not write an alternate task format.
 
-## Submitted definition
+## Deliverable files
 
-Submit this logical shape through `submit_task`:
+`/work/task/instruction.md` holds the standalone instruction; it is authoritative for the prompt, so omit `prompt` from `definition.json` or keep it identical. `/work/task/test.patch` and `/work/task/gold.patch` are Git patches (start with `diff --git`; produce them with `git diff`), except an explicitly empty base-only `test.patch`. `/work/task/definition.json` has this shape (shown with the derived prompt):
 
 ```json
 {
   "definition": {
-    "schemaVersion": 1,
+    "schemaVersion": 2,
     "difficulty": "medium",
     "taskId": "project-pr-123",
     "repo": "example/project",
     "baseCommit": "0123456789abcdef0123456789abcdef01234567",
     "workdir": ".",
-    "setupCommand": "bun install --frozen-lockfile",
     "testCommand": "bun test {tests}",
     "failToPass": ["tests/new-behavior.test.ts"],
     "passToPass": ["tests/existing-a.test.ts", "tests/existing-b.test.ts"],
     "testPaths": ["tests/new-behavior.test.ts"],
-    "toolchains": ["node", "bun"],
     "sourcePr": 123,
     "sourceUrl": "https://github.com/example/project/pull/123",
     "prompt": "Implement the requested behavior...",
@@ -96,6 +94,17 @@ Submit this logical shape through `submit_task`:
       "cpus": 4,
       "memoryMb": 8192,
       "storageMb": 20480
+    },
+    "environment": {
+      "schemaVersion": 1,
+      "baseImage": "node:22-bookworm@sha256:...",
+      "rootSetupCommand": "apt-get update && apt-get install -y --no-install-recommends bash git passwd procps tar",
+      "setupCommand": "bun install --frozen-lockfile",
+      "smokeCommand": "bun --version",
+      "environmentVariables": { "CI": "1" },
+      "services": [],
+      "source": "ci-adapted",
+      "evidence": [{ "path": ".github/workflows/ci.yml", "reason": "Defines the test job." }]
     }
   },
   "testPatch": "diff --git ...",
@@ -103,17 +112,66 @@ Submit this logical shape through `submit_task`:
 }
 ```
 
-`testCommand` must contain the literal `{tests}` placeholder. Paths must be repository-relative and must not contain `..`.
+`testCommand` must contain the literal `{tests}` placeholder. Paths must be repository-relative and must not contain `..`. Secret-named environment variables are accepted only with fixed placeholder literals.
+
+## What the compiler renders
+
+The trusted compiler on the worker turns your submission into a native Harbor task. You never write these files; `verify` and `submit_task` dry-render the same tree to `/work/rendered/` so you can inspect exactly what will be built.
+
+```
+harbor-task/
+  task.toml            ← timeouts, resources, agent/verifier settings from the definition
+  instruction.md       ← definition.prompt (what the evaluated agent reads)
+  definition.json      ← the submitted definition (with environment contract)
+  environment/         ← agent image build context
+    Dockerfile         ← FROM environment.baseImage; ENV from environmentVariables; COPY + run root-setup.sh;
+                         unpack repo.tar.gz into /app; git init/commit base; run setup.sh from /app/<workdir>;
+                         commit the post-setup tree (baseline for the agent's diff); create user "agent",
+                         snapshot .git to /opt/selfbench/base.git
+    root-setup.sh      ← environment.rootSetupCommand (runs as root, /bin/sh)
+    setup.sh           ← environment.setupCommand (bash, cwd /app/<workdir>)
+    smoke.sh           ← environment.smokeCommand (bash, cwd /app/<workdir>), run by the smoke gate before any test
+    repo.tar.gz        ← git archive of baseCommit (never contains tests/solution)
+  tests/               ← verifier image build context (separate container, user "verifier")
+    Dockerfile         ← same base layers as environment/, plus /tests with test.patch and the scripts;
+                         when the gold patch changes a dependency manifest, setup.sh runs again with
+                         dependency-setup.patch applied and only those manifest paths are reset to the base
+    test.patch         ← the held-out test patch; applied by test.sh at verify time
+    test.sh, task-test.sh ← generated verifier: apply test.patch, run testCommand with failToPass (twice, for
+                            determinism) then passToPass under runuser verifier, write rewards
+                            (patch_applied, fail_to_pass, pass_to_pass, deterministic, setup_completed)
+    docker-compose.yaml ← only when environment.services is non-empty (services with health checks)
+    root-setup.sh, setup.sh, smoke.sh, repo.tar.gz ← copies, because a Docker build context cannot reach outside itself
+  solution/
+    gold.patch         ← the gold patch; applied only by the oracle agent
+    solve.sh           ← git apply of gold.patch
+```
+
+Each verify gate maps to those files, so a red gate tells you which field to change:
+
+- **compile** (worker): schema, environment policy, patch path safety, evidence paths at the pinned commit → definition, environment contract, patch headers.
+- **audit**: tier thresholds, gold/test overlap, `{tests}` placeholder rules → goldPatch, testPatch, testCommand, failToPass, passToPass.
+- **build**: both Dockerfiles → baseImage, rootSetupCommand, setupCommand, environmentVariables, workdir, services.
+- **smoke**: smoke.sh in the verifier image → smokeCommand (and whatever setup it relies on).
+- **nop**: test.sh on the base snapshot with test.patch applied, no solution → failToPass must fail, passToPass must pass; testCommand, test selection, held-out tests.
+- **oracle**: test.sh after gold.patch → both selections pass deterministically; goldPatch, tests, timeouts, resources.
 
 ## Patch rules
 
-- Produce binary-safe Git patches beginning with `diff --git`.
+- When a change spans backend and frontend, anchor the held-out tests on the backend contract through its public boundary; tests that mock the API and check only rendering are rejected as unfair.
+- Never touch paths the repository marks `export-ignore` in `.gitattributes` (for PostHog that includes everything under `.github/`): the snapshot the solver and the verifier receive is a `git archive`, so those files do not exist there and the static check rejects patches that reference them. If a change lives only in such paths, decline the task.
+- Produce binary-safe Git patches beginning with `diff --git`, with LF line endings and a final newline (use `git diff`). Except for an explicitly empty base-only test.patch, both must apply cleanly to the base commit, and the gold patch must apply on top of the test patch; `verify` checks this with `git apply --check` before any build.
 - Keep test and gold paths disjoint.
 - Exclude dependency caches, lockfile churn unrelated to the change, build output, vendored code, and generated files.
-- Keep repository-native package-manager pins and frozen install commands.
-- Do not patch around a broken base environment. Reject the candidate when reproducibility is not honest.
+- Do not patch around a broken base repository. Environment reproducibility is proven by the worker's build, smoke, nop, and oracle gates.
 - Do not include source transcripts or provenance records in either patch.
 
 ## Final check
 
 Before submission, re-read the prompt without looking at the completed diff. It must be sufficient to implement the behavior but insufficient to recover the hidden implementation. Confirm the test patch observes public behavior and would fail a plausible wrong implementation, not merely the base commit. Then imagine a second correct implementation with different file boundaries and helper names; the held-out tests must still pass it.
+
+## Structured test evidence
+
+Optional `testResults` contains `format: "junit"` and disjoint `failToPass`/`passToPass` arrays of exact XML `classname::name` identities (not command selectors). Configure the native runner to write JUnit XML to `$SELFBENCH_JUNIT_REPORT` for each invocation and include python3 in root setup. For example, pytest uses `python -m pytest {tests} --junitxml="$SELFBENCH_JUNIT_REPORT"`; verify the actual emitted identities rather than guessing. The verifier reads a fresh bounded report after stopping test processes. Every declared target must assertion-fail on base; all declared targets and regressions must pass with the reference. Missing, duplicate, skipped, errored, malformed, oversized or exit-inconsistent reports fail closed. Results are emitted as JSON in the stored verifier log. Never fabricate reports to get a green gate.
+
+Without `testResults`, legacy command-level gates remain available and cannot prove individual test transitions. Explain this limitation in testSelection.coverage. Repeatability currently means two consecutive target-command successes in the same verifier environment, not fresh-environment determinism. Setup remains part of this same authoring session. Reference dependency manifests are provisioned into the verifier before tracked source is restored; hidden test patches are applied only at runtime, so required test dependencies/fixtures must be covered explicitly by setup.

package/biome.json

@@ -1,24 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/2.5.7/schema.json",
-  "files": {
-    "includes": [
-      "src/**/*.ts",
-      "tests/**/*.ts",
-      "scripts/**/*.ts",
-      "review/src/**/*.{ts,tsx}",
-      "review/vite.config.ts"
-    ]
-  },
-  "formatter": {
-    "enabled": true,
-    "indentStyle": "space",
-    "indentWidth": 2,
-    "lineWidth": 100
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "preset": "recommended"
-    }
-  }
-}

package/dist/agent-smoke-main.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=agent-smoke-main.d.ts.map

package/dist/agent-smoke-main.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-smoke-main.d.ts","sourceRoot":"","sources":["../src/agent-smoke-main.ts"],"names":[],"mappings":""}

package/dist/agent-smoke-main.js

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-import { parseArgs } from "node:util";
-import { smokeAllAdapters } from "./agent-smoke.js";
-import { isHarborEnvironment } from "./providers.js";
-const parsed = parseArgs({
-    options: {
-        task: { type: "string" },
-        jobs: { type: "string" },
-        harbor: { type: "string" },
-        environment: { type: "string", default: "modal" },
-        concurrency: { type: "string", default: "4" },
-        help: { type: "boolean", short: "h" },
-    },
-    strict: true,
-});
-if (parsed.values.help) {
-    console.log(`Attempt installation and instantiation of every pinned Harbor adapter.
-
-Usage:
-  self-bench-agent-smoke --task DIRECTORY --jobs DIRECTORY [options]
-
-Options:
-  --harbor PATH              Harbor executable (default: harbor)
-  --environment docker|modal Execution environment (default: modal)
-  --concurrency N            Concurrent adapter checks (default: 4)
-  -h, --help                 Show this help`);
-    process.exit(0);
-}
-const environment = parsed.values.environment ?? "modal";
-if (!isHarborEnvironment(environment)) {
-    throw new Error("--environment must be docker or modal");
-}
-const results = await smokeAllAdapters({
-    taskDirectory: parsed.values.task ?? fail("--task is required"),
-    jobsDirectory: parsed.values.jobs ?? fail("--jobs is required"),
-    environment,
-    concurrency: positiveInteger(parsed.values.concurrency, "--concurrency"),
-    ...(parsed.values.harbor ? { harborPath: parsed.values.harbor } : {}),
-});
-console.log(JSON.stringify({
-    adapters: results.length,
-    installed: results.filter((result) => result.installed).length,
-    failed: results.filter((result) => !result.installed).length,
-}, null, 2));
-function fail(message) {
-    throw new Error(message);
-}
-function positiveInteger(value, label) {
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed < 1) {
-        throw new Error(`${label} must be a positive integer`);
-    }
-    return parsed;
-}
-//# sourceMappingURL=agent-smoke-main.js.map

package/dist/agent-smoke-main.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-smoke-main.js","sourceRoot":"","sources":["../src/agent-smoke-main.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAErD,MAAM,MAAM,GAAG,SAAS,CAAC;IACvB,OAAO,EAAE;QACP,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QACxB,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QACxB,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QAC1B,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE;QACjD,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,EAAE;QAC7C,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,EAAE;KACtC;IACD,MAAM,EAAE,IAAI;CACb,CAAC,CAAC;AACH,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACvB,OAAO,CAAC,GAAG,CAAC;;;;;;;;;4CAS8B,CAAC,CAAC;IAC5C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC;AACD,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,WAAW,IAAI,OAAO,CAAC;AACzD,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,EAAE,CAAC;IACtC,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;AAC3D,CAAC;AACD,MAAM,OAAO,GAAG,MAAM,gBAAgB,CAAC;IACrC,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,IAAI,IAAI,CAAC,oBAAoB,CAAC;IAC/D,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,IAAI,IAAI,CAAC,oBAAoB,CAAC;IAC/D,WAAW;IACX,WAAW,EAAE,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,eAAe,CAAC;IACxE,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;CACtE,CAAC,CAAC;AACH,OAAO,CAAC,GAAG,CACT,IAAI,CAAC,SAAS,CACZ;IACE,QAAQ,EAAE,OAAO,CAAC,MAAM;IACxB,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM;IAC9D,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM;CAC7D,EACD,IAAI,EACJ,CAAC,CACF,CACF,CAAC;AAEF,SAAS,IAAI,CAAC,OAAe;IAC3B,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;AAC3B,CAAC;AAED,SAAS,eAAe,CAAC,KAAyB,EAAE,KAAa;IAC/D,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC7B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5C,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,6BAA6B,CAAC,CAAC;IACzD,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/agent-smoke.d.ts

@@ -1,18 +0,0 @@
-import type { HarborEnvironment } from "./providers.js";
-export declare const HARBOR_AGENT_ADAPTERS: readonly ["oracle", "nop", "acp", "terminus-2", "claude-code", "copilot-cli", "aider", "cline-cli", "codex", "cortex-code", "cursor-cli", "gemini-cli", "antigravity-cli", "antigravity-sdk", "rovodev-cli", "goose", "grok-build", "hermes", "kimi-code", "kimi-cli", "langgraph", "deerflow", "mini-swe-agent", "nemo-agent", "swe-agent", "opencode", "mimo", "openclaw", "openhands", "openhands-sdk", "pi", "qwen-coder", "devin", "trae-agent", "computer-1", "eve", "dspy-rlm", "vibe"];
-export interface AdapterSmokeOptions {
-    readonly taskDirectory: string;
-    readonly jobsDirectory: string;
-    readonly harborPath?: string;
-    readonly environment?: HarborEnvironment;
-    readonly concurrency?: number;
-}
-export interface AdapterSmokeResult {
-    readonly agent: (typeof HARBOR_AGENT_ADAPTERS)[number];
-    readonly installed: boolean;
-    readonly exitCode: number;
-    readonly jobName: string;
-    readonly outputTail: string;
-}
-export declare function smokeAllAdapters(options: AdapterSmokeOptions): Promise<readonly AdapterSmokeResult[]>;
-//# sourceMappingURL=agent-smoke.d.ts.map

package/dist/agent-smoke.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-smoke.d.ts","sourceRoot":"","sources":["../src/agent-smoke.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,eAAO,MAAM,qBAAqB,geAuCxB,CAAC;AAEX,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,CAAC;IACzC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;IACvD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,SAAS,kBAAkB,EAAE,CAAC,CAuExC"}

package/dist/agent-smoke.js

@@ -1,103 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { harborChildEnvironment } from "./harbor-environment.js";
-import { parallelMap } from "./parallel.js";
-import { runCommand } from "./process.js";
-export const HARBOR_AGENT_ADAPTERS = [
-    "oracle",
-    "nop",
-    "acp",
-    "terminus-2",
-    "claude-code",
-    "copilot-cli",
-    "aider",
-    "cline-cli",
-    "codex",
-    "cortex-code",
-    "cursor-cli",
-    "gemini-cli",
-    "antigravity-cli",
-    "antigravity-sdk",
-    "rovodev-cli",
-    "goose",
-    "grok-build",
-    "hermes",
-    "kimi-code",
-    "kimi-cli",
-    "langgraph",
-    "deerflow",
-    "mini-swe-agent",
-    "nemo-agent",
-    "swe-agent",
-    "opencode",
-    "mimo",
-    "openclaw",
-    "openhands",
-    "openhands-sdk",
-    "pi",
-    "qwen-coder",
-    "devin",
-    "trae-agent",
-    "computer-1",
-    "eve",
-    "dspy-rlm",
-    "vibe",
-];
-export async function smokeAllAdapters(options) {
-    const jobsDirectory = resolve(options.jobsDirectory);
-    const reportsDirectory = join(jobsDirectory, "adapter-smoke");
-    await mkdir(reportsDirectory, { recursive: true });
-    const results = await parallelMap(HARBOR_AGENT_ADAPTERS, options.concurrency ?? 4, async (agent) => {
-        const reportPath = join(reportsDirectory, `${agent}.json`);
-        const existing = await readFile(reportPath, "utf8").catch(() => undefined);
-        if (existing) {
-            return JSON.parse(existing);
-        }
-        const jobName = `install-${agent}-${crypto.randomUUID().slice(0, 8)}`;
-        const result = await runCommand(options.harborPath ?? "harbor", [
-            "run",
-            "--path",
-            resolve(options.taskDirectory),
-            "--agent",
-            agent,
-            "--env",
-            options.environment ?? "modal",
-            "--job-name",
-            jobName,
-            "--jobs-dir",
-            jobsDirectory,
-            "--install-only",
-            "--n-concurrent",
-            "1",
-            "--max-retries",
-            "0",
-            "--delete",
-            "--yes",
-            "--quiet",
-        ], {
-            allowFailure: true,
-            env: harborChildEnvironment(),
-            timeoutMs: 60 * 60 * 1000,
-        });
-        const summary = {
-            agent,
-            installed: result.exitCode === 0,
-            exitCode: result.exitCode,
-            jobName,
-            outputTail: `${result.stdout}\n${result.stderr}`.trim().slice(-2_000),
-        };
-        await writeFile(reportPath, `${JSON.stringify(summary, null, 2)}\n`, { flag: "wx" });
-        return summary;
-    });
-    await writeFile(join(reportsDirectory, "summary.json"), `${JSON.stringify({
-        schemaVersion: 1,
-        mode: "install-only",
-        environment: options.environment ?? "modal",
-        adapterCount: results.length,
-        installed: results.filter((result) => result.installed).length,
-        failed: results.filter((result) => !result.installed).length,
-        results,
-    }, null, 2)}\n`);
-    return results;
-}
-//# sourceMappingURL=agent-smoke.js.map