opencode-swarm 7.114.9 → 7.116.0

package/dist/evaluation/gate-stats.d.ts

@@ -0,0 +1,47 @@
+import type { GateName } from './contracts.js';
+export type GateModelStatistics = {
+    model: string;
+    gate: GateName;
+    total: number;
+    caught: number;
+    missed: number;
+    falseRejections: number;
+    negativeControls: number;
+    infrastructureFailures: number;
+    unsupported: number;
+    catchRate: number | null;
+    confidenceInterval: [number, number] | null;
+    falseRejectionRate: number | null;
+    falseRejectionConfidenceInterval: [number, number] | null;
+    insufficientData: boolean;
+    retries: {
+        total: number;
+        maximum: number;
+    };
+    cost: {
+        usd: number;
+        unavailable: number;
+    };
+};
+export type ReviewerTelemetryStatistics = {
+    parsed: number;
+    skipped: number;
+    genuine: number;
+    fallback: number;
+    dataQuality: number;
+    blocked: number;
+    fallbackToGenuineRatio: number | null;
+};
+export type GateStatisticsReport = {
+    runs: number;
+    corruptRuns: string[];
+    groundTruth: {
+        parsed: number;
+        malformed: number;
+        ambiguous: number;
+        unjoined: number;
+    };
+    models: GateModelStatistics[];
+    reviewerTelemetry: ReviewerTelemetryStatistics;
+};
+export declare function computeGateStatistics(directory: string, minSamples?: number, runId?: string): Promise<GateStatisticsReport>;

package/dist/evaluation/hashing.d.ts

@@ -0,0 +1,34 @@
+import { lstat, opendir, readFile, realpath } from 'node:fs/promises';
+import type { EvaluationCandidateV1, EvaluationRunV1, EvaluationTaskV1, GateAuditManifestV1, TaskSetSnapshotV1 } from './contracts.js';
+export declare function canonicalJson(value: unknown): string;
+export declare function sha256(value: string | Uint8Array): string;
+export declare function canonicalHash(value: unknown): string;
+export declare function contentHashWithout<T extends Record<string, unknown>>(value: T, keys: readonly (keyof T)[]): string;
+export declare function computeTaskContentHash(task: Omit<EvaluationTaskV1, 'contentHash'> | EvaluationTaskV1): string;
+export declare function computeCandidateInputContentHash(projectRoot: string, candidate: Omit<EvaluationCandidateV1, 'contentHash'> | EvaluationCandidateV1): Promise<string>;
+export interface TaskInputHashLimits {
+    /** Maximum aggregate filesystem entries (regular files plus directories). */
+    maxFiles?: number;
+    maxBytes?: number;
+}
+/** Hash task metadata plus the exact admitted instruction, fixture/container, and project scorer bytes. */
+export declare function computeTaskInputContentHash(projectRoot: string, task: Omit<EvaluationTaskV1, 'contentHash'> | EvaluationTaskV1, limits?: TaskInputHashLimits): Promise<string>;
+/**
+ * Hash the stable task input identity used for split isolation. Mutable catalog
+ * metadata is excluded so aliases cannot move identical inputs across splits.
+ * Derived tasks are linked to their admitted parent by the store instead.
+ */
+export declare function computeTaskLineageInputHash(projectRoot: string, task: Omit<EvaluationTaskV1, 'contentHash'> | EvaluationTaskV1, limits?: TaskInputHashLimits): Promise<string>;
+export declare function computeTaskSetContentHash(snapshot: Omit<TaskSetSnapshotV1, 'contentHash' | 'createdAt'> | TaskSetSnapshotV1): string;
+export declare function computeRunIntegrityHash(run: Omit<EvaluationRunV1, 'integrityHash'> | EvaluationRunV1): string;
+export declare function computeManifestContentHash(manifest: Omit<GateAuditManifestV1, 'contentHash'> | GateAuditManifestV1): string;
+/** Resolve an existing path and reject traversal plus symlink/junction/reparse components. */
+export declare function resolveContainedExistingPath(root: string, relativePath: string): string;
+/** Async containment equivalent for I/O-heavy evaluation hashing paths. */
+export declare function resolveContainedExistingPathAsync(root: string, relativePath: string): Promise<string>;
+export declare const _internals: {
+    lstat: typeof lstat;
+    opendir: typeof opendir;
+    readFile: typeof readFile;
+    realpath: typeof realpath;
+};

package/dist/evaluation/index.d.ts

@@ -0,0 +1,17 @@
+export * from './contracts.js';
+export type { DisposableWorktree, WorkingTreeFingerprint, } from './disposable-worktree.js';
+export { captureWorkingTreeFingerprint, createDisposableWorktree, removeDisposableWorktree, withDisposableWorktree, } from './disposable-worktree.js';
+export * from './fixtures.js';
+export * from './gate-audit.js';
+export * from './gate-ground-truth.js';
+export * from './gate-stats.js';
+export type { TaskInputHashLimits } from './hashing.js';
+export { canonicalHash, canonicalJson, computeCandidateInputContentHash, computeManifestContentHash, computeRunIntegrityHash, computeTaskContentHash, computeTaskInputContentHash, computeTaskLineageInputHash, computeTaskSetContentHash, contentHashWithout, resolveContainedExistingPath, sha256, } from './hashing.js';
+export type { EvaluationModelDispatcher, EvaluationModelDispatchRequest, EvaluationModelDispatchResult, } from './model-dispatcher.js';
+export { createEvaluationModelDispatcher, resolveEvaluationAgentName, } from './model-dispatcher.js';
+export * from './public-api.js';
+export * from './retention.js';
+export type { EvaluationExecutor, EvaluationExecutorResult, RunEvaluationOptions, } from './runner.js';
+export { createModelEvaluationExecutor, runEvaluation, } from './runner.js';
+export * from './statistics.js';
+export * from './store.js';

package/dist/evaluation/model-dispatcher.d.ts

@@ -0,0 +1,30 @@
+import type { Agent, OpencodeClient } from '@opencode-ai/sdk';
+import { log } from '../utils/logger.js';
+export type EvaluationModelDispatchRequest = {
+    directory: string;
+    agentName: string;
+    modelId: string;
+    prompt: string;
+    system?: string;
+    timeoutMs: number;
+    parentSessionId?: string;
+    preferredSwarm?: string;
+    abortSignal?: AbortSignal;
+};
+export type EvaluationModelDispatchResult = {
+    status: 'completed' | 'timeout' | 'cancelled' | 'error';
+    modelId: string;
+    agentName?: string;
+    text: string;
+    durationMs: number;
+    error?: string;
+};
+export type EvaluationModelDispatcher = (request: EvaluationModelDispatchRequest) => Promise<EvaluationModelDispatchResult>;
+export declare function resolveEvaluationAgentName(agents: readonly Pick<Agent, 'name'>[], logicalName: string, preferredSwarm?: string): string;
+declare function boundedDelete(client: OpencodeClient, sessionId: string, timeoutMs?: number): Promise<void>;
+export declare const _internals: {
+    boundedDelete: typeof boundedDelete;
+    log: typeof log;
+};
+export declare function createEvaluationModelDispatcher(client: OpencodeClient): EvaluationModelDispatcher;
+export {};

package/dist/evaluation/public-api.d.ts

@@ -0,0 +1,87 @@
+import type { EvaluationRunV1, PromotionDecisionV1, PromotionPolicyV1 } from './contracts.js';
+import { recordTestImpactGateGroundTruth } from './gate-ground-truth.js';
+import { computeCandidateInputContentHash, computeTaskInputContentHash } from './hashing.js';
+import { type RunEvaluationOptions, runEvaluation } from './runner.js';
+import { type DecidePromotionInput } from './statistics.js';
+export type EvaluateCandidateV1Options = RunEvaluationOptions & {
+    historicalBest?: EvaluationRunV1;
+    policy?: Partial<PromotionPolicyV1>;
+    decidedAt?: string;
+};
+export type EvaluateCandidateV1Result = {
+    run: EvaluationRunV1;
+    decision: PromotionDecisionV1;
+};
+/**
+ * Stable package-level evaluation boundary for SkillOpt/HarnessOpt consumers.
+ * It freezes and executes the run, decides against baseline and historical-best,
+ * and durably persists the immutable promotion decision before returning.
+ */
+export declare function evaluateCandidateV1(options: EvaluateCandidateV1Options): Promise<EvaluateCandidateV1Result>;
+/**
+ * Callable function namespace: OpenCode's legacy plugin loader permits named
+ * function exports but rejects plain-object named exports. The attached methods
+ * retain the cohesive versioned API without jeopardizing plugin discovery.
+ */
+export declare const evaluationV1: ((options: EvaluateCandidateV1Options) => Promise<EvaluateCandidateV1Result>) & {
+    evaluateCandidate: typeof evaluateCandidateV1;
+    runEvaluation: typeof runEvaluation;
+    decidePromotion: (input: DecidePromotionInput) => {
+        v: 1;
+        decisionId: string;
+        runId: string;
+        decidedAt: string;
+        status: "inconclusive" | "accept" | "reject";
+        reasons: string[];
+        baseline: {
+            baselineRunId: string;
+            baselineCandidateId: string;
+            baselineMean: number;
+            candidateMean: number;
+            pairedDelta: number;
+            confidenceInterval: [number, number];
+            validPairs: number;
+            missingPairs: number;
+            coverage: number;
+        };
+        historicalBest: {
+            baselineRunId: string;
+            baselineCandidateId: string;
+            baselineMean: number;
+            candidateMean: number;
+            pairedDelta: number;
+            confidenceInterval: [number, number];
+            validPairs: number;
+            missingPairs: number;
+            coverage: number;
+        };
+        deadband: number;
+        bootstrap: {
+            resamples: 10000;
+            confidence: 0.95;
+            seedHash: string;
+        };
+        categories: {
+            category: string;
+            protected: boolean;
+            tolerance: number;
+            baselineMean: number;
+            candidateMean: number;
+            pairedDelta: number;
+            regression: boolean;
+        }[];
+        lineage: {
+            baselineRunId: string;
+            historicalBestRunId: string;
+            taskSetHash: string;
+            baselineHash: string;
+            candidateHash: string;
+            historicalBestHash: string;
+        };
+        policyHash: string;
+        unavailableQualityMetrics: ("complexity_delta" | "public_api_delta")[];
+    };
+    hashTaskInput: typeof computeTaskInputContentHash;
+    hashCandidateInput: typeof computeCandidateInputContentHash;
+    recordTestImpactGroundTruth: typeof recordTestImpactGateGroundTruth;
+};

package/dist/evaluation/retention.d.ts

@@ -0,0 +1,56 @@
+export type EvaluationArtifactNamespace = 'evaluation-run' | 'gate-audit';
+export type EvaluationArtifactRef = {
+    namespace: EvaluationArtifactNamespace;
+    id: string;
+};
+export type EvaluationRetentionFailure = {
+    artifact: EvaluationArtifactRef;
+    error: string;
+};
+export type EvaluationRetentionResult = {
+    inventory: EvaluationArtifactRef[];
+    selected: EvaluationArtifactRef[];
+    archived: EvaluationArtifactRef[];
+    corrupt: EvaluationArtifactRef[];
+    protected: EvaluationArtifactRef[];
+    failed: EvaluationRetentionFailure[];
+};
+/** Compatibility shape retained for existing direct gate-audit callers. */
+export type GateAuditRetentionResult = {
+    selected: string[];
+    archived: string[];
+    corrupt: string[];
+    protected: string[];
+    failed: string[];
+};
+type Candidate = {
+    artifact: EvaluationArtifactRef;
+    createdAt: string;
+    target: string;
+    kind: 'file' | 'directory';
+};
+declare function protectedArtifacts(directory: string): Promise<Set<string>>;
+declare function removeCandidate(candidate: Candidate): Promise<void>;
+export declare const _retentionInternals: {
+    protectedArtifacts: typeof protectedArtifacts;
+    removeCandidate: typeof removeCandidate;
+};
+/**
+ * Apply one age/count policy to generic evaluation runs and gate-audit detail.
+ * Namespaced references prevent unrelated run IDs from protecting one another.
+ */
+export declare function archiveEvaluationArtifacts(args: {
+    directory: string;
+    maxAgeDays: number;
+    maxBundles?: number;
+    dryRun?: boolean;
+    now?: Date;
+}): Promise<EvaluationRetentionResult>;
+export declare function archiveGateAuditResults(args: {
+    directory: string;
+    maxAgeDays: number;
+    maxBundles?: number;
+    dryRun?: boolean;
+    now?: Date;
+}): Promise<GateAuditRetentionResult>;
+export {};

package/dist/evaluation/runner.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { runExternalTool } from '../utils/external-tool-runner.js';
+import type { CostRecord, EvaluationBudgetsV1Schema, EvaluationCandidateV1, EvaluationRunV1, EvaluationSplit, EvaluationTaskV1 } from './contracts.js';
+import { captureWorkingTreeFingerprint, type DisposableWorktree } from './disposable-worktree.js';
+import type { EvaluationModelDispatcher } from './model-dispatcher.js';
+type EvaluationBudgetsV1 = z.infer<typeof EvaluationBudgetsV1Schema>;
+export type EvaluationExecutorResult = {
+    status: 'completed' | 'timeout' | 'cancelled' | 'infrastructure_failure';
+    text: string;
+    durationMs: number;
+    cost: CostRecord;
+    error?: string;
+};
+export type EvaluationExecutor = (args: {
+    task: EvaluationTaskV1;
+    candidate: EvaluationCandidateV1;
+    isolatedRoot: string;
+    instruction: string;
+    payload: string;
+    seed: string;
+    abortSignal: AbortSignal;
+}) => Promise<EvaluationExecutorResult>;
+export type RunEvaluationOptions = {
+    projectRoot: string;
+    inputRoot?: string;
+    tasks: EvaluationTaskV1[];
+    baseline: EvaluationCandidateV1;
+    candidate: EvaluationCandidateV1;
+    split: EvaluationSplit;
+    seed: string;
+    models: string[];
+    budgets: EvaluationBudgetsV1;
+    executor: EvaluationExecutor;
+    abortSignal?: AbortSignal;
+};
+export declare function runEvaluation(options: RunEvaluationOptions): Promise<EvaluationRunV1>;
+export declare const _internals: {
+    captureWorkingTreeFingerprint: typeof captureWorkingTreeFingerprint;
+    runExternalTool: typeof runExternalTool;
+    withDisposableWorktree: <T>(args: {
+        projectRoot: string;
+        baseRef: string;
+        abortSignal?: AbortSignal;
+        run: (worktree: DisposableWorktree) => Promise<T>;
+    }) => Promise<T>;
+};
+export declare function createModelEvaluationExecutor(dispatcher: EvaluationModelDispatcher, parentSessionId?: string): EvaluationExecutor;
+export {};

package/dist/evaluation/statistics.d.ts

@@ -0,0 +1,9 @@
+import { type EvaluationRunV1, type PromotionDecisionV1, type PromotionPolicyV1 } from './contracts.js';
+export interface DecidePromotionInput {
+    run: EvaluationRunV1;
+    historicalBest?: EvaluationRunV1;
+    policy?: Partial<PromotionPolicyV1>;
+    decidedAt?: string;
+}
+export declare function pairedBootstrapConfidenceInterval(deltas: readonly number[], seedHash: string, resamples?: number): [number, number];
+export declare function decidePromotion(input: DecidePromotionInput): PromotionDecisionV1;

package/dist/evaluation/store.d.ts

@@ -0,0 +1,26 @@
+import { type EvaluationRunV1, type EvaluationTaskV1, type GateAuditManifestV1, type GateAuditResultV1, type PromotionDecisionV1, type TaskSetSnapshotV1, type TestConsumptionClaimV1 } from './contracts.js';
+export declare class EvaluationConflictError extends Error {
+    constructor(message: string);
+}
+export declare class TestAlreadyConsumedError extends Error {
+    readonly priorClaim: TestConsumptionClaimV1;
+    constructor(priorClaim: TestConsumptionClaimV1);
+}
+export declare function admitEvaluationTask(directory: string, input: EvaluationTaskV1, inputRoot?: string): Promise<EvaluationTaskV1>;
+export declare function saveTaskSetSnapshot(directory: string, input: TaskSetSnapshotV1, inputRoot?: string): Promise<TaskSetSnapshotV1>;
+export declare function saveEvaluationRun(directory: string, input: EvaluationRunV1): Promise<EvaluationRunV1>;
+export declare function readEvaluationRun(directory: string, runId: string): Promise<EvaluationRunV1 | undefined>;
+export declare function savePromotionDecision(directory: string, input: PromotionDecisionV1): Promise<PromotionDecisionV1>;
+export declare function saveGateAuditResult(directory: string, input: GateAuditResultV1): Promise<GateAuditResultV1>;
+export declare function saveGateAuditManifest(directory: string, input: GateAuditManifestV1): Promise<GateAuditManifestV1>;
+export declare function readGateAuditManifest(directory: string, runId: string): Promise<GateAuditManifestV1 | undefined>;
+export declare function readGateAuditResult(directory: string, runId: string): Promise<GateAuditResultV1 | undefined>;
+export type GateAuditReadSummary = {
+    results: GateAuditResultV1[];
+    corruptRunIds: string[];
+};
+/** Enumerate only validated immediate gate-audit children; never recurse. */
+export declare function listGateAuditResults(directory: string): Promise<GateAuditReadSummary>;
+export declare function claimHeldOutTest(directory: string, input: TestConsumptionClaimV1): Promise<TestConsumptionClaimV1>;
+/** Run ids that retention must preserve to keep promotion and test lineage valid. */
+export declare function getProtectedEvaluationRunIds(directory: string): Promise<Set<string>>;

package/dist/evidence/manager.d.ts

@@ -1,4 +1,5 @@
 import { type BuildEvidence, type Evidence, type EvidenceBundle, type PlaceholderEvidence, type QualityBudgetEvidence, type SastEvidence, type SbomEvidence, type SecretscanEvidence, type SyntaxEvidence } from '../config/evidence-schema';
+import { type EvaluationRetentionResult } from '../evaluation/retention.js';
 /**
  * Discriminated union returned by loadEvidence.
  * - 'found': file exists and passed Zod schema validation
@@ -92,7 +93,22 @@ export declare function checkRequirementCoverage(phase: number, directory: strin
  * If maxBundles is provided, enforces a maximum bundle count by deleting oldest first.
  * Returns array of archived (deleted) task IDs.
  */
+export type EvidenceArchiveReport = {
+    inventoryEvidence: string[];
+    selectedEvidence: string[];
+    selectedEvidenceByAge: string[];
+    selectedEvidenceByCount: string[];
+    archivedEvidence: string[];
+    failedEvidence: string[];
+    evaluation: EvaluationRetentionResult;
+};
+export type EvidenceArchiveReportOptions = {
+    report: true;
+    dryRun?: boolean;
+    now?: Date;
+};
 export declare function archiveEvidence(directory: string, maxAgeDays: number, maxBundles?: number): Promise<string[]>;
+export declare function archiveEvidence(directory: string, maxAgeDays: number, maxBundles: number | undefined, options: EvidenceArchiveReportOptions): Promise<EvidenceArchiveReport>;
 /**
  * Validates evidence through Zod. Exposed via _internals for DI testing.
  */
@@ -108,5 +124,7 @@ export declare const _internals: {
     validateProjectRoot: typeof validateProjectRoot;
     validateEvidence: typeof validateEvidence;
     saveEvidence: typeof saveEvidence;
+    deleteEvidence: typeof deleteEvidence;
+    now: () => Date;
 };
 export {};

package/dist/index.d.ts

@@ -13,3 +13,7 @@ declare const _default: {
 export default _default;
 export type { AgentDefinition } from './agents';
 export type { AgentName, AutomationCapabilities, AutomationConfig, AutomationMode, PipelineAgentName, PluginConfig, QAAgentName, } from './config';
+export { loadTier1EvaluationTasks } from './evaluation/fixtures.js';
+export { recordTestImpactGateGroundTruth } from './evaluation/gate-ground-truth.js';
+export type { EvaluateCandidateV1Options, EvaluateCandidateV1Result, } from './evaluation/public-api.js';
+export { evaluateCandidateV1, evaluationV1, } from './evaluation/public-api.js';