opencode-swarm 7.123.0 → 7.125.0

package/dist/hooks/pr-workflow-gate.d.ts

@@ -0,0 +1,211 @@
+import { resolveCommitCountSince, resolveCurrentGitHead, resolveCurrentUpstreamPushTarget, resolveCurrentUpstreamRemoteRef, resolveExactRemoteBranchHead, resolveIsExactSingleChildCommit, resolveIsWorkingTreeClean, resolvePrWorkflowRevisionDigest, resolveRemoteRefsContainingHead } from '../background/workspace-snapshot.js';
+export declare const PR_REVIEW_BASE_DIMENSION_IDS: readonly ["intent-architecture", "correctness-state", "tests-falsifiability", "security-trust", "reliability-performance", "compatibility-delivery"];
+export declare const PR_REVIEW_REQUIRED_MICRO_LANE_IDS: readonly ["auth-identity-secrets", "untrusted-input-boundaries", "subprocess-platform", "concurrency-state", "dependencies-build-release", "api-schema-migrations", "test-infrastructure", "ui-accessibility-i18n", "privacy-observability", "generated-provenance", "unclassified-risk"];
+export type PrReviewBaseDimensionId = (typeof PR_REVIEW_BASE_DIMENSION_IDS)[number];
+export type PrWorkflowMode = 'PR_REVIEW' | 'PR_FEEDBACK';
+export interface PrWorkflowLaneSpec {
+    laneId?: string;
+    workflowLane?: string;
+    reviewItemIds?: string[];
+}
+export interface PrFeedbackLaneOwnership {
+    laneId: string;
+    ownedItemIds: string[];
+}
+interface PrReviewBaseDispatchRecord {
+    batchId: string;
+    lanes: Array<{
+        laneId: string;
+        workflowLane: PrReviewBaseDimensionId;
+    }>;
+    validatedAt: string;
+}
+interface PrFeedbackVerificationRecord {
+    batchId: string;
+    ownership: PrFeedbackLaneOwnership[];
+    validatedAt: string;
+}
+export type PrFeedbackGatePhase = 'stage-b-reviewer' | 'stage-b-test' | 'closeout-reviewer' | 'closeout-critic';
+export type PrFeedbackStageACategory = 'build' | 'typecheck' | 'lint' | 'diff-check' | 'reproduction';
+export interface PrFeedbackStageACheckReceipt {
+    category: PrFeedbackStageACategory;
+    workingDirectory?: string;
+    obligationId?: string;
+    validatorContract?: {
+        path: string;
+        id: string;
+    };
+    command: string[];
+    targets?: string[];
+    feedbackTargets?: Array<{
+        feedbackItemId: string;
+        target: string;
+        expectedBehavior: string;
+    }>;
+    durationMs: number;
+}
+interface PrFeedbackStageARecord {
+    revisionDigest: string;
+    checks: PrFeedbackStageACheckReceipt[];
+    feedbackItemIds?: string[];
+    applicableCategories?: Array<'build' | 'typecheck' | 'lint'>;
+    applicableObligations?: Array<{
+        id: string;
+        category: 'build' | 'typecheck' | 'lint';
+        workingDirectory: string;
+        source: string;
+        validatorContract?: {
+            path: string;
+            id: string;
+        };
+    }>;
+    validatedAt: string;
+}
+interface PrFeedbackGateBatchRecord {
+    batchId: string;
+    phase: PrFeedbackGatePhase;
+    laneId: string;
+    itemIds: string[];
+    revisionDigest: string;
+    validatedAt: string;
+}
+interface PrFeedbackReadyToPublishRecord {
+    revisionDigest: string;
+    localHead: string;
+    remoteName: string;
+    remoteBranchRef: string;
+    remoteRef: string;
+    validatedAt: string;
+}
+export type PrWorkflowCompletionStatus = 'completed' | 'ready-to-publish';
+export type PrReviewValidationPhase = 'council' | 'reviewer' | 'critic';
+interface PrReviewValidationBatchRecord {
+    batchId: string;
+    phase: PrReviewValidationPhase;
+    lanes: Array<{
+        laneId: string;
+        workflowLane: string;
+        reviewItemIds?: string[];
+    }>;
+    validatedAt: string;
+}
+export interface PrWorkflowGateState {
+    schemaVersion: 1;
+    /** Monotonic durable revision used to reject stale same-session transitions. */
+    revision: number;
+    sessionID: string;
+    mode: PrWorkflowMode;
+    activatedAt: string;
+    updatedAt: string;
+    prHeadSha?: string;
+    prReviewBaseRef?: string;
+    prReviewBaseSha?: string;
+    prReviewBaseDispatches?: PrReviewBaseDispatchRecord[];
+    /** @deprecated Compatibility projection of the most recent base dispatch. */
+    prReviewBaseDispatch?: PrReviewBaseDispatchRecord;
+    prReviewTriggerEvalPath?: string;
+    prReviewValidationBatches?: PrReviewValidationBatchRecord[];
+    prFeedbackInventory?: string[];
+    prFeedbackVerifications?: PrFeedbackVerificationRecord[];
+    /** @deprecated Compatibility projection of the most recent verification dispatch. */
+    prFeedbackVerification?: PrFeedbackVerificationRecord;
+    prFeedbackStageA?: PrFeedbackStageARecord;
+    prFeedbackGateBatches?: PrFeedbackGateBatchRecord[];
+    prFeedbackReadyToPublish?: PrFeedbackReadyToPublishRecord;
+}
+export declare function activatePrWorkflow(directory: string, sessionID: string, mode: PrWorkflowMode, options?: {
+    prHeadSha?: string;
+}): Promise<PrWorkflowGateState>;
+export declare function readPrWorkflowGateState(directory: string, sessionID: string): Promise<PrWorkflowGateState | null>;
+export declare function clearPrWorkflowGateState(directory: string, sessionID: string, expectedRevision?: number): Promise<void>;
+/** Bind an active PR workflow to one immutable PR head. */
+export declare function bindPrWorkflowHead(directory: string, sessionID: string, prHeadSha: string): Promise<PrWorkflowGateState>;
+/** Bind an active PR_REVIEW workflow to one immutable merge-base scope. */
+export declare function bindPrReviewBase(directory: string, sessionID: string, options: {
+    prHeadSha: string;
+    baseRef: string;
+    baseSha: string;
+}): Promise<PrWorkflowGateState>;
+/** Prove that caller-provided PR identity equals the actual checked-out commit. */
+export declare function assertCurrentCheckoutHead(directory: string, expectedHead: string): string;
+/** Prove that every PR-review lane reads the immutable checked-out PR tree. */
+export declare function assertPrReviewCleanCheckout(directory: string): void;
+export declare function enforcePrWorkflowDispatchLanesAsync(directory: string, sessionID: string, toolName: string): Promise<PrWorkflowGateState | null>;
+export declare function enforcePrReviewBaseDimensions(directory: string, sessionID: string, lanes: readonly PrWorkflowLaneSpec[], options: {
+    batchId: string;
+    prHeadSha: string;
+}): Promise<PrWorkflowGateState>;
+/** Validate durable exact-six PR review evidence across all base and retry batches. */
+export declare function assertPrReviewBaseCoverageSettled(directory: string, sessionID: string): Promise<PrWorkflowGateState>;
+/** Persist a council/reviewer/critic validation batch before launch. */
+export declare function recordPrReviewValidationBatch(directory: string, sessionID: string, phase: PrReviewValidationPhase, lanes: readonly PrWorkflowLaneSpec[], options: {
+    batchId: string;
+    prHeadSha: string;
+}): Promise<PrWorkflowGateState>;
+/** Validate that every declared council/reviewer/critic obligation has a successful retry. */
+export declare function assertPrReviewValidationSettled(directory: string, sessionID: string, phase?: PrReviewValidationPhase): Promise<PrWorkflowGateState>;
+export declare function declarePrFeedbackInventory(directory: string, sessionID: string, inventoryIds: readonly string[], options: {
+    prHeadSha: string;
+}): Promise<PrWorkflowGateState>;
+export declare function enforcePrFeedbackVerificationOwnership(directory: string, sessionID: string, ownership: readonly PrFeedbackLaneOwnership[], options: {
+    batchId: string;
+    prHeadSha: string;
+}): Promise<PrWorkflowGateState>;
+/** Validate cumulative exact inventory ownership and settled verification artifacts. */
+export declare function assertPrFeedbackVerificationSettled(directory: string, sessionID: string): Promise<PrWorkflowGateState>;
+/** Persist an actually executed Stage A receipt and invalidate later approvals. */
+export declare function recordPrFeedbackStageA(directory: string, sessionID: string, revisionDigest: string, checks: readonly PrFeedbackStageACheckReceipt[], options?: {
+    applicableCategories?: ReadonlyArray<'build' | 'typecheck' | 'lint'>;
+    applicableObligations?: ReadonlyArray<{
+        id: string;
+        category: 'build' | 'typecheck' | 'lint';
+        workingDirectory: string;
+        source: string;
+        validatorContract?: {
+            path: string;
+            id: string;
+        };
+    }>;
+}): Promise<PrWorkflowGateState>;
+/** Record one ordered, single-lane feedback validation phase before launch. */
+export declare function recordPrFeedbackGateBatch(directory: string, sessionID: string, phase: PrFeedbackGatePhase, lane: PrFeedbackLaneOwnership, options: {
+    batchId: string;
+    prHeadSha: string;
+    revisionDigest: string;
+}): Promise<PrWorkflowGateState>;
+/** Require the latest receipt for a feedback gate phase to be positive and fresh. */
+export declare function assertPrFeedbackGatePhaseSettled(directory: string, sessionID: string, phase: PrFeedbackGatePhase): Promise<PrWorkflowGateState>;
+/** Require every ordered feedback gate on one unchanged revision. */
+export declare function assertPrFeedbackReadyToPublish(directory: string, sessionID: string): Promise<PrWorkflowGateState>;
+export declare function markPrReviewTriggerEvaluationComplete(directory: string, sessionID: string, artifactPath: string): Promise<PrWorkflowGateState>;
+export declare function enforcePrWorkflowToolBefore(directory: string, sessionID: string, toolName: string, args: Record<string, unknown> | undefined, generatedAgentNames?: readonly string[]): Promise<void>;
+/** Validate the terminal PR workflow contract before removing its durable gate. */
+export declare function completePrWorkflow(directory: string, sessionID: string, expectedMode: PrWorkflowMode, prHeadSha: string): Promise<PrWorkflowCompletionStatus>;
+export declare const _test_exports: {
+    workflowGateStateRelativePath: typeof workflowGateStateRelativePath;
+    workflowGateStateLockRelativePath: typeof workflowGateStateLockRelativePath;
+    resetTrackedStateCache: () => void;
+    beforeTerminalClear: (() => Promise<void>) | undefined;
+    resolveCurrentGitHead: typeof resolveCurrentGitHead;
+    resolveCurrentUpstreamPushTarget: typeof resolveCurrentUpstreamPushTarget;
+    resolveCurrentUpstreamRemoteRef: typeof resolveCurrentUpstreamRemoteRef;
+    resolveExactRemoteBranchHead: typeof resolveExactRemoteBranchHead;
+    resolveCommitCountSince: typeof resolveCommitCountSince;
+    resolveIsWorkingTreeClean: typeof resolveIsWorkingTreeClean;
+    resolveIsExactSingleChildCommit: typeof resolveIsExactSingleChildCommit;
+    resolvePrWorkflowRevisionDigest: typeof resolvePrWorkflowRevisionDigest;
+    resolveRemoteRefsContainingHead: typeof resolveRemoteRefsContainingHead;
+    parseCriticVerdict: typeof parseCriticVerdict;
+    isProcessAlive: typeof isProcessAlive;
+    nowMs: () => number;
+};
+/** Require at least one real discovery row or a lane-bound CLEAN attestation. */
+export declare function prReviewDiscoveryArtifactCoversLane(text: string, expectedWorkflowLane: string): boolean;
+declare function parseCriticVerdict(text: string, itemId: string, reviewerSeverity?: string): {
+    status: string;
+    severity: string;
+} | null;
+declare function isProcessAlive(pid: number): boolean;
+declare function workflowGateStateLockRelativePath(sessionID: string): string;
+declare function workflowGateStateRelativePath(sessionID: string): string;
+export {};

package/dist/hooks/pr-workflow-response-gate.d.ts

@@ -0,0 +1,23 @@
+interface PrWorkflowResponseGateClient {
+    session?: unknown;
+}
+/**
+ * Prevent an architect from bypassing PR obligations by simply emitting text.
+ * The text-complete hook replaces every architect-session text part while the
+ * durable gate exists; session.idle then mechanically resumes that session.
+ */
+export declare function createPrWorkflowResponseGate(options: {
+    directory: string;
+    client?: PrWorkflowResponseGateClient;
+    wakeTimeoutMs?: number;
+}): {
+    event: (input: {
+        event: unknown;
+    }) => Promise<void>;
+    textComplete: (input: {
+        sessionID?: string;
+    }, output: {
+        text: string;
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/pr-workflow-session-resolver.d.ts

@@ -0,0 +1,14 @@
+interface ResolverClient {
+    session?: unknown;
+}
+/** Resolve a child tool call back to the nearest ancestor owning a durable PR gate. */
+export declare function createPrWorkflowSessionResolver(options: {
+    directory: string;
+    client?: ResolverClient;
+}): {
+    observeEvent: (input: {
+        event: unknown;
+    }) => void;
+    resolve: (sessionID: string) => Promise<string>;
+};
+export {};