opencode-swarm 7.155.0 → 7.156.0

package/dist/harness/factory.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { type HarnessBlueprintV1, type HarnessConstraintsV1, type ToolSpecV1 } from './contracts.js';
+import { loadHarnessPromptArtifact } from './store.js';
+declare const RuntimeAgentDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    config: z.ZodObject<{
+        mode: z.ZodEnum<{
+            primary: "primary";
+            subagent: "subagent";
+        }>;
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        reasoning: z.ZodOptional<z.ZodObject<{
+            effort: z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                max: "max";
+                xhigh: "xhigh";
+                minimal: "minimal";
+                ultra: "ultra";
+            }>;
+        }, z.core.$strict>>;
+        thinking: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                enabled: "enabled";
+                disabled: "disabled";
+            }>;
+            budget_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        temperature: z.ZodNumber;
+        prompt: z.ZodString;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    }, z.core.$strict>;
+    harnessPromptProvenance: z.ZodOptional<z.ZodObject<{
+        source: z.ZodEnum<{
+            candidate: "candidate";
+            static: "static";
+        }>;
+        promptId: z.ZodString;
+        sha256: z.ZodString;
+        candidateId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RuntimeAgentDefinition = z.infer<typeof RuntimeAgentDefinitionSchema>;
+export declare function computeRuntimeDefinitionsHash(runtimeDefinitions: readonly RuntimeAgentDefinition[]): string;
+export declare function createToolFactory(registeredToolIds: readonly string[]): {
+    projectTools(toolIds: readonly string[]): ToolSpecV1[];
+    materializeTools(tools: readonly ToolSpecV1[]): string[];
+};
+export declare function createAgentFactory(options: {
+    runtimeDefinitions: readonly RuntimeAgentDefinition[];
+    registeredToolIds: readonly string[];
+    defaultConstraints?: HarnessConstraintsV1;
+}): {
+    definitionsHash: string;
+    projectBlueprint(args: {
+        blueprintId: string;
+        agentNames?: readonly string[];
+        defaultAgent?: string;
+        constraints?: HarnessConstraintsV1;
+    }): HarnessBlueprintV1;
+    materializeBlueprint(blueprint: HarnessBlueprintV1, options?: {
+        directory?: string;
+    }): RuntimeAgentDefinition[];
+};
+export declare const _factoryInternals: {
+    loadHarnessPromptArtifact: typeof loadHarnessPromptArtifact;
+};
+export {};

package/dist/harness/hash.d.ts

@@ -0,0 +1,4 @@
+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;

package/dist/harness/index.d.ts

@@ -0,0 +1,6 @@
+export * from './contracts.js';
+export * from './factory.js';
+export * from './hash.js';
+export * from './patch.js';
+export * from './source-candidate.js';
+export * from './store.js';

package/dist/harness/patch.d.ts

@@ -0,0 +1,3 @@
+import { type BlueprintPatchOperationV1, type HarnessBlueprintV1 } from './contracts.js';
+export declare function deriveBlueprintPatchRiskTier(operations: readonly BlueprintPatchOperationV1[]): 'low' | 'medium' | 'high';
+export declare function applyBlueprintPatch(base: HarnessBlueprintV1, patch: unknown): HarnessBlueprintV1;

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

@@ -0,0 +1,105 @@
+import type { AgentDefinition } from '../agents/index.js';
+import { type HarnessBlueprintV1, parseHarnessBlueprint } from './contracts.js';
+import { applyBlueprintPatch } from './patch.js';
+import { validateSourceCandidate } from './source-candidate.js';
+import { activateHarnessCandidate, auditHarnessLedger, listHarnessHistory, loadHarnessCurrent, recordHarnessCandidate, recoverHarnessCorruptTail, rollbackHarnessVersion, saveHarnessVersion } from './store.js';
+declare function projectStaticBlueprint(agents: Record<string, AgentDefinition>): {
+    v: 1;
+    blueprintId: string;
+    definitionsHash: string;
+    tools: {
+        v: 1;
+        toolId: string;
+        description?: string | undefined;
+    }[];
+    agents: {
+        v: 1;
+        agentName: string;
+        mode: "primary" | "subagent";
+        temperature: number;
+        prompt: {
+            v: 1;
+            promptId: string;
+            ref: string;
+            sha256: string;
+        };
+        tools: string[];
+        description?: string | undefined;
+        model?: string | undefined;
+        variant?: string | undefined;
+        reasoning?: {
+            effort: "none" | "low" | "medium" | "high" | "max" | "xhigh" | "minimal" | "ultra";
+        } | undefined;
+        thinking?: {
+            type: "enabled" | "disabled";
+            budget_tokens?: number | undefined;
+        } | undefined;
+        disabledTools?: string[] | undefined;
+    }[];
+    orchestration: {
+        v: 1;
+        defaultAgent: string;
+        activation: "manual";
+        execution: "disabled";
+        multiSwarm: boolean;
+    };
+    constraints: {
+        v: 1;
+        sourceAllowlist: string[];
+        extraProtectedPaths: string[];
+        maxPatchBytes: number;
+        maxFiles: number;
+        maxFileBytes: number;
+        maxTotalBytes: number;
+        maxChangedLines: number;
+        maxVersions: number;
+        maxReplayRecords: number;
+        maxOutputBytes: number;
+    };
+    contentHash: string;
+};
+declare function diffHarnessBlueprints(left: HarnessBlueprintV1, right: HarnessBlueprintV1): {
+    changes: Record<string, {
+        before: unknown;
+        after: unknown;
+    }>;
+    summary: {
+        changeCount: number;
+        changedKeys: string[];
+    };
+};
+/**
+ * Callable package namespace for explicit HarnessOpt consumers. Importing it is
+ * pure; no filesystem, Git, agent, or activation work occurs until a method is
+ * invoked. The live plugin manifest never calls this function during init.
+ */
+export declare const harnessMutationV1: (() => /*elided*/ any & {
+    validateBlueprint: typeof parseHarnessBlueprint;
+    projectStaticBlueprint: typeof projectStaticBlueprint;
+    applyPatchSet: typeof applyBlueprintPatch;
+    validateSourceCandidate: typeof validateSourceCandidate;
+    saveCandidate: typeof recordHarnessCandidate;
+    saveVersion: typeof saveHarnessVersion;
+    activate: typeof activateHarnessCandidate;
+    rollback: typeof rollbackHarnessVersion;
+    current: typeof loadHarnessCurrent;
+    history: typeof listHarnessHistory;
+    diff: typeof diffHarnessBlueprints;
+    auditLedger: typeof auditHarnessLedger;
+    recoverCorruptTail: typeof recoverHarnessCorruptTail;
+}) & {
+    validateBlueprint: typeof parseHarnessBlueprint;
+    projectStaticBlueprint: typeof projectStaticBlueprint;
+    applyPatchSet: typeof applyBlueprintPatch;
+    validateSourceCandidate: typeof validateSourceCandidate;
+    saveCandidate: typeof recordHarnessCandidate;
+    saveVersion: typeof saveHarnessVersion;
+    activate: typeof activateHarnessCandidate;
+    rollback: typeof rollbackHarnessVersion;
+    current: typeof loadHarnessCurrent;
+    history: typeof listHarnessHistory;
+    diff: typeof diffHarnessBlueprints;
+    auditLedger: typeof auditHarnessLedger;
+    recoverCorruptTail: typeof recoverHarnessCorruptTail;
+};
+export {};

package/dist/harness/source-candidate.d.ts

@@ -0,0 +1,45 @@
+import { lstatSync } from 'node:fs';
+import type { HarnessEvolutionConfig } from '../config/schema.js';
+import { type HarnessCandidateFileV1, type HarnessCandidateManifestV1 } from './contracts.js';
+export type HarnessSourceCandidateFileV1 = HarnessCandidateFileV1;
+export type HarnessSourceCandidateV1 = HarnessCandidateManifestV1 & {
+    /** Inert evidence only. No production API applies this patch. */
+    patch?: string;
+};
+type ValidationFailureCode = 'ALLOWLIST_EMPTY' | 'INVALID_BASE_SHA' | 'STALE_BASE' | 'PATCH_TOO_LARGE' | 'UNSUPPORTED_PATCH' | 'PATH_REJECTED' | 'PATH_NOT_ALLOWLISTED' | 'PROTECTED_PATH' | 'GIT_FAILED' | 'UNTRACKED_PATH' | 'UNSUPPORTED_TRACKED_MODE' | 'SYMLINK_PATH' | 'HARDLINK_PATH' | 'BINARY_FILE' | 'FILE_TOO_LARGE' | 'TOTAL_TOO_LARGE' | 'FILE_COUNT_EXCEEDED' | 'LINE_COUNT_EXCEEDED' | 'PATH_CHANGED_DURING_VALIDATION' | 'PATCH_DOES_NOT_APPLY';
+export type SourceCandidateValidationResult = {
+    ok: true;
+    candidate: HarnessSourceCandidateV1;
+} | {
+    ok: false;
+    code: ValidationFailureCode;
+    reason: string;
+};
+interface GitCommandResult {
+    ok: boolean;
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+interface GitBinaryCommandResult {
+    ok: boolean;
+    code: number;
+    stdout: Uint8Array;
+    stderr: string;
+}
+export declare function validateSourceCandidate(args: {
+    directory: string;
+    config: HarnessEvolutionConfig;
+    candidateId: string;
+    baseSha: string;
+    origin: string;
+    patch: string;
+}): Promise<SourceCandidateValidationResult>;
+declare function runGitCommand(directory: string, args: string[]): Promise<GitCommandResult>;
+declare function runGitBinaryCommand(directory: string, args: string[], maxOutputBytes?: number): Promise<GitBinaryCommandResult>;
+export declare const _internals: {
+    runGitCommand: typeof runGitCommand;
+    runGitBinaryCommand: typeof runGitBinaryCommand;
+    lstatSync: typeof lstatSync;
+};
+export {};

package/dist/harness/store.d.ts

@@ -0,0 +1,256 @@
+import { type WriteApprovalRequest } from '../security/write-authority.js';
+import { type BlueprintPatchV1, type HarnessBlueprintV1, type PromptArtifactV1 } from './contracts.js';
+import type { HarnessSourceCandidateV1 } from './source-candidate.js';
+type RetainedCandidateBinding = {
+    candidateId: string;
+    manifestHash: string;
+};
+export interface StoredHarnessCandidateV1 {
+    v: 1;
+    candidate: HarnessSourceCandidateV1;
+    promptArtifacts?: PromptArtifactV1[];
+    baseBlueprint?: HarnessBlueprintV1;
+    targetBlueprint?: HarnessBlueprintV1;
+    blueprintPatch?: BlueprintPatchV1;
+    recordedAt: string;
+}
+export interface HarnessVersionV1 {
+    v: 1;
+    versionId: string;
+    candidateId: string;
+    manifestHash: string;
+    allowedPathDigest: string;
+    generation: number;
+    sourceKind: 'activation' | 'rollback';
+    parentVersionId: string | null;
+    restoredFromVersionId: string | null;
+    approvalFactId: string;
+    blueprint?: HarnessBlueprintV1;
+    recordedAt: string;
+}
+export interface HarnessCurrentProjectionV1 {
+    v: 1;
+    currentVersionId: string | null;
+    currentCandidateId: string | null;
+    currentManifestHash: string | null;
+    currentHash: string;
+    generation: number;
+    versionIds: string[];
+    updatedAt: string;
+    ledgerHeadSegment: string | null;
+    ledgerHeadSeq: number;
+    ledgerHeadHash: string;
+}
+export interface HarnessLedgerRecordV1 {
+    v: 1;
+    seq: number;
+    timestamp: string;
+    kind: 'candidate_recorded' | 'activated' | 'rolled_back' | 'recovered_tail' | 'compacted';
+    candidateId: string;
+    versionId: string | null;
+    parentVersionId: string | null;
+    restoredFromVersionId: string | null;
+    approvalFactId: string | null;
+    payloadHash: string;
+    generation: number;
+    currentHashBefore: string;
+    currentHashAfter: string;
+    nextCurrentVersionId: string | null;
+    nextCurrentCandidateId: string | null;
+    nextCurrentManifestHash: string | null;
+    nextVersionIds: string[];
+    nextUpdatedAt: string;
+    ledgerSegment: string;
+    prunedVersionIds: string[];
+    recoverySegment: string | null;
+    recoveredBytes: number | null;
+    retainedCandidates: RetainedCandidateBinding[];
+    compactedRecords: number | null;
+    hashBefore: string;
+    hashAfter: string;
+}
+export type RecordHarnessCandidateResult = {
+    status: 'recorded';
+    candidate: StoredHarnessCandidateV1;
+    retentionReconciled: boolean;
+    retentionFailures: string[];
+} | {
+    status: 'conflict';
+    reason: string;
+};
+export type ActivateHarnessCandidateResult = {
+    status: 'activated';
+    version: HarnessVersionV1;
+    current: HarnessCurrentProjectionV1;
+    projectionReconciled: boolean;
+    prunedArtifactsReconciled: boolean;
+    prunedArtifactFailures: string[];
+    retentionReconciled: boolean;
+    retentionFailures: string[];
+} | {
+    status: 'candidate_not_found';
+    reason: string;
+} | {
+    status: 'candidate_not_activatable';
+    reason: string;
+} | {
+    status: 'consumer_mismatch';
+    reason: string;
+} | {
+    status: 'approval_required';
+    reason: string;
+} | {
+    status: 'retention_conflict';
+    reason: string;
+    maxVersions: number;
+    requiredVersionIds: string[];
+} | {
+    status: 'stale_current';
+    reason: string;
+};
+export type RollbackHarnessVersionResult = {
+    status: 'rolled_back';
+    version: HarnessVersionV1;
+    current: HarnessCurrentProjectionV1;
+    projectionReconciled: boolean;
+    prunedArtifactsReconciled: boolean;
+    prunedArtifactFailures: string[];
+    retentionReconciled: boolean;
+    retentionFailures: string[];
+} | {
+    status: 'version_not_found';
+    reason: string;
+} | {
+    status: 'consumer_mismatch';
+    reason: string;
+} | {
+    status: 'approval_required';
+    reason: string;
+} | {
+    status: 'retention_conflict';
+    reason: string;
+    maxVersions: number;
+    requiredVersionIds: string[];
+} | {
+    status: 'stale_current';
+    reason: string;
+};
+export type SaveHarnessVersionResult = {
+    status: 'saved';
+    version: HarnessVersionV1;
+} | {
+    status: 'conflict';
+    reason: string;
+};
+export interface HarnessHistoryResult {
+    records: HarnessLedgerRecordV1[];
+    truncated: boolean;
+    quarantinePath: string | null;
+    totalRecordCount: number;
+    limit: number;
+    totalSegments: number;
+}
+export type HarnessLedgerAuditResult = {
+    outcome: 'ok';
+    records: HarnessLedgerRecordV1[];
+    truncated: boolean;
+    quarantinePath: string | null;
+    totalSegments: number;
+} | {
+    outcome: 'scope_exceeded';
+    maxSegments: number;
+    totalSegments: number;
+    replayBoundExceeded?: true;
+    maxReplayRecords?: number;
+};
+export declare class HarnessStoreIntegrityError extends Error {
+    readonly artifactPath: string;
+    readonly code = "HARNESS_STORE_INTEGRITY";
+    constructor(artifactPath: string, message: string);
+}
+export declare class HarnessReplayBoundExceededError extends Error {
+    readonly maxReplayRecords: number;
+    readonly code = "HARNESS_REPLAY_BOUND_EXCEEDED";
+    constructor(maxReplayRecords: number);
+}
+declare function appendLedgerLine(directory: string, line: string, expectedSegmentName?: string): void;
+declare function removeVersionArtifact(filePath: string): void;
+declare function writeCurrentProjection(directory: string, current: HarnessCurrentProjectionV1): Promise<void>;
+declare function removeCandidateArtifact(directory: string): void;
+declare function removeLedgerArtifact(target: string): void;
+export declare function buildHarnessActivationApprovalRequest(args: {
+    targetSessionId: string;
+    candidate: StoredHarnessCandidateV1;
+    expectedCurrentHash: string | null;
+    expectedCurrentGeneration: number;
+    targetContentHash: string;
+    allowedPathDigest: string;
+}): WriteApprovalRequest;
+export declare function buildHarnessRollbackApprovalRequest(args: {
+    targetSessionId: string;
+    currentVersionId: string;
+    targetVersionId: string;
+    expectedCurrentHash: string;
+    expectedCurrentGeneration: number;
+    targetContentHash: string;
+    allowedPathDigest: string;
+}): WriteApprovalRequest;
+export declare function recordHarnessCandidate(args: {
+    directory: string;
+    candidate: StoredHarnessCandidateV1;
+    maxReplayRecords?: number;
+    maxInactiveCandidates?: number;
+}): Promise<RecordHarnessCandidateResult>;
+export declare function saveHarnessVersion(args: {
+    directory: string;
+    version: HarnessVersionV1;
+}): Promise<SaveHarnessVersionResult>;
+export declare function loadHarnessCurrent(directory: string, maxReplayRecords?: number): Promise<HarnessCurrentProjectionV1>;
+/** Explicitly reconcile the derived projection; read paths never mutate state. */
+export declare function reconcileHarnessCurrent(directory: string, maxReplayRecords?: number): Promise<HarnessCurrentProjectionV1>;
+export declare function loadHarnessCandidate(directory: string, candidateId: string, maxReplayRecords?: number): Promise<StoredHarnessCandidateV1 | null>;
+export declare function loadHarnessPromptArtifact(directory: string, candidateId: string, promptHash: string): PromptArtifactV1 | null;
+export declare function loadHarnessVersion(directory: string, versionId: string): Promise<HarnessVersionV1 | null>;
+export declare function listHarnessHistory(directory: string, options?: number | {
+    maxReplayRecords?: number;
+    limit?: number;
+}): Promise<HarnessHistoryResult>;
+export declare function auditHarnessLedger(directory: string, options: {
+    maxReplayRecords?: number;
+    maxSegments: number;
+}): Promise<HarnessLedgerAuditResult>;
+export declare function recoverHarnessCorruptTail(directory: string, maxReplayRecords?: number): Promise<HarnessHistoryResult>;
+export declare function activateHarnessCandidate(args: {
+    directory: string;
+    candidateId: string;
+    consumerSessionId: string;
+    targetSessionId?: string;
+    expectedCurrentHash: string | null;
+    expectedCurrentGeneration: number;
+    targetContentHash: string;
+    allowedPathDigest: string;
+    maxVersions?: number;
+    maxReplayRecords?: number;
+    maxInactiveCandidates?: number;
+}): Promise<ActivateHarnessCandidateResult>;
+export declare function rollbackHarnessVersion(args: {
+    directory: string;
+    targetVersionId: string;
+    consumerSessionId: string;
+    targetSessionId?: string;
+    expectedCurrentHash: string;
+    expectedCurrentGeneration: number;
+    targetContentHash: string;
+    allowedPathDigest: string;
+    maxVersions?: number;
+    maxReplayRecords?: number;
+    maxInactiveCandidates?: number;
+}): Promise<RollbackHarnessVersionResult>;
+export declare const _storeInternals: {
+    appendLedgerLine: typeof appendLedgerLine;
+    writeCurrentProjection: typeof writeCurrentProjection;
+    removeVersionArtifact: typeof removeVersionArtifact;
+    removeCandidateArtifact: typeof removeCandidateArtifact;
+    removeLedgerArtifact: typeof removeLedgerArtifact;
+};
+export {};

package/dist/index.d.ts

@@ -63,3 +63,5 @@ export type { EvaluatePrReviewRecoveryV1Options } from './evaluation/pr-review-r
 export { evaluatePrReviewRecoveryV1 } from './evaluation/pr-review-recovery.js';
 export type { EvaluateCandidateV1Options, EvaluateCandidateV1Result, } from './evaluation/public-api.js';
 export { evaluateCandidateV1, evaluationV1, } from './evaluation/public-api.js';
+export type { AgentBlueprintV1, BlueprintPatchV1, HarnessBlueprintV1, HarnessCandidateManifestV1, OrchestrationSpecV1, PromptArtifactV1, ToolSpecV1, } from './harness/contracts.js';
+export { harnessMutationV1 } from './harness/public-api.js';