opencode-swarm 7.154.3 → 7.156.0

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/hooks/repo-graph-injection.d.ts

@@ -16,25 +16,65 @@
  * bounded workspace probe gates use of the graph. Uncertified graphs and
  * complete drift above the configured refresh cap are suppressed;
  * inconclusive probes remain usable as freshness-unknown, without mutation.
+ *
+ * Storage modes (issue #1534): when `options.storage === 'indexed'`, the two
+ * FILE-SCOPED block builders may, on a full-graph LRU miss, serve a bounded
+ * subgraph read from `.swarm/repo-memory.sqlite` instead of parsing the whole
+ * JSON document. The kill switch, the stat gate and the freshness probe all
+ * run first and are unchanged, and the LRU hit — the common case — never
+ * touches SQLite. Whole-graph consumers (`buildLaneOrientationBlock`,
+ * `semantic-diff-injection`) always get the full JSON graph.
  */
 import { loadPluginConfigWithMetaAsync } from '../config/loader';
 import { type FreshnessOptions, probeFreshness, type RepoGraph } from '../tools/repo-graph';
+import { loadSubgraphForFiles } from '../tools/repo-graph/indexed-storage';
 export interface RepoGraphInjectionOptions extends FreshnessOptions {
     enabled?: boolean;
     refreshCap?: number;
+    /**
+     * Resolved `repo_graph.storage` mode (issue #1534). Passed in by the caller
+     * — this module deliberately never reads config synchronously (see the
+     * `loadPluginConfigWithMetaAsync` note on `_internals`), so the mode rides
+     * in beside `enabled` / `refreshCap`. Anything other than `'indexed'`
+     * (including `undefined`) keeps every path on the JSON document.
+     */
+    storage?: 'json' | 'indexed';
 }
 export declare const _internals: {
     probeFreshness: typeof probeFreshness;
     cacheSize: () => number;
+    subgraphCacheSize: () => number;
     renderLaneOrientationBlock: typeof renderLaneOrientationBlock;
     orientationFreshnessLine: typeof orientationFreshnessLine;
     loadPluginConfigWithMetaAsync: typeof loadPluginConfigWithMetaAsync;
+    loadSubgraphForFiles: typeof loadSubgraphForFiles;
+    subgraphCacheKey: typeof subgraphCacheKey;
 };
+/**
+ * Cache key for a subgraph request. The graph artifact's `{mtimeMs, size, ino}`
+ * is part of the key, so a graph change invalidates every cached subgraph for
+ * that directory without an explicit sweep — the identical invalidation
+ * contract the full-graph LRU uses. Files are sorted because the closure is a
+ * set union and is order-independent; the caller's own array order (which does
+ * drive `BlastRadiusResult.target` and the rendered target list) is never read
+ * from this key. NUL is the separator because it is the one character that
+ * cannot appear in a path component, so no two distinct requests can collide
+ * by concatenation.
+ */
+declare function subgraphCacheKey(directoryKey: string, stat: {
+    mtimeMs: number;
+    size: number;
+    ino: number;
+}, files: readonly string[], depth: number): string;
 /**
  * Load the repo graph for `directory`, using a bounded per-directory cache that
  * invalidates on file mtime/size change and a shared content-freshness gate.
  * Returns null if no graph exists or its workspace alignment is unsafe.
  *
+ * Always returns the WHOLE graph — `semantic-diff-injection` and
+ * `buildLaneOrientationBlock` are whole-graph consumers and must never receive
+ * a bounded subgraph.
+ *
  * Exported only for tests; production callers use the buildXxxBlock helpers below.
  */
 export declare function getCachedGraph(directory: string, options?: RepoGraphInjectionOptions): Promise<RepoGraph | null>;

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';