@ai-sdlc/orchestrator 0.6.0 → 0.9.0

package/dist/harness/adapters/claude-code.js

@@ -0,0 +1,191 @@
+/**
+ * ClaudeCodeAdapter — wraps Claude Code CLI behind the HarnessAdapter contract.
+ * Uses the local `claude` CLI in `-p --output-format stream-json` mode, authenticating
+ * via whatever credential the CLI is logged into (Pro/Max subscription or API key).
+ */
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { probeVersion } from '../version-probe.js';
+const DEFAULT_AVAILABLE_MODELS = [
+    'claude-haiku-4-5-20251001',
+    'claude-sonnet-4-6',
+    'claude-opus-4-7',
+    'claude-opus-4-7[1m]',
+];
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+const HEARTBEAT_INTERVAL_MS = 30_000;
+export class ClaudeCodeAdapter {
+    deps;
+    name = 'claude-code';
+    capabilities = {
+        freshContext: true,
+        customTools: true,
+        streaming: true,
+        worktreeAwareCwd: true,
+        skills: true,
+        artifactWrites: true,
+        maxContextTokens: 1_000_000,
+    };
+    requires = {
+        binary: 'claude',
+        versionRange: '>=2.0.0',
+        versionProbe: {
+            args: ['--version'],
+            parse: (stdout) => stdout.match(/(\d+\.\d+\.\d+)/)?.[1] ?? '',
+        },
+    };
+    cachedAvailability = null;
+    constructor(deps = {}) {
+        this.deps = deps;
+    }
+    async getAccountId() {
+        const env = this.deps.env ?? process.env;
+        const tokenSources = [env.ANTHROPIC_API_KEY, env.CLAUDE_CODE_API_KEY, env.ANTHROPIC_AUTH_TOKEN];
+        for (const source of tokenSources) {
+            if (source && source.length > 0) {
+                return createHash('sha256').update(`claude-code:${source}`).digest('hex').slice(0, 16);
+            }
+        }
+        return null;
+    }
+    async isAvailable() {
+        if (this.cachedAvailability)
+            return this.cachedAvailability;
+        const result = this.deps.probe ? await this.deps.probe() : await probeVersion(this.requires);
+        this.cachedAvailability = result;
+        return result;
+    }
+    async invoke(input, onEvent) {
+        if (this.deps.invoke)
+            return this.deps.invoke(input, onEvent);
+        return runClaudeCli(input, this.deps.spawn ?? spawn, onEvent);
+    }
+    async availableModels() {
+        return DEFAULT_AVAILABLE_MODELS;
+    }
+}
+function runClaudeCli(input, spawnFn, onEvent) {
+    const timeoutMs = parseDurationMs(input.timeout) ?? DEFAULT_TIMEOUT_MS;
+    const args = ['-p', '--output-format', 'stream-json', '--verbose', '--model', input.model];
+    return new Promise((resolve) => {
+        const startTs = Date.now();
+        onEvent?.({ type: 'started', timestamp: new Date().toISOString() });
+        let child;
+        try {
+            child = spawnFn('claude', args, {
+                cwd: input.cwd,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: process.env,
+                timeout: timeoutMs,
+            });
+        }
+        catch (err) {
+            resolve({
+                status: 'unavailable',
+                exitCode: -1,
+                costUsd: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                artifactPaths: [],
+                errorDetail: `failed to spawn 'claude': ${err.message}`,
+            });
+            return;
+        }
+        let resultText = '';
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let costUsd = 0;
+        let lineBuf = '';
+        const errBuf = [];
+        const heartbeat = setInterval(() => {
+            onEvent?.({
+                type: 'heartbeat',
+                timestamp: new Date().toISOString(),
+                message: `${Math.round((Date.now() - startTs) / 1000)}s elapsed`,
+            });
+        }, HEARTBEAT_INTERVAL_MS);
+        child.stdout?.on('data', (chunk) => {
+            lineBuf += chunk.toString('utf-8');
+            const lines = lineBuf.split('\n');
+            lineBuf = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const ev = JSON.parse(trimmed);
+                    if (ev.type === 'result') {
+                        resultText = ev.result ?? '';
+                        costUsd = ev.total_cost_usd ?? 0;
+                        const modelUsage = ev.modelUsage;
+                        if (modelUsage) {
+                            const firstModel = Object.keys(modelUsage)[0];
+                            if (firstModel) {
+                                const usage = modelUsage[firstModel];
+                                inputTokens = usage.inputTokens ?? 0;
+                                outputTokens = usage.outputTokens ?? 0;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Non-JSON line (claude occasionally emits status text); ignore.
+                }
+            }
+        });
+        child.stderr?.on('data', (chunk) => {
+            errBuf.push(chunk);
+        });
+        child.on('error', (err) => {
+            clearInterval(heartbeat);
+            resolve({
+                status: 'unavailable',
+                exitCode: -1,
+                costUsd,
+                inputTokens,
+                outputTokens,
+                artifactPaths: [],
+                errorDetail: `claude spawn error: ${err.message}`,
+            });
+        });
+        child.on('close', (code, signal) => {
+            clearInterval(heartbeat);
+            const stderr = Buffer.concat(errBuf).toString('utf-8');
+            const status = code === 0
+                ? 'success'
+                : signal === 'SIGTERM' || signal === 'SIGKILL'
+                    ? 'timeout'
+                    : 'failure';
+            onEvent?.({
+                type: 'completed',
+                timestamp: new Date().toISOString(),
+                status,
+            });
+            resolve({
+                status,
+                exitCode: code ?? -1,
+                costUsd,
+                inputTokens,
+                outputTokens,
+                artifactPaths: [],
+                outputText: resultText,
+                errorDetail: status === 'success' ? undefined : stderr.slice(-500) || undefined,
+            });
+        });
+        child.stdin?.write(input.prompt);
+        child.stdin?.end();
+    });
+}
+function parseDurationMs(duration) {
+    if (!duration)
+        return null;
+    const m = duration.match(/^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/);
+    if (!m)
+        return null;
+    const days = Number.parseInt(m[1] ?? '0', 10);
+    const hours = Number.parseInt(m[2] ?? '0', 10);
+    const minutes = Number.parseInt(m[3] ?? '0', 10);
+    const seconds = Number.parseInt(m[4] ?? '0', 10);
+    return (((days * 24 + hours) * 60 + minutes) * 60 + seconds) * 1000;
+}
+//# sourceMappingURL=claude-code.js.map

package/dist/harness/adapters/codex.d.ts

@@ -0,0 +1,25 @@
+/**
+ * CodexAdapter — wraps OpenAI Codex CLI behind the HarnessAdapter contract.
+ * Phase 2.7 ships the adapter shell; the actual end-to-end Codex invocation against a
+ * fixture worktree is deferred to Phase 3 dispatcher integration. The adapter's
+ * capabilities, version probe, and account-id derivation are wired and tested here.
+ */
+import type { HarnessAdapter, HarnessAvailability, HarnessCapabilities, HarnessEvent, HarnessInput, HarnessName, HarnessRequires, HarnessResult } from '../types.js';
+export interface CodexAdapterDeps {
+    env?: NodeJS.ProcessEnv;
+    invoke?: (input: HarnessInput, onEvent?: (e: HarnessEvent) => void) => Promise<HarnessResult>;
+    probe?: () => Promise<HarnessAvailability>;
+}
+export declare class CodexAdapter implements HarnessAdapter {
+    private readonly deps;
+    readonly name: HarnessName;
+    readonly capabilities: HarnessCapabilities;
+    readonly requires: HarnessRequires;
+    private cachedAvailability;
+    constructor(deps?: CodexAdapterDeps);
+    getAccountId(): Promise<string | null>;
+    isAvailable(): Promise<HarnessAvailability>;
+    invoke(input: HarnessInput, onEvent?: (e: HarnessEvent) => void): Promise<HarnessResult>;
+    availableModels(): Promise<string[]>;
+}
+//# sourceMappingURL=codex.d.ts.map

package/dist/harness/adapters/codex.js

@@ -0,0 +1,61 @@
+/**
+ * CodexAdapter — wraps OpenAI Codex CLI behind the HarnessAdapter contract.
+ * Phase 2.7 ships the adapter shell; the actual end-to-end Codex invocation against a
+ * fixture worktree is deferred to Phase 3 dispatcher integration. The adapter's
+ * capabilities, version probe, and account-id derivation are wired and tested here.
+ */
+import { createHash } from 'node:crypto';
+import { probeVersion } from '../version-probe.js';
+const DEFAULT_AVAILABLE_MODELS = ['gpt-5', 'gpt-5-mini', 'o3', 'o3-mini'];
+export class CodexAdapter {
+    deps;
+    name = 'codex';
+    capabilities = {
+        freshContext: true,
+        customTools: false, // Phase 2.7: partial MCP support; track via capability declaration.
+        streaming: true,
+        worktreeAwareCwd: true,
+        skills: false,
+        artifactWrites: true,
+        maxContextTokens: 200_000,
+    };
+    requires = {
+        binary: 'codex',
+        versionRange: '>=0.1.0',
+        versionProbe: {
+            args: ['--version'],
+            parse: (stdout) => stdout.match(/(\d+\.\d+\.\d+)/)?.[1] ?? '',
+        },
+    };
+    cachedAvailability = null;
+    constructor(deps = {}) {
+        this.deps = deps;
+    }
+    async getAccountId() {
+        const env = this.deps.env ?? process.env;
+        const tokenSources = [env.OPENAI_API_KEY, env.CODEX_API_KEY];
+        for (const source of tokenSources) {
+            if (source && source.length > 0) {
+                return createHash('sha256').update(`codex:${source}`).digest('hex').slice(0, 16);
+            }
+        }
+        return null;
+    }
+    async isAvailable() {
+        if (this.cachedAvailability)
+            return this.cachedAvailability;
+        const result = this.deps.probe ? await this.deps.probe() : await probeVersion(this.requires);
+        this.cachedAvailability = result;
+        return result;
+    }
+    async invoke(input, onEvent) {
+        if (this.deps.invoke)
+            return this.deps.invoke(input, onEvent);
+        throw new Error('CodexAdapter.invoke is not wired into dispatch yet (Phase 3 work). ' +
+            'Tests should inject deps.invoke; production code should not call this method directly until Phase 3.');
+    }
+    async availableModels() {
+        return DEFAULT_AVAILABLE_MODELS;
+    }
+}
+//# sourceMappingURL=codex.js.map

package/dist/harness/independence.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Harness independence enforcement per RFC §13.10 (Q8 resolution).
+ *
+ * When a stage declares requiresIndependentHarnessFrom: [stageA, stageB], the orchestrator
+ * filters that stage's harness chain to exclude harnesses that actually ran the named
+ * upstream stages (which may differ from declared if a fallback was used).
+ *
+ * This is the load-bearing safety property for cross-harness review (RFC §13.6) — without
+ * it, fallback can silently collapse review onto the same harness as the implementer.
+ */
+import type { HarnessName } from './types.js';
+export interface UpstreamRun {
+    stage: string;
+    resolvedHarness: HarnessName;
+}
+export interface IndependenceResult {
+    effectiveChain: HarnessName[];
+    removed: HarnessName[];
+    forbidden: HarnessName[];
+    /** True when the filtered chain is empty — caller must apply onFailure. */
+    violated: boolean;
+}
+/**
+ * Filter a stage's candidate harness chain to preserve independence from named upstreams.
+ */
+export declare function enforceIndependence(candidateChain: HarnessName[], requiresIndependentFrom: string[], upstreamRuns: UpstreamRun[]): IndependenceResult;
+/**
+ * Validate that requiresIndependentHarnessFrom declarations form a DAG.
+ * Returns the set of cyclic edges (empty array means valid).
+ *
+ * Each stage is identified by name; references must point at stages that appear *earlier*
+ * in the pipeline order. References to downstream or self → cycle.
+ */
+export declare function validateIndependenceGraph(stages: ReadonlyArray<{
+    name: string;
+    requiresIndependentHarnessFrom?: string[];
+}>): Array<{
+    stage: string;
+    references: string;
+}>;
+export declare class CyclicIndependenceConstraintError extends Error {
+    readonly cycles: Array<{
+        stage: string;
+        references: string;
+    }>;
+    constructor(cycles: Array<{
+        stage: string;
+        references: string;
+    }>);
+}
+//# sourceMappingURL=independence.d.ts.map

package/dist/harness/independence.js

@@ -0,0 +1,67 @@
+/**
+ * Harness independence enforcement per RFC §13.10 (Q8 resolution).
+ *
+ * When a stage declares requiresIndependentHarnessFrom: [stageA, stageB], the orchestrator
+ * filters that stage's harness chain to exclude harnesses that actually ran the named
+ * upstream stages (which may differ from declared if a fallback was used).
+ *
+ * This is the load-bearing safety property for cross-harness review (RFC §13.6) — without
+ * it, fallback can silently collapse review onto the same harness as the implementer.
+ */
+/**
+ * Filter a stage's candidate harness chain to preserve independence from named upstreams.
+ */
+export function enforceIndependence(candidateChain, requiresIndependentFrom, upstreamRuns) {
+    const upstreamMap = new Map(upstreamRuns.map((r) => [r.stage, r.resolvedHarness]));
+    const forbidden = new Set();
+    for (const stage of requiresIndependentFrom) {
+        const h = upstreamMap.get(stage);
+        if (h)
+            forbidden.add(h);
+    }
+    const effectiveChain = candidateChain.filter((h) => !forbidden.has(h));
+    const removed = candidateChain.filter((h) => forbidden.has(h));
+    return {
+        effectiveChain,
+        removed,
+        forbidden: Array.from(forbidden),
+        violated: effectiveChain.length === 0,
+    };
+}
+/**
+ * Validate that requiresIndependentHarnessFrom declarations form a DAG.
+ * Returns the set of cyclic edges (empty array means valid).
+ *
+ * Each stage is identified by name; references must point at stages that appear *earlier*
+ * in the pipeline order. References to downstream or self → cycle.
+ */
+export function validateIndependenceGraph(stages) {
+    const stageOrder = new Map(stages.map((s, i) => [s.name, i]));
+    const cycles = [];
+    for (const [i, s] of stages.entries()) {
+        const refs = s.requiresIndependentHarnessFrom ?? [];
+        for (const ref of refs) {
+            const refIndex = stageOrder.get(ref);
+            if (refIndex === undefined) {
+                cycles.push({ stage: s.name, references: `unknown stage '${ref}'` });
+            }
+            else if (refIndex >= i) {
+                cycles.push({
+                    stage: s.name,
+                    references: `'${ref}' is not strictly upstream (cycle / self-reference)`,
+                });
+            }
+        }
+    }
+    return cycles;
+}
+export class CyclicIndependenceConstraintError extends Error {
+    cycles;
+    constructor(cycles) {
+        const summary = cycles.map((c) => `${c.stage} → ${c.references}`).join('; ');
+        super(`requiresIndependentHarnessFrom forms invalid graph: ${summary}`);
+        this.cycles = cycles;
+        this.name = 'CyclicIndependenceConstraintError';
+    }
+}
+//# sourceMappingURL=independence.js.map

package/dist/harness/index.d.ts

@@ -0,0 +1,14 @@
+export { type HarnessAdapter, type HarnessAvailability, type HarnessCapabilities, type HarnessEvent, type HarnessInput, type HarnessName, type HarnessRequires, type HarnessResult, type HarnessResultStatus, type ToolDefinition, } from './types.js';
+export { HarnessRegistry, UnknownHarnessError } from './registry.js';
+export { probeVersion, matchesRange } from './version-probe.js';
+export { enforceIndependence, validateIndependenceGraph, CyclicIndependenceConstraintError, type IndependenceResult, type UpstreamRun, } from './independence.js';
+export { ClaudeCodeAdapter, type ClaudeCodeAdapterDeps } from './adapters/claude-code.js';
+export { CodexAdapter, type CodexAdapterDeps } from './adapters/codex.js';
+import { HarnessRegistry } from './registry.js';
+/**
+ * Create a registry pre-populated with the v1 adapters (claude-code, codex).
+ * Future adapters (gemini-cli, opencode, aider, generic-api) register themselves
+ * the same way once their adapter implementations land.
+ */
+export declare function createDefaultHarnessRegistry(): HarnessRegistry;
+//# sourceMappingURL=index.d.ts.map

package/dist/harness/index.js

@@ -0,0 +1,20 @@
+export { HarnessRegistry, UnknownHarnessError } from './registry.js';
+export { probeVersion, matchesRange } from './version-probe.js';
+export { enforceIndependence, validateIndependenceGraph, CyclicIndependenceConstraintError, } from './independence.js';
+export { ClaudeCodeAdapter } from './adapters/claude-code.js';
+export { CodexAdapter } from './adapters/codex.js';
+import { HarnessRegistry } from './registry.js';
+import { ClaudeCodeAdapter } from './adapters/claude-code.js';
+import { CodexAdapter } from './adapters/codex.js';
+/**
+ * Create a registry pre-populated with the v1 adapters (claude-code, codex).
+ * Future adapters (gemini-cli, opencode, aider, generic-api) register themselves
+ * the same way once their adapter implementations land.
+ */
+export function createDefaultHarnessRegistry() {
+    const reg = new HarnessRegistry();
+    reg.register(new ClaudeCodeAdapter());
+    reg.register(new CodexAdapter());
+    return reg;
+}
+//# sourceMappingURL=index.js.map

package/dist/harness/registry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Harness adapter registry per RFC §13.2. Resolves harness names to adapter implementations.
+ * Pipeline-load fails with UnknownHarness when a stage names an unregistered harness.
+ */
+import type { HarnessAdapter, HarnessName } from './types.js';
+export declare class UnknownHarnessError extends Error {
+    readonly name: string;
+    constructor(name: string);
+}
+export declare class HarnessRegistry {
+    private readonly adapters;
+    register(adapter: HarnessAdapter): void;
+    get(name: string): HarnessAdapter;
+    has(name: string): boolean;
+    list(): HarnessName[];
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/harness/registry.js

@@ -0,0 +1,31 @@
+/**
+ * Harness adapter registry per RFC §13.2. Resolves harness names to adapter implementations.
+ * Pipeline-load fails with UnknownHarness when a stage names an unregistered harness.
+ */
+export class UnknownHarnessError extends Error {
+    name;
+    constructor(name) {
+        super(`Unknown harness: ${name}`);
+        this.name = name;
+        this.name = 'UnknownHarnessError';
+    }
+}
+export class HarnessRegistry {
+    adapters = new Map();
+    register(adapter) {
+        this.adapters.set(adapter.name, adapter);
+    }
+    get(name) {
+        const a = this.adapters.get(name);
+        if (!a)
+            throw new UnknownHarnessError(name);
+        return a;
+    }
+    has(name) {
+        return this.adapters.has(name);
+    }
+    list() {
+        return Array.from(this.adapters.keys());
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/harness/types.d.ts

@@ -0,0 +1,123 @@
+/**
+ * HarnessAdapter framework per RFC-0010 §13. Decouples the orchestrator from any single
+ * coding-agent runtime. Each adapter declares static capabilities + binary requirements;
+ * the orchestrator validates at pipeline-load and dispatches at runtime, with the
+ * fallback chain handling availability failures.
+ */
+export type HarnessName = 'claude-code' | 'codex' | 'gemini-cli' | 'opencode' | 'aider' | 'generic-api';
+export interface HarnessCapabilities {
+    /** Can spawn a clean session per invocation (no leaked context). */
+    freshContext: boolean;
+    /** Supports MCP tools / custom tool definitions. */
+    customTools: boolean;
+    /** Emits incremental output (for heartbeats). */
+    streaming: boolean;
+    /** Honors a per-invocation cwd. */
+    worktreeAwareCwd: boolean;
+    /** Supports loadable skills / system prompts. */
+    skills: boolean;
+    /** Can write files to $ARTIFACTS_DIR mid-stage. */
+    artifactWrites: boolean;
+    /** Largest context window across this harness's models. */
+    maxContextTokens: number;
+}
+export interface HarnessRequires {
+    /** Executable name resolved against PATH. */
+    binary: string;
+    /** semver range. Open-ended upper bound by default (RFC §13.8). */
+    versionRange: string;
+    /** Probe configuration: how to extract the installed version. */
+    versionProbe: {
+        args: string[];
+        parse: (stdout: string) => string;
+    };
+}
+export interface HarnessAvailability {
+    available: boolean;
+    reason?: 'binary-missing' | 'version-out-of-range' | 'probe-failed' | 'health-check-failed';
+    detail?: string;
+    installedVersion?: string;
+}
+export interface HarnessInput {
+    prompt: string;
+    /** Worktree path (cwd for the agent invocation). */
+    cwd: string;
+    /** Resolved physical model ID, not alias. */
+    model: string;
+    /** Allocated dev-server port (optional). */
+    port?: number;
+    /** $ARTIFACTS_DIR/<issue-id>/ for the run. */
+    artifactsDir: string;
+    /** Optional MCP tools / tool definitions. */
+    tools?: ToolDefinition[];
+    /** Optional skill names to load. */
+    skills?: string[];
+    /** ISO 8601 duration. */
+    timeout?: string;
+    /** Per-stage cost ceiling. */
+    maxBudgetUsd?: number;
+}
+export interface ToolDefinition {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+}
+export type HarnessResultStatus = 'success' | 'failure' | 'timeout' | 'budget-exceeded' | 'unavailable';
+export interface HarnessResult {
+    status: HarnessResultStatus;
+    exitCode: number;
+    costUsd: number;
+    inputTokens: number;
+    outputTokens: number;
+    /** Files the harness wrote to $ARTIFACTS_DIR. */
+    artifactPaths: string[];
+    /**
+     * Final assistant text response, when the stage produced one (read-only stages like
+     * triage/review return their verdict here; code-generation stages typically write to
+     * artifacts and leave this empty or set it to a brief summary).
+     */
+    outputText?: string;
+    errorDetail?: string;
+}
+export type HarnessEvent = {
+    type: 'started';
+    timestamp: string;
+} | {
+    type: 'heartbeat';
+    timestamp: string;
+    message?: string;
+} | {
+    type: 'progress';
+    timestamp: string;
+    tokensConsumed: number;
+} | {
+    type: 'completed';
+    timestamp: string;
+    status: HarnessResultStatus;
+};
+export interface HarnessAdapter {
+    readonly name: HarnessName;
+    readonly capabilities: HarnessCapabilities;
+    readonly requires: HarnessRequires;
+    /**
+     * Stable identifier for the credential / account in scope. Used as the SubscriptionLedger
+     * key per RFC §14.12. MUST be a one-way derivation (e.g., SHA-256 of the API key).
+     * Returns null when the harness cannot derive an account identity (e.g., generic-api
+     * with no auth scheme).
+     */
+    getAccountId(): Promise<string | null>;
+    /**
+     * Cheap liveness probe used at pipeline-load and by the fallback chain. Combines binary
+     * presence + version-range check + adapter-specific health. May be cached for the
+     * orchestrator's lifetime; operator restart picks up newly-installed binaries.
+     */
+    isAvailable(): Promise<HarnessAvailability>;
+    /**
+     * Execute one stage end-to-end. Streams progress via onEvent. Adapters MUST validate
+     * any schema-conformant artifact they produce per RFC §13.9.
+     */
+    invoke(input: HarnessInput, onEvent?: (e: HarnessEvent) => void): Promise<HarnessResult>;
+    /** List models the harness can drive (after env-var introspection). */
+    availableModels(): Promise<string[]>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/harness/types.js

@@ -0,0 +1,8 @@
+/**
+ * HarnessAdapter framework per RFC-0010 §13. Decouples the orchestrator from any single
+ * coding-agent runtime. Each adapter declares static capabilities + binary requirements;
+ * the orchestrator validates at pipeline-load and dispatches at runtime, with the
+ * fallback chain handling availability failures.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/harness/version-probe.d.ts

@@ -0,0 +1,14 @@
+import type { HarnessAvailability, HarnessRequires } from './types.js';
+/**
+ * Run a harness's version probe and compare against its declared semver range.
+ * Per RFC §13.8: parse failures fall through to "available" (warning only) so undocumented
+ * vendor changes to --version output don't break every pipeline.
+ */
+export declare function probeVersion(requires: HarnessRequires): Promise<HarnessAvailability>;
+/**
+ * Minimal semver-range matcher supporting `>=X.Y.Z` and `>=X.Y.Z <A.B.C`.
+ * v1 ships only the cases the RFC's default policy uses (open-ended upper bound by
+ * default; explicit upper bound only when a known-incompatible upstream version exists).
+ */
+export declare function matchesRange(version: string, range: string): boolean;
+//# sourceMappingURL=version-probe.d.ts.map