@wix/pathgrade 1.0.8 → 1.0.10

package/bin/pathgrade.js

@@ -1,2 +1,7 @@
 #!/usr/bin/env node
-import '../dist/pathgrade.js';
+import { runPathgradeCli } from '../dist/pathgrade.js';
+
+runPathgradeCli().catch(error => {
+  console.error(error);
+  process.exit(1);
+});

package/dist/agents/{opencode-contract.d.ts → opencode/contract.d.ts}

@@ -1,5 +1,5 @@
-import type { MockMcpServerDescriptor } from '../core/mcp-mock.types.js';
-import type { AgentName, AgentOptions } from '../sdk/types.js';
+import type { MockMcpServerDescriptor } from '../../core/mcp-mock.types.js';
+import type { AgentName, AgentOptions } from '../../sdk/types.js';
 export declare const OPENCODE_MODEL = "anthropic/claude-sonnet-5";
 export declare const OPENCODE_VERSION = "1.18.18";
 export interface OpenCodeRuntimeLockEntry {

package/dist/agents/opencode/process-groups.d.ts

@@ -0,0 +1,3 @@
+export declare function killOpenCodeProcessGroup(pid: number, signal: NodeJS.Signals): void;
+export declare function registerOpenCodeProcessGroup(pid: number): void;
+export declare function unregisterOpenCodeProcessGroup(pid: number): void;

package/dist/agents/opencode/process-groups.js

@@ -0,0 +1,47 @@
+/** Process-wide ownership of detached OpenCode child process groups. */
+const activeProcessGroups = new Set();
+let processCleanupInstalled = false;
+export function killOpenCodeProcessGroup(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+    }
+    catch {
+        // The process group may already have exited.
+    }
+}
+function killAllProcessGroups() {
+    for (const pid of activeProcessGroups) {
+        killOpenCodeProcessGroup(pid, 'SIGKILL');
+    }
+    activeProcessGroups.clear();
+}
+function uninstallProcessCleanup() {
+    if (!processCleanupInstalled)
+        return;
+    processCleanupInstalled = false;
+    process.removeListener('exit', onProcessExit);
+    process.removeListener('SIGINT', onProcessSignal);
+    process.removeListener('SIGTERM', onProcessSignal);
+}
+function onProcessExit() {
+    killAllProcessGroups();
+}
+function onProcessSignal(signal) {
+    killAllProcessGroups();
+    uninstallProcessCleanup();
+    process.kill(process.pid, signal);
+}
+export function registerOpenCodeProcessGroup(pid) {
+    activeProcessGroups.add(pid);
+    if (processCleanupInstalled)
+        return;
+    processCleanupInstalled = true;
+    process.once('exit', onProcessExit);
+    process.once('SIGINT', onProcessSignal);
+    process.once('SIGTERM', onProcessSignal);
+}
+export function unregisterOpenCodeProcessGroup(pid) {
+    activeProcessGroups.delete(pid);
+    if (activeProcessGroups.size === 0)
+        uninstallProcessCleanup();
+}

package/dist/agents/opencode.js

@@ -7,7 +7,8 @@ import fs from 'fs-extra';
 import { BaseAgent, getRuntimeEnv, getWorkspacePath, } from '../types.js';
 import { buildSummary, enrichSkillEvents } from '../tool-events.js';
 import { readStagedMcpServers } from '../providers/mcp-config.js';
-import { currentOpenCodePlatformKey, OPENCODE_MODEL, OPENCODE_RUNTIME_LOCK, } from './opencode-contract.js';
+import { currentOpenCodePlatformKey, OPENCODE_MODEL, OPENCODE_RUNTIME_LOCK, } from './opencode/contract.js';
+import { killOpenCodeProcessGroup, registerOpenCodeProcessGroup, unregisterOpenCodeProcessGroup, } from './opencode/process-groups.js';
 const OUTPUT_CAP_BYTES = 16 * 1024 * 1024;
 const FIXED_OPENCODE_ENV = {
     OPENCODE_CLIENT: 'pathgrade',
@@ -68,6 +69,7 @@ export function spawnOpenCode(executable, args, options) {
         let aborted = false;
         let killTimer;
         let settled = false;
+        let terminating = false;
         const child = spawn(executable, args, {
             cwd: options.cwd,
             env: options.env,
@@ -75,22 +77,22 @@ export function spawnOpenCode(executable, args, options) {
             detached: true,
             stdio: ['pipe', 'pipe', 'pipe'],
         });
+        if (child.pid)
+            registerOpenCodeProcessGroup(child.pid);
         const killGroup = (signal) => {
             if (!child.pid)
                 return;
-            try {
-                process.kill(-child.pid, signal);
-            }
-            catch {
-                // The process may have exited between the state check and kill.
-            }
+            killOpenCodeProcessGroup(child.pid, signal);
         };
         const terminate = () => {
+            terminating = true;
             killGroup('SIGTERM');
             killTimer ??= setTimeout(() => killGroup('SIGKILL'), 250);
             killTimer.unref();
         };
         const onAbort = () => {
+            if (aborted)
+                return;
             aborted = true;
             terminate();
         };
@@ -98,9 +100,6 @@ export function spawnOpenCode(executable, args, options) {
             overflow = true;
             terminate();
         };
-        options.signal?.addEventListener('abort', onAbort, { once: true });
-        if (options.signal?.aborted)
-            onAbort();
         child.stdout.on('data', (chunk) => {
             stdoutBytes += chunk.length;
             if (stdoutBytes <= cap)
@@ -114,16 +113,23 @@ export function spawnOpenCode(executable, args, options) {
                 onOverflow();
         });
         child.stdin.on('error', () => undefined);
+        child.once('error', (error) => finish(undefined, undefined, error));
+        child.once('close', (code, signal) => finish(code, signal));
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        if (options.signal?.aborted)
+            onAbort();
         if (!aborted)
             child.stdin.end(options.stdin);
         else
             child.stdin.destroy();
-        child.once('error', (error) => finish(undefined, undefined, error));
-        child.once('close', (code, signal) => finish(code, signal));
         function finish(code, signal, error) {
             if (settled)
                 return;
             settled = true;
+            if (child.pid && terminating)
+                killOpenCodeProcessGroup(child.pid, 'SIGKILL');
+            if (child.pid)
+                unregisterOpenCodeProcessGroup(child.pid);
             options.signal?.removeEventListener('abort', onAbort);
             if (killTimer)
                 clearTimeout(killTimer);
@@ -377,6 +383,7 @@ class OpenCodeSession {
     disposed = false;
     sessionId;
     inFlight;
+    disposeController = new AbortController();
     constructor(runtime, options) {
         this.workspacePath = getWorkspacePath(runtime);
         this.runtimeEnv = getRuntimeEnv(runtime);
@@ -432,11 +439,15 @@ class OpenCodeSession {
                 '--model', OPENCODE_MODEL, '--agent', 'build',
                 ...(this.sessionId ? ['--session', this.sessionId] : []),
             ];
+            const turnSignal = this.getAbortSignal();
+            const signal = turnSignal
+                ? AbortSignal.any([turnSignal, this.disposeController.signal])
+                : this.disposeController.signal;
             const processResult = await spawnOpenCode(this.resolvedExecutable, args, {
                 cwd: this.workspacePath,
                 env,
                 stdin: message,
-                signal: this.getAbortSignal(),
+                signal,
             });
             const parsed = parseOpenCodeOutput(processResult.stdout, processResult, this.mcpToolNames);
             if (this.sessionId && parsed.sessionId !== this.sessionId) {
@@ -494,6 +505,7 @@ class OpenCodeSession {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.disposeController.abort();
         await this.inFlight?.catch(() => undefined);
         await this.cleanupState();
     }

package/dist/commands/init.d.ts

@@ -1,3 +1,5 @@
-export declare function runInit(dir: string, opts?: {
+export interface InitOptions {
     force?: boolean;
-}): Promise<void>;
+    commandName?: string;
+}
+export declare function runInit(dir: string, opts?: InitOptions): Promise<void>;

package/dist/commands/init.js

@@ -22,6 +22,11 @@ async function findExistingEvalFile(dir) {
     return null;
 }
 export async function runInit(dir, opts = {}) {
+    const commandName = opts.commandName?.trim() || 'pathgrade';
+    const skills = await detectSkills(dir);
+    const dirName = path.basename(dir);
+    const evalName = skills.length === 1 ? skills[0].name : dirName;
+    const evalPath = resolveEvalPath(dir, evalName);
     const existing = await findExistingEvalFile(dir);
     if (existing) {
         if (opts.force) {
@@ -33,16 +38,11 @@ export async function runInit(dir, opts = {}) {
             throw new Error(`${name} already exists`);
         }
     }
-    console.log('\npathgrade init\n');
-    // Detect skills
-    const skills = await detectSkills(dir);
-    // Derive eval filename: <skill-name>.eval.ts or <dirname>.eval.ts
-    const dirName = path.basename(dir);
+    console.log(`\n${commandName} init\n`);
     if (skills.length === 0) {
         console.log('  No SKILL.md found. Creating a generic template.');
         console.log('     Place a SKILL.md in this directory for better scaffolding.\n');
-        const evalPath = path.join(dir, `${dirName}.eval.ts`);
-        await writeTemplate(evalPath, 'my-skill', 'Describe what the agent should do with this skill.');
+        await writeTemplate(evalPath, 'my-skill', 'Describe what the agent should do with this skill.', commandName);
         return;
     }
     console.log(`  Found ${skills.length} skill(s): ${skills.map(s => s.name).join(', ')}\n`);
@@ -61,17 +61,15 @@ export async function runInit(dir, opts = {}) {
     const openaiKey = process.env.OPENAI_API_KEY;
     const hasApiKey = !!(anthropicKey || openaiKey);
     const cliAvailable = await isClaudeCliAvailable();
-    const evalName = skills.length === 1 ? skills[0].name : dirName;
-    const evalPath = path.join(dir, `${evalName}.eval.ts`);
     if (hasApiKey || cliAvailable) {
         const { Spinner, fmt } = await import('../utils/cli.js');
         const label = 'generating eval with available LLM backend';
         const spinner = new Spinner('init', label);
         try {
             const config = await generateWithLLM(skills);
-            await fs.writeFile(evalPath, config, 'utf-8');
+            await writeEvalFile(evalPath, config);
             spinner.stop(fmt.green(`created ${path.basename(evalPath)}`));
-            console.log(`     Review and edit the file, then run: pathgrade\n`);
+            console.log(`     Review and edit the file, then run: ${commandName}\n`);
             return;
         }
         catch (err) {
@@ -86,9 +84,9 @@ export async function runInit(dir, opts = {}) {
     const skill = skills[0];
     const taskName = `test-${skill.name}`;
     const instruction = extractInstructionHint(skill.skillMd);
-    await writeTemplate(evalPath, taskName, instruction);
+    await writeTemplate(evalPath, taskName, instruction, commandName);
 }
-async function writeTemplate(evalPath, taskName, instruction) {
+async function writeTemplate(evalPath, taskName, instruction, commandName) {
     const templatePath = path.join(import.meta.dirname, '..', '..', 'templates', 'eval.ts.template');
     let template;
     if (await fs.pathExists(templatePath)) {
@@ -101,9 +99,38 @@ async function writeTemplate(evalPath, taskName, instruction) {
     const result = template
         .replace(/\{\{TASK_NAME\}\}/g, taskName)
         .replace(/\{\{INSTRUCTION\}\}/g, instruction);
-    await fs.writeFile(evalPath, result, 'utf-8');
+    await writeEvalFile(evalPath, result);
     console.log(`  Created ${path.basename(evalPath)}.`);
-    console.log(`     Edit the file to define your eval tasks, then run: pathgrade\n`);
+    console.log(`     Edit the file to define your eval tasks, then run: ${commandName}\n`);
+}
+function resolveEvalPath(dir, evalName) {
+    const baseDir = path.resolve(dir);
+    if (!evalName
+        || evalName === '.'
+        || evalName === '..'
+        || path.basename(evalName) !== evalName
+        || evalName.includes('/')
+        || evalName.includes('\\')) {
+        throw new Error(`Invalid skill name for eval filename: ${JSON.stringify(evalName)}`);
+    }
+    const evalPath = path.resolve(baseDir, `${evalName}.eval.ts`);
+    if (path.dirname(evalPath) !== baseDir) {
+        throw new Error(`Eval filename escapes the target directory: ${JSON.stringify(evalName)}`);
+    }
+    return evalPath;
+}
+async function writeEvalFile(evalPath, content) {
+    try {
+        const stat = await fs.lstat(evalPath);
+        if (stat.isSymbolicLink()) {
+            throw new Error(`Refusing to write eval through symbolic link: ${path.basename(evalPath)}`);
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    await fs.writeFile(evalPath, content, 'utf-8');
 }
 /**
  * Extract a reasonable instruction hint from SKILL.md content.

package/dist/commands/validate.js

@@ -15,6 +15,8 @@ import fs from 'fs-extra';
 import { findSkillRoot } from '../affected/anchor.js';
 import { parsePathgradeMeta } from '../affected/meta.js';
 import { discoverEvalFiles } from './affected.js';
+import * as ts from 'typescript';
+import { hasEvalSdkImport } from '../evals/sdk-import.js';
 /**
  * Run the validate command. Returns exit code (0 = valid, 1 = errors).
  */
@@ -40,8 +42,12 @@ export async function runValidate(filePath, opts = {}) {
         }
     }
     // Check 3: Imports
-    if (!content.includes("from '@wix/pathgrade'") && !content.includes('from "@wix/pathgrade"')) {
-        errors.push({ check: 'imports-pathgrade', message: "No import from '@wix/pathgrade' found." });
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+    if (!hasEvalSdkImport(sourceFile)) {
+        errors.push({
+            check: 'imports-pathgrade',
+            message: 'No recognizable eval SDK import found.',
+        });
     }
     // Check 4: describe/it blocks
     if (!/describe\s*\(/.test(content) || !/it\s*\(/.test(content)) {

package/dist/evals/discovery.js

@@ -2,8 +2,8 @@ import * as fs from 'fs';
 import * as path from 'path';
 import picomatch from 'picomatch';
 import * as ts from 'typescript';
+import { hasEvalSdkImport } from './sdk-import.js';
 const EVAL_SUFFIX = '.eval.ts';
-const PATHGRADE_PACKAGE = '@wix/pathgrade';
 export function discoverPathgradeEvalFiles(opts) {
     const { cwd, include, exclude } = opts;
     const root = path.resolve(cwd);
@@ -48,16 +48,8 @@ export function isPathgradeEval(absPath) {
     const source = fs.readFileSync(absPath, 'utf8');
     const sourceFile = ts.createSourceFile(absPath, source, ts.ScriptTarget.Latest, 
     /* setParentNodes */ false, ts.ScriptKind.TS);
-    for (const stmt of sourceFile.statements) {
-        if (isPathgradeImport(stmt) || isPathgradeMetaExport(stmt))
-            return true;
-    }
-    return false;
-}
-function isPathgradeImport(stmt) {
-    if (!ts.isImportDeclaration(stmt))
-        return false;
-    return ts.isStringLiteral(stmt.moduleSpecifier) && stmt.moduleSpecifier.text === PATHGRADE_PACKAGE;
+    return hasEvalSdkImport(sourceFile)
+        || sourceFile.statements.some(isPathgradeMetaExport);
 }
 function isPathgradeMetaExport(stmt) {
     if (!ts.isVariableStatement(stmt))

package/dist/evals/sdk-import.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+/** Detects the Pathgrade SDK shape without depending on a module specifier. */
+export declare function hasEvalSdkImport(sourceFile: ts.SourceFile): boolean;

package/dist/evals/sdk-import.js

@@ -0,0 +1,76 @@
+import * as ts from 'typescript';
+const PATHGRADE_PACKAGE = '@wix/pathgrade';
+const SUPPORTING_SDK_IMPORTS = new Set([
+    'Agent',
+    'check',
+    'judge',
+    'score',
+    'toolUsage',
+]);
+/** Detects the Pathgrade SDK shape without depending on a module specifier. */
+export function hasEvalSdkImport(sourceFile) {
+    const sdkSignalsBySource = new Map();
+    const namespaceSources = new Map();
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isImportDeclaration(stmt))
+            continue;
+        if (ts.isStringLiteral(stmt.moduleSpecifier)
+            && stmt.moduleSpecifier.text === PATHGRADE_PACKAGE)
+            return true;
+        const bindings = stmt.importClause?.namedBindings;
+        const importSource = ts.isStringLiteral(stmt.moduleSpecifier)
+            ? stmt.moduleSpecifier.text
+            : stmt.moduleSpecifier.getText(sourceFile);
+        if (bindings && ts.isNamespaceImport(bindings)) {
+            namespaceSources.set(bindings.name.text, importSource);
+            continue;
+        }
+        if (bindings && ts.isNamedImports(bindings)) {
+            const importedNames = sdkSignalsBySource.get(importSource) ?? new Set();
+            for (const element of bindings.elements) {
+                importedNames.add(element.propertyName?.text ?? element.name.text);
+            }
+            sdkSignalsBySource.set(importSource, importedNames);
+        }
+    }
+    function addNamespaceMember(namespace, member) {
+        const importSource = namespaceSources.get(namespace);
+        if (!importSource)
+            return;
+        const members = sdkSignalsBySource.get(importSource) ?? new Set();
+        members.add(member);
+        sdkSignalsBySource.set(importSource, members);
+    }
+    function visit(node) {
+        if (ts.isPropertyAccessExpression(node)
+            && ts.isIdentifier(node.expression)
+            && namespaceSources.has(node.expression.text)) {
+            addNamespaceMember(node.expression.text, node.name.text);
+        }
+        if (ts.isQualifiedName(node)
+            && ts.isIdentifier(node.left)
+            && namespaceSources.has(node.left.text)) {
+            addNamespaceMember(node.left.text, node.right.text);
+        }
+        if (ts.isVariableDeclaration(node)
+            && ts.isObjectBindingPattern(node.name)
+            && node.initializer
+            && ts.isIdentifier(node.initializer)
+            && namespaceSources.has(node.initializer.text)) {
+            for (const element of node.name.elements) {
+                const importedName = element.propertyName ?? element.name;
+                if (ts.isIdentifier(importedName)) {
+                    addNamespaceMember(node.initializer.text, importedName.text);
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return [...sdkSignalsBySource.values()].some(matchesSdkShape);
+}
+function matchesSdkShape(names) {
+    return names.has('evaluate')
+        && (names.has('createAgent')
+            || [...SUPPORTING_SDK_IMPORTS].some(name => names.has(name)));
+}

package/dist/pathgrade.d.ts

@@ -7,4 +7,8 @@
  *   pathgrade init [--force]         Generate eval scaffolding
  *   pathgrade preview [browser]      View results (CLI default, or browser)
  */
-export {};
+export interface PathgradeCliOptions {
+    name?: string;
+    version?: string;
+}
+export declare function runPathgradeCli(options?: PathgradeCliOptions): Promise<void>;

package/dist/pathgrade.js

@@ -9,6 +9,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { fileURLToPath } from 'node:url';
 import { runInit } from './commands/init.js';
 import { runAnalyze } from './commands/analyze.js';
 import { runValidate, runValidateAffected } from './commands/validate.js';
@@ -58,15 +59,20 @@ function validateApiKeys() {
             `  ${fmt.dim('         Claude CLI auth (keychain) and Codex exec cached login (~/.codex/auth.json) may still work if installed.')}\n`);
     }
 }
-async function main() {
+export async function runPathgradeCli(options = {}) {
+    const cliName = options.name?.trim() || 'pathgrade';
     shutdown.install();
     const args = process.argv.slice(2);
     const command = args[0];
     if (command === '--help' || command === '-h') {
-        printHelp();
+        printHelp(cliName);
         return;
     }
     if (command === '--version' || command === '-v') {
+        if (options.version) {
+            console.log(options.version);
+            return;
+        }
         const pkg = JSON.parse(await import('fs').then(fs => fs.promises.readFile(new URL('../package.json', import.meta.url), 'utf-8')));
         console.log(pkg.version);
         return;
@@ -89,7 +95,7 @@ async function main() {
         }
         const filePath = validateArgs[0];
         if (!filePath) {
-            console.error('Usage: pathgrade validate <file.eval.ts>  |  pathgrade validate --affected');
+            console.error(`Usage: ${cliName} validate <file.eval.ts>  |  ${cliName} validate --affected`);
             process.exitCode = 1;
             return;
         }
@@ -99,13 +105,16 @@ async function main() {
     }
     if (command === 'init') {
         const hasForce = args.includes('--force');
-        await runInit(process.cwd(), { force: hasForce });
+        await runInit(process.cwd(), {
+            force: hasForce,
+            commandName: cliName,
+        });
         return;
     }
     if (command === 'clean') {
         const result = await runClean(process.cwd(), parseCleanArgs(args.slice(1)));
         const action = result.dryRun ? 'would remove' : 'removed';
-        console.log(`pathgrade: ${action} ${result.removed} debug run(s); ` +
+        console.log(`${cliName}: ${action} ${result.removed} debug run(s); ` +
             `retained ${result.retained}; active ${result.active}`);
         return;
     }
@@ -159,7 +168,7 @@ async function main() {
         validateApiKeys();
         const parsed = parsePathgradeRunArgs(command === 'run' ? args.slice(1) : args);
         for (const warning of parsed.warnings ?? []) {
-            console.error(`pathgrade: ${warning}`);
+            console.error(`${cliName}: ${warning}`);
         }
         if (parsed.changed) {
             const exitCode = await runChanged({
@@ -194,15 +203,15 @@ async function main() {
         return;
     }
     console.error(`Unknown command: ${command}`);
-    console.error('Run "pathgrade --help" for usage.');
+    console.error(`Run "${cliName} --help" for usage.`);
     process.exitCode = 1;
 }
-function printHelp() {
+function printHelp(cliName) {
     console.log(`
-  pathgrade - Evaluate AI agent skills with a runner adapter
+  ${cliName} - Evaluate AI agent skills with a runner adapter
 
   Usage:
-    pathgrade run [-- runner-args]   Run evals (loads .env, delegates to the selected adapter)
+    ${cliName} run [-- runner-args]   Run evals (loads .env, delegates to the selected adapter)
                      [--changed]               Run only evals affected by the current PR/change-set
                      [--since=<ref>]           Override base ref (implies git mode)
                      [--changed-files=<path>]  Use an explicit newline-delimited file list
@@ -210,22 +219,22 @@ function printHelp() {
                      [--diagnostics]           Print full diagnostics for passing evals too
                      [--quiet]                 Suppress the run-start summary
                      [--verbose|-v]            Stream live per-turn events to stderr during the run
-    pathgrade init [--force]         Generate eval scaffolding
-    pathgrade analyze [--skill=X]    Analyze skills and output JSON
-    pathgrade validate <file>        Validate an .eval.ts file
-    pathgrade validate --affected    Strict: every eval must be anchored or have valid __pathgradeMeta
-    pathgrade clean --debug          Remove completed debug runs
+    ${cliName} init [--force]         Generate eval scaffolding
+    ${cliName} analyze [--skill=X]    Analyze skills and output JSON
+    ${cliName} validate <file>        Validate an .eval.ts file
+    ${cliName} validate --affected    Strict: every eval must be anchored or have valid __pathgradeMeta
+    ${cliName} clean --debug          Remove completed debug runs
                      [--keep=N]      Keep the N newest completed debug runs
                      [--dry-run]     Report removals without changing files
-    pathgrade preview [browser]      View results (CLI default, or browser)
+    ${cliName} preview [browser]      View results (CLI default, or browser)
                      [--last=N]     Show only the N most recent reports
                      [--filter=X]   Filter reports by test name (substring)
-    pathgrade preview-reactions      Preview reactions against a snapshot
-    pathgrade report                 Format .pathgrade/results.json as a markdown PR comment
+    ${cliName} preview-reactions      Preview reactions against a snapshot
+    ${cliName} report                 Format .pathgrade/results.json as a markdown PR comment
                      [--results-path=<path>]   Override results.json location
                      [--no-comment]            Print markdown to stdout; do not post
                      [--comment-id=<id>]       Override comment marker (default: $GITHUB_WORKFLOW:$GITHUB_JOB)
-    pathgrade affected               Print eval files affected by a change-set (one per line)
+    ${cliName} affected               Print eval files affected by a change-set (one per line)
                      [--since=<ref>]           Diff <ref>...HEAD (overrides git auto-detection)
                      [--changed-files=<path>]  Newline-delimited repo-relative file list
                      [--explain]               Print human-readable per-eval decision to stderr
@@ -237,16 +246,19 @@ function printHelp() {
     OPENAI_API_KEY                   API key for Codex and OpenAI-backed judges
 
   Examples:
-    pathgrade run                    # run all *.eval.ts files
-    pathgrade run --diagnostics      # print full diagnostics for passing evals too
-    pathgrade run --verbose          # stream per-turn events live to stderr while evals run
-    pathgrade run -- --grep superlint   # filter by test name
-    pathgrade init                   # scaffold eval files
-    pathgrade preview browser        # open web UI
-    pathgrade preview-reactions --snapshot ./pathgrade-debug/run-snapshot.json --reactions ./reactions.ts
+    ${cliName} run                    # run all *.eval.ts files
+    ${cliName} run --diagnostics      # print full diagnostics for passing evals too
+    ${cliName} run --verbose          # stream per-turn events live to stderr while evals run
+    ${cliName} run -- --grep superlint   # filter by test name
+    ${cliName} init                   # scaffold eval files
+    ${cliName} preview browser        # open web UI
+    ${cliName} preview-reactions --snapshot ./pathgrade-debug/run-snapshot.json --reactions ./reactions.ts
 `);
 }
-main().catch(err => {
-    console.error(err);
-    process.exit(1);
-});
+if (process.argv[1]
+    && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    runPathgradeCli().catch(err => {
+        console.error(err);
+        process.exit(1);
+    });
+}

package/dist/sdk/agent.js

@@ -15,7 +15,7 @@ import { createVerboseEmitter } from '../reporters/verbose-emitter.js';
 import fs from 'fs-extra';
 import * as path from 'path';
 import { cleanDebugRuns, DEFAULT_DEBUG_RETAIN_RUNS, prepareManagedDebugRun, } from '../providers/debug-runs.js';
-import { collectOpenCodeMcpToolNames, validateOpenCodeDeclaration } from '../agents/opencode-contract.js';
+import { collectOpenCodeMcpToolNames, validateOpenCodeDeclaration } from '../agents/opencode/contract.js';
 /**
  * Test-only injection point: override the sink used by the next emitter
  * built inside `createAgent`. Pass `null` to restore the default (stderr).

package/dist/sdk/judge-tool-session.js

@@ -35,13 +35,14 @@ export async function runJudgeSession(input, options = {}) {
         { role: 'user', content: user },
     ];
     let rounds = 0;
+    let scoreRepairAttempted = false;
     while (rounds < maxRounds) {
         rounds++;
         let response;
         try {
             response = await llm.callWithTools(messages, {
                 system,
-                tools: toolSchemas,
+                tools: scoreRepairAttempted ? [] : toolSchemas,
                 model: scorer.model,
                 cacheControl: scorer.cacheControl,
             });
@@ -63,6 +64,22 @@ export async function runJudgeSession(input, options = {}) {
             }
             const parsed = parseFinalScore(response.text);
             if (!parsed.ok) {
+                if (parsed.message.startsWith('JSON parse failed:')
+                    && !scoreRepairAttempted
+                    && rounds < maxRounds) {
+                    scoreRepairAttempted = true;
+                    messages.push({ role: 'assistant', content: response.text });
+                    messages.push({
+                        role: 'user',
+                        content: [
+                            `Your final answer was not valid JSON: ${parsed.message}.`,
+                            'Return ONLY a valid JSON object with double-quoted keys in this exact shape:',
+                            '{"score": <number 0..1>, "details": "<brief explanation>"}',
+                            'Do not call more tools or include Markdown fences.',
+                        ].join('\n'),
+                    });
+                    continue;
+                }
                 return makeOutcome(tokenUsage, toolCalls, logEntries, rounds, {
                     code: 'invalid_score',
                     details: parsed.message,

package/dist/utils/llm-providers/anthropic.js

@@ -11,6 +11,11 @@ function resolveBaseUrl(env) {
         || process.env.APP_ANTHROPIC_BASE_URL
         || 'https://api.anthropic.com';
 }
+function resolveMessagesUrl(env) {
+    const baseUrl = resolveBaseUrl(env).replace(/\/+$/, '');
+    const apiRoot = baseUrl.endsWith('/v1') ? baseUrl : `${baseUrl}/v1`;
+    return `${apiRoot}/messages`;
+}
 function buildHeaders(apiKey, useCache) {
     const headers = {
         'Content-Type': 'application/json',
@@ -57,7 +62,7 @@ function resolveTemperature(model, config, temperature) {
     return temperature ?? 0;
 }
 async function postAnthropic(apiKey, useCache, body, env) {
-    const response = await fetch(`${resolveBaseUrl(env)}/v1/messages`, {
+    const response = await fetch(resolveMessagesUrl(env), {
         method: 'POST',
         headers: buildHeaders(apiKey, useCache),
         body: JSON.stringify(body),

package/dist/utils/llm.js

@@ -199,6 +199,7 @@ export function createAgentLLM(agentName, agentEnv) {
     const adapters = agentEnv && Object.keys(agentEnv).length > 0
         ? baseAdapters.map((a) => ({
             ...a,
+            isAvailable: (env) => a.isAvailable({ ...agentEnv, ...env }),
             call: (prompt, opts) => a.call(prompt, { ...opts, env: { ...agentEnv, ...opts.env } }),
             ...(a.callWithTools
                 ? { callWithTools: (messages, opts) => a.callWithTools(messages, { ...opts, env: { ...agentEnv, ...opts.env } }) }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/pathgrade",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "packageManager": "yarn@4.12.0",
   "description": "Evaluate whether AI agents discover and use your skills correctly",
   "exports": {
@@ -44,6 +44,10 @@
       "types": "./dist/core/mcp-mock.d.ts",
       "default": "./dist/core/mcp-mock.js"
     },
+    "./cli": {
+      "types": "./dist/pathgrade.d.ts",
+      "default": "./dist/pathgrade.js"
+    },
     "./package.json": "./package.json"
   },
   "bin": "bin/pathgrade.js",
@@ -128,5 +132,5 @@
     "typescript": "^5.9.3",
     "zod": "4.3.6"
   },
-  "falconPackageHash": "3a6990dfd4a93a86e7bd1cf9acc42873b8b0b580f5a9b0d7c9692ed5"
+  "falconPackageHash": "be877aa61dfb2cd1b58c716b704cffee9592428675a660382e86e358"
 }