opencode-plugin-flow 5.2.1 → 5.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-plugin-flow",
-	"version": "5.2.1",
+	"version": "5.2.2",
 	"description": "Stateful planning and execution workflow plugin for OpenCode",
 	"type": "module",
 	"repository": {
@@ -20,7 +20,13 @@
 		"opencode-plugin-flow": "./dist/cli.js"
 	},
 	"files": [
-		"dist",
+		"dist/index.js",
+		"dist/index.js.map",
+		"dist/index.d.ts",
+		"dist/platform/opencode/plugin.d.ts",
+		"dist/platform/opencode/sdk.d.ts",
+		"dist/cli.js",
+		"dist/cli.js.map",
 		"LICENSE",
 		"README.md",
 		"CHANGELOG.md"
@@ -29,11 +35,12 @@
 		"build": "bun run clean && bun run build:plugin && bun run build:cli && bun run build:types",
 		"build:plugin": "bun build --target=node --outdir=./dist --entry-naming=index.js --external=@opencode-ai/plugin --external=zod --sourcemap=external ./src/index.ts",
 		"build:cli": "bun build --target=node --outdir=./dist --entry-naming=cli.js --banner='#!/usr/bin/env node' --sourcemap=external ./src/cli.ts",
-		"build:types": "tsc -p tsconfig.types.json",
+		"build:types": "tsc -p tsconfig.types.json && bun run scripts/prune-dist-declarations.ts",
 		"clean": "bun run scripts/clean-dist.ts",
-		"lint": "bunx biome check src tests scripts --files-ignore-unknown=true --vcs-use-ignore-file=true",
+		"lint": "bunx biome check biome.json src tests scripts --files-ignore-unknown=true --vcs-use-ignore-file=true",
 		"prompt:quality": "bun run scripts/prompt-quality.ts",
 		"prompt:model-eval": "bun run scripts/prompt-model-eval.ts",
+		"release:metadata": "bun run scripts/release-metadata.ts",
 		"replay:report": "bun run scripts/replay-report.ts",
 		"transport:report": "bun run scripts/causal-transport-report.ts",
 		"package:smoke": "bun test tests/package-smoke.test.ts",
@@ -45,7 +52,7 @@
 		"verify:lifecycle": "bun run test:lifecycle:invariants && bun run test:lifecycle:recovery && bun run test:contracts",
 		"test": "bun test tests",
 		"typecheck": "tsc --noEmit",
-		"check": "bun run typecheck && bun run lint && bun run prompt:quality && bun run build && bun run test"
+		"check": "bun run typecheck && bun run lint && bun run release:metadata && bun run prompt:quality && bun run build && bun run test"
 	},
 	"keywords": [
 		"opencode",

package/dist/application/errors.d.ts

@@ -1,10 +0,0 @@
-export declare class UnreadableFlowSessionError extends Error {
-    readonly code = "UNREADABLE_FLOW_SESSION";
-    readonly reason: string;
-    constructor(message: string, reason: string);
-}
-export declare class UnsupportedFlowSessionVersionError extends Error {
-    readonly code = "UNSUPPORTED_FLOW_SESSION_VERSION";
-    readonly actualVersion: unknown;
-    constructor(actualVersion: unknown);
-}

package/dist/application/flow-service.d.ts

@@ -1,311 +0,0 @@
-import { z } from "zod";
-import type { Session, SessionId } from "../domain/session.js";
-import { mutationReceiptProjection, rejectedMutationReceiptProjection, type TransitionEnvironment } from "../domain/transitions.js";
-import type { SessionRepository } from "./ports/session-repository.js";
-type WorkflowData = {
-    projection?: unknown;
-    receipt?: ReturnType<typeof mutationReceiptProjection> | ReturnType<typeof rejectedMutationReceiptProjection>;
-    failure?: {
-        summary: string;
-        recovery?: string;
-    };
-    archive?: {
-        sessionId: SessionId;
-        closure: Session["closure"];
-    };
-    quarantine?: {
-        reason: string;
-        preservedAt?: string;
-    };
-};
-type ResponseContext = {
-    statusSummary?: string;
-    nextAction?: string;
-    dataNote?: string;
-    warnings?: string[];
-    workflowData?: WorkflowData;
-    recovery?: string;
-};
-export type FlowResponse = ResponseContext & {
-    status: "ok" | "error" | "missing_goal" | "missing_session";
-    summary: string;
-};
-export type FlowService = {
-    status(input: unknown): Promise<FlowResponse>;
-    planSave(input: unknown): Promise<FlowResponse>;
-    planApprove(): Promise<FlowResponse>;
-    runStart(input: unknown): Promise<FlowResponse>;
-    reviewStart(input: unknown): Promise<FlowResponse>;
-    featureComplete(input: unknown): Promise<FlowResponse>;
-    featureReset(input: unknown): Promise<FlowResponse>;
-    sessionClose(input: unknown): Promise<FlowResponse>;
-};
-export declare const FlowStatusSchema: z.ZodObject<{
-    request: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        view: z.ZodLiteral<"reviewer">;
-        assignmentId: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        view: z.ZodLiteral<"execution">;
-    }, z.core.$strict>, z.ZodObject<{
-        view: z.ZodLiteral<"detail">;
-        sinceRevision: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>, z.ZodObject<{
-        view: z.ZodLiteral<"compact">;
-        sinceRevision: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>], "view">;
-}, z.core.$strict>;
-export declare const FlowPlanSaveSchema: z.ZodObject<{
-    goal: z.ZodOptional<z.ZodString>;
-    plan: z.ZodOptional<z.ZodObject<{
-        summary: z.ZodString;
-        overview: z.ZodString;
-        requirements: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        decisions: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        finalReviewPolicy: z.ZodOptional<z.ZodEnum<{
-            broad: "broad";
-            detailed: "detailed";
-        }>>;
-        features: z.ZodArray<z.ZodObject<{
-            id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
-            title: z.ZodString;
-            summary: z.ZodString;
-            status: z.ZodOptional<z.ZodEnum<{
-                blocked: "blocked";
-                completed: "completed";
-                in_progress: "in_progress";
-                pending: "pending";
-            }>>;
-            reviewDepth: z.ZodOptional<z.ZodEnum<{
-                detailed: "detailed";
-                quick: "quick";
-                standard: "standard";
-            }>>;
-            targets: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            validation: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            dependsOn: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const FlowRunStartSchema: z.ZodObject<{
-    featureId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>>;
-}, z.core.$strict>;
-export declare const FlowFeatureResetSchema: z.ZodObject<{
-    operationId: z.ZodString;
-    expectedRevision: z.ZodNumber;
-    expectedSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
-    featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
-}, z.core.$strict>;
-export declare const FlowSessionCloseSchema: z.ZodObject<{
-    request: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        mode: z.ZodLiteral<"start">;
-        operationId: z.ZodString;
-        expectedRevision: z.ZodNumber;
-        expectedSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
-        kind: z.ZodEnum<{
-            abandoned: "abandoned";
-            completed: "completed";
-            deferred: "deferred";
-        }>;
-        summary: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        mode: z.ZodLiteral<"retry">;
-        operationId: z.ZodString;
-    }, z.core.$strict>], "mode">;
-}, z.core.$strict>;
-export declare const FlowFeatureCompleteToolSchema: z.ZodObject<{
-    request: z.ZodObject<{
-        operationId: z.ZodString;
-        expectedRevision: z.ZodNumber;
-        expectedSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
-        featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
-        result: z.ZodUnion<readonly [z.ZodObject<{
-            kind: z.ZodLiteral<"completed">;
-            summary: z.ZodString;
-            artifactsChanged: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                path: z.ZodString;
-            }, z.core.$strict>>>;
-            orchestrationPasses: z.ZodOptional<z.ZodUnknown>;
-            validationScope: z.ZodLiteral<"targeted">;
-            featureReview: z.ZodObject<{
-                assignmentId: z.ZodString;
-                verdict: z.ZodEnum<{
-                    failed: "failed";
-                    passed: "passed";
-                }>;
-                findings: z.ZodArray<z.ZodObject<{
-                    taxonomy: z.ZodEnum<{
-                        advisory: "advisory";
-                        evidence_gap: "evidence_gap";
-                        implementation_defect: "implementation_defect";
-                        regression_coverage_gap: "regression_coverage_gap";
-                    }>;
-                    subject: z.ZodString;
-                    requirementOrRisk: z.ZodString;
-                    evidenceLocator: z.ZodString;
-                    summary: z.ZodString;
-                    severity: z.ZodEnum<{
-                        advisory: "advisory";
-                        blocking: "blocking";
-                    }>;
-                }, z.core.$strict>>;
-                completedAt: z.ZodString;
-                terminalDisposition: z.ZodEnum<{
-                    observed_unsubmitted: "observed_unsubmitted";
-                    submitted: "submitted";
-                }>;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"completed">;
-            summary: z.ZodString;
-            artifactsChanged: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                path: z.ZodString;
-            }, z.core.$strict>>>;
-            orchestrationPasses: z.ZodOptional<z.ZodUnknown>;
-            validationScope: z.ZodLiteral<"broad">;
-            finalReview: z.ZodObject<{
-                assignmentId: z.ZodString;
-                verdict: z.ZodEnum<{
-                    failed: "failed";
-                    passed: "passed";
-                }>;
-                findings: z.ZodArray<z.ZodObject<{
-                    taxonomy: z.ZodEnum<{
-                        advisory: "advisory";
-                        evidence_gap: "evidence_gap";
-                        implementation_defect: "implementation_defect";
-                        regression_coverage_gap: "regression_coverage_gap";
-                    }>;
-                    subject: z.ZodString;
-                    requirementOrRisk: z.ZodString;
-                    evidenceLocator: z.ZodString;
-                    summary: z.ZodString;
-                    severity: z.ZodEnum<{
-                        advisory: "advisory";
-                        blocking: "blocking";
-                    }>;
-                }, z.core.$strict>>;
-                completedAt: z.ZodString;
-                terminalDisposition: z.ZodEnum<{
-                    observed_unsubmitted: "observed_unsubmitted";
-                    submitted: "submitted";
-                }>;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"blocked">;
-            summary: z.ZodString;
-            review: z.ZodObject<{
-                assignmentId: z.ZodString;
-                verdict: z.ZodEnum<{
-                    failed: "failed";
-                    passed: "passed";
-                }>;
-                findings: z.ZodArray<z.ZodObject<{
-                    taxonomy: z.ZodEnum<{
-                        advisory: "advisory";
-                        evidence_gap: "evidence_gap";
-                        implementation_defect: "implementation_defect";
-                        regression_coverage_gap: "regression_coverage_gap";
-                    }>;
-                    subject: z.ZodString;
-                    requirementOrRisk: z.ZodString;
-                    evidenceLocator: z.ZodString;
-                    summary: z.ZodString;
-                    severity: z.ZodEnum<{
-                        advisory: "advisory";
-                        blocking: "blocking";
-                    }>;
-                }, z.core.$strict>>;
-                completedAt: z.ZodString;
-                terminalDisposition: z.ZodEnum<{
-                    observed_unsubmitted: "observed_unsubmitted";
-                    submitted: "submitted";
-                }>;
-            }, z.core.$strict>;
-            resolutionHint: z.ZodOptional<z.ZodString>;
-            orchestrationPasses: z.ZodOptional<z.ZodUnknown>;
-        }, z.core.$strict>]>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const FlowReviewStartSchema: z.ZodObject<{
-    request: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        operationId: z.ZodString;
-        expectedRevision: z.ZodNumber;
-        expectedSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
-        featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
-        packet: z.ZodObject<{
-            summary: z.ZodString;
-            riskLenses: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>;
-        validations: z.ZodArray<z.ZodObject<{
-            startedAt: z.ZodString;
-            completedAt: z.ZodString;
-            command: z.ZodString;
-            summary: z.ZodString;
-            exitCode: z.ZodNumber;
-            outputDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
-            artifactRef: z.ZodOptional<z.ZodObject<{
-                kind: z.ZodLiteral<"restricted_evidence_v1">;
-                digest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
-                byteLength: z.ZodNumber;
-            }, z.core.$strict>>;
-            environmentKeys: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>>;
-        reviewKind: z.ZodLiteral<"feature">;
-        validationScope: z.ZodLiteral<"targeted">;
-    }, z.core.$strict>, z.ZodObject<{
-        operationId: z.ZodString;
-        expectedRevision: z.ZodNumber;
-        expectedSnapshotId: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
-        featureId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../domain/session.js").FeatureId, string>>;
-        packet: z.ZodObject<{
-            summary: z.ZodString;
-            riskLenses: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>;
-        validations: z.ZodArray<z.ZodObject<{
-            startedAt: z.ZodString;
-            completedAt: z.ZodString;
-            command: z.ZodString;
-            summary: z.ZodString;
-            exitCode: z.ZodNumber;
-            outputDigest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
-            artifactRef: z.ZodOptional<z.ZodObject<{
-                kind: z.ZodLiteral<"restricted_evidence_v1">;
-                digest: z.ZodPipe<z.ZodString, z.ZodTransform<`sha256:${string}`, string>>;
-                byteLength: z.ZodNumber;
-            }, z.core.$strict>>;
-            environmentKeys: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>>;
-        reviewKind: z.ZodLiteral<"final">;
-        validationScope: z.ZodLiteral<"broad">;
-        featureReview: z.ZodObject<{
-            assignmentId: z.ZodString;
-            verdict: z.ZodEnum<{
-                failed: "failed";
-                passed: "passed";
-            }>;
-            findings: z.ZodArray<z.ZodObject<{
-                taxonomy: z.ZodEnum<{
-                    advisory: "advisory";
-                    evidence_gap: "evidence_gap";
-                    implementation_defect: "implementation_defect";
-                    regression_coverage_gap: "regression_coverage_gap";
-                }>;
-                subject: z.ZodString;
-                requirementOrRisk: z.ZodString;
-                evidenceLocator: z.ZodString;
-                summary: z.ZodString;
-                severity: z.ZodEnum<{
-                    advisory: "advisory";
-                    blocking: "blocking";
-                }>;
-            }, z.core.$strict>>;
-            completedAt: z.ZodString;
-            terminalDisposition: z.ZodEnum<{
-                observed_unsubmitted: "observed_unsubmitted";
-                submitted: "submitted";
-            }>;
-        }, z.core.$strict>;
-    }, z.core.$strict>], "reviewKind">;
-}, z.core.$strict>;
-export declare function createFlowService(repository: SessionRepository, environment: TransitionEnvironment): FlowService;
-export {};

package/dist/application/ports/evidence-artifact-store.d.ts

@@ -1,28 +0,0 @@
-import type { EvidenceArtifactRef } from "../../domain/session.js";
-export declare const MAX_EVIDENCE_ARTIFACT_BYTES: number;
-export type EvidenceArtifactDigest = `sha256:${string}`;
-export type { EvidenceArtifactRef } from "../../domain/session.js";
-export interface EvidenceArtifactStore {
-    publishEvidenceArtifact(bytes: Uint8Array): Promise<EvidenceArtifactRef>;
-    readEvidenceArtifact(ref: EvidenceArtifactRef): Promise<Uint8Array>;
-}
-export declare class InvalidEvidenceArtifactReferenceError extends Error {
-    readonly code = "FLOW_EVIDENCE_INVALID_REFERENCE";
-    constructor(message: string, options?: ErrorOptions);
-}
-export declare class EvidenceArtifactNotFoundError extends Error {
-    readonly code = "FLOW_EVIDENCE_NOT_FOUND";
-    constructor(message: string, options?: ErrorOptions);
-}
-export declare class EvidenceArtifactIntegrityError extends Error {
-    readonly code = "FLOW_EVIDENCE_INTEGRITY";
-    constructor(message: string, options?: ErrorOptions);
-}
-export declare class EvidenceArtifactCollisionError extends Error {
-    readonly code = "FLOW_EVIDENCE_COLLISION";
-    constructor(message: string, options?: ErrorOptions);
-}
-export declare class EvidenceArtifactTooLargeError extends Error {
-    readonly code = "FLOW_EVIDENCE_TOO_LARGE";
-    constructor(message: string, options?: ErrorOptions);
-}

package/dist/application/ports/session-repository.d.ts

@@ -1,22 +0,0 @@
-import type { Session } from "../../domain/session.js";
-import type { EvidenceArtifactStore } from "./evidence-artifact-store.js";
-import type { SourceIdentityProvider } from "./source-identity.js";
-export declare class ArchivedSessionLookupError extends Error {
-    readonly code = "FLOW_ARCHIVE_LOOKUP_FAILED";
-    readonly failureKind: "history-integrity" | "helper-runtime";
-    constructor(message: string, options?: ErrorOptions & {
-        failureKind?: "history-integrity" | "helper-runtime";
-    });
-}
-export type SessionTransaction = EvidenceArtifactStore & SourceIdentityProvider & {
-    load(): Promise<Session | null>;
-    findArchivedByCloseRetryOperationId(operationId: string): Promise<Session | null>;
-    findArchivedByOperationId(operationId: string): Promise<Session | null>;
-    save(session: Session): Promise<Session>;
-    archiveAndClear(session: Session): Promise<void>;
-    quarantineUnreadable(): Promise<string | null>;
-};
-export interface SessionRepository {
-    read(): Promise<Session | null>;
-    transact<T>(task: (transaction: SessionTransaction) => Promise<T>): Promise<T>;
-}

package/dist/application/ports/source-identity.d.ts

@@ -1,61 +0,0 @@
-/**
- * Application port for the authoritative source/worktree identity boundary.
- *
- * The provider derives a canonical, deterministic digest of the workspace
- * source state (the "A1 canonical source digest"). It is the single trusted
- * producer of source identity used by the transactional completion boundary.
- * Callers never assert source identity; Flow recomputes it and binds evidence
- * to it. The source-v2 manifest is materialization-sensitive:
- * an indexed sparse-checkout path absent from disk is distinct from the same
- * path materialized in a dense worktree.
- */
-export type SourceDigest = `sha256:${string}`;
-export type SourceIdentity = {
-    /** Canonical lowercase SHA-256 digest of the source state. */
-    readonly digest: SourceDigest;
-    /** Whether the digest was derived from a Git manifest or a full-tree walk. */
-    readonly mode: "git" | "non-git";
-    /** Number of source entries that contributed to the digest. */
-    readonly entryCount: number;
-};
-export interface SourceIdentityProvider {
-    /**
-     * Compute the canonical source digest for the workspace. Implementations
-     * must fail closed on unsafe symlinks, unreadable entries, resource limits,
-     * or a workspace mutation observed while the source is being measured.
-     */
-    computeSourceIdentity(): Promise<SourceIdentity>;
-}
-/**
- * Base class for source-identity failures. The message never carries absolute
- * paths, file contents, or command output; only a bounded, safe reason.
- */
-export declare class SourceIdentityError extends Error {
-    readonly code: string;
-    constructor(message: string, options?: ErrorOptions);
-}
-/** A symlink whose target escapes the workspace root or is absolute. */
-export declare class SourceIdentityUnsafeSymlinkError extends SourceIdentityError {
-    readonly code = "FLOW_SOURCE_IDENTITY_UNSAFE_SYMLINK";
-    constructor(message: string, options?: ErrorOptions);
-}
-/** An entry that could not be read; measurement never silently skips state. */
-export declare class SourceIdentityUnreadableError extends SourceIdentityError {
-    readonly code = "FLOW_SOURCE_IDENTITY_UNREADABLE";
-    constructor(message: string, options?: ErrorOptions);
-}
-/** The source exceeded the bounded file-count or byte budget. */
-export declare class SourceIdentityOverflowError extends SourceIdentityError {
-    readonly code = "FLOW_SOURCE_IDENTITY_OVERFLOW";
-    constructor(message: string, options?: ErrorOptions);
-}
-/** The workspace changed while it was being measured. */
-export declare class SourceIdentityRaceError extends SourceIdentityError {
-    readonly code = "FLOW_SOURCE_IDENTITY_RACE";
-    constructor(message: string, options?: ErrorOptions);
-}
-/** Git enumeration failed for a Git workspace. */
-export declare class SourceIdentityGitError extends SourceIdentityError {
-    readonly code = "FLOW_SOURCE_IDENTITY_GIT";
-    constructor(message: string, options?: ErrorOptions);
-}

package/dist/application/replay/canonical-json.d.ts

@@ -1,7 +0,0 @@
-export type CanonicalJsonValue = null | boolean | number | string | readonly CanonicalJsonValue[] | {
-    readonly [key: string]: CanonicalJsonValue;
-};
-/** Stable, whitespace-free JSON with recursively sorted object keys. */
-export declare function canonicalizeReplayJson(value: CanonicalJsonValue): string;
-export declare const canonicalizeJson: typeof canonicalizeReplayJson;
-export declare const canonicalReplayJson: typeof canonicalizeReplayJson;