opencode-plugin-flow 4.4.0 → 5.0.0

package/dist/infrastructure/fs/session-repository.d.ts

@@ -0,0 +1,2 @@
+import type { SessionRepository } from "../../application/ports/session-repository.js";
+export declare function createFileSessionRepository(workspace: string): SessionRepository;

package/dist/infrastructure/fs/workspace-flow-service.d.ts

@@ -0,0 +1,9 @@
+import { type FlowResponse, type FlowService } from "../../application/flow-service.js";
+export declare function createWorkspaceFlowService(workspace: string): FlowService;
+export declare function flowStatus(workspace: string): Promise<FlowResponse>;
+export declare function flowPlanSave(workspace: string, input: unknown): Promise<FlowResponse>;
+export declare function flowPlanApprove(workspace: string): Promise<FlowResponse>;
+export declare function flowRunStart(workspace: string, input: unknown): Promise<FlowResponse>;
+export declare function flowFeatureComplete(workspace: string, input: unknown): Promise<FlowResponse>;
+export declare function flowFeatureReset(workspace: string, input: unknown): Promise<FlowResponse>;
+export declare function flowSessionClose(workspace: string, input: unknown): Promise<FlowResponse>;

package/dist/{runtime → infrastructure/fs}/workspace.d.ts

@@ -1,7 +1,15 @@
-import { type Session } from "./schema";
+import type { Session } from "../../domain/session.js";
 export declare class InvalidFlowWorkspaceRootError extends Error {
     readonly code = "INVALID_FLOW_WORKSPACE_ROOT";
-    constructor(message: string);
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class UnsafeFlowWorkspaceLayoutError extends Error {
+    readonly code = "UNSAFE_FLOW_WORKSPACE_LAYOUT";
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class ArchiveCollisionError extends Error {
+    readonly code = "FLOW_ARCHIVE_COLLISION";
+    constructor(message: string, options?: ErrorOptions);
 }
 export declare function normalizeWorkspaceRoot(rawPath: string | undefined): string | null;
 export declare function assertMutableWorkspaceRoot(rawPath: string): string;
@@ -11,26 +19,13 @@ export declare function resolveWorkspaceRoot(context: {
 }): string;
 export declare function flowDir(worktree: string): string;
 export declare function sessionPath(worktree: string): string;
-export declare function flowInstructionPath(worktree: string): string;
 export declare function historyDir(worktree: string): string;
 export declare function archivedSessionPath(worktree: string, sessionId: string): string;
 export type SessionLockOptions = {
     timeoutMs?: number;
-    staleMs?: number;
 };
 export declare function withSessionLock<T>(worktree: string, task: () => Promise<T>, lockOptions?: SessionLockOptions): Promise<T>;
-export declare class UnreadableFlowSessionError extends Error {
-    readonly reason: string;
-    readonly code = "UNREADABLE_FLOW_SESSION";
-    constructor(message: string, reason: string);
-}
 export declare function loadSession(worktree: string): Promise<Session | null>;
 export declare function quarantineUnreadableSession(worktree: string): Promise<string | null>;
-export declare function flowSessionProgress(session: Session): {
-    completed: number;
-    total: number;
-};
-export declare function renderFlowInstructionFile(session: Session): string;
-export declare function refreshFlowInstructionFile(worktree: string): Promise<void>;
 export declare function saveSession(worktree: string, session: Session): Promise<Session>;
 export declare function archiveAndClearSession(worktree: string, session: Session): Promise<void>;

package/dist/infrastructure/system/transition-environment.d.ts

@@ -0,0 +1,2 @@
+import type { TransitionEnvironment } from "../../domain/transitions.js";
+export declare const systemTransitionEnvironment: TransitionEnvironment;

package/dist/platform/opencode/config.d.ts

@@ -0,0 +1,2 @@
+import { type MutableFlowConfig } from "../../config-shared.js";
+export declare function createConfigHook(ctx: unknown): (config: MutableFlowConfig) => Promise<void>;

package/dist/{adapters → platform}/opencode/plugin.d.ts

@@ -1,3 +1,3 @@
-import type { Plugin } from "./sdk";
+import type { Plugin } from "./sdk.js";
 declare const FlowPlugin: Plugin;
 export default FlowPlugin;

package/dist/{adapters → platform}/opencode/sdk.d.ts

@@ -1,3 +1,2 @@
 export type { Hooks, Plugin, ToolContext } from "@opencode-ai/plugin";
 export { tool } from "@opencode-ai/plugin";
-export type { Part } from "@opencode-ai/sdk";

package/dist/platform/opencode/tools.d.ts

@@ -0,0 +1,6 @@
+import { type Hooks } from "@opencode-ai/plugin";
+export type FlowHostInputOperation = "planSave" | "runStart" | "featureComplete" | "featureReset" | "sessionClose";
+export declare function acceptsFlowHostInput(operation: FlowHostInputOperation, input: unknown): boolean;
+type FlowTools = NonNullable<Hooks["tool"]>;
+export declare function createTools(ctx: unknown): FlowTools;
+export {};

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

@@ -1,25 +1,25 @@
 import { z } from "zod";
-import { type FlowPromptVariant } from "./prompt-surfaces";
+import { type FlowPromptVariant } from "./prompt-surfaces.js";
 declare const ModelDecisionSchema: z.ZodObject<{
     id: z.ZodString;
     route: z.ZodEnum<{
+        "flow-audit-worker": "flow-audit-worker";
+        "flow-auto": "flow-auto";
+        "flow-candidate-worker": "flow-candidate-worker";
+        "flow-evidence-worker": "flow-evidence-worker";
         "flow-plan": "flow-plan";
-        "flow-run": "flow-run";
         "flow-review": "flow-review";
-        "flow-evidence-worker": "flow-evidence-worker";
+        "flow-reviewer": "flow-reviewer";
+        "flow-run": "flow-run";
+        "flow-status": "flow-status";
         "flow-validation-worker": "flow-validation-worker";
-        "flow-audit-worker": "flow-audit-worker";
-        "flow-candidate-worker": "flow-candidate-worker";
         "flow-verifier-worker": "flow-verifier-worker";
-        "flow-auto": "flow-auto";
-        "flow-status": "flow-status";
-        "flow-reviewer": "flow-reviewer";
     }>;
     executionMode: z.ZodEnum<{
         blocked: "blocked";
-        serial: "serial";
-        readonly_parallel: "readonly_parallel";
         candidate_worker: "candidate_worker";
+        readonly_parallel: "readonly_parallel";
+        serial: "serial";
     }>;
     workers: z.ZodArray<z.ZodString>;
     stateOwner: z.ZodEnum<{
@@ -30,51 +30,40 @@ declare const ModelDecisionSchema: z.ZodObject<{
     planOnly: z.ZodBoolean;
     reviewFirst: z.ZodBoolean;
     validation: z.ZodArray<z.ZodEnum<{
+        behavioral: "behavioral";
         broad: "broad";
+        browser: "browser";
         focused: "focused";
-        behavioral: "behavioral";
         ui: "ui";
-        browser: "browser";
     }>>;
     independentReview: z.ZodBoolean;
     reviewDepth: z.ZodEnum<{
         broad: "broad";
-        quick: "quick";
-        standard: "standard";
         detailed: "detailed";
         not_applicable: "not_applicable";
+        quick: "quick";
+        standard: "standard";
     }>;
     manifestComplete: z.ZodBoolean;
     coverage: z.ZodEnum<{
+        complete: "complete";
         missing: "missing";
-        partial: "partial";
         not_applicable: "not_applicable";
-        complete: "complete";
+        partial: "partial";
     }>;
     handoffStatus: z.ZodEnum<{
         blocked: "blocked";
+        not_applicable: "not_applicable";
         partial: "partial";
         success: "success";
-        not_applicable: "not_applicable";
     }>;
     handoffHasRequiredSections: z.ZodBoolean;
     retryReviews: z.ZodNumber;
     stopsAfterRetryFailure: z.ZodBoolean;
-    phaseBoundaryAction: z.ZodEnum<{
-        none: "none";
-        stop: "stop";
-        resume_with_ack: "resume_with_ack";
-    }>;
-    sessionContinuation: z.ZodEnum<{
-        continue: "continue";
-        not_applicable: "not_applicable";
-        stop_on_runtime_boundary: "stop_on_runtime_boundary";
-        self_initiated_rollover: "self_initiated_rollover";
-    }>;
     candidateDecision: z.ZodEnum<{
-        used: "used";
-        serial_required: "serial_required";
         not_applicable: "not_applicable";
+        serial_required: "serial_required";
+        used: "used";
     }>;
     completionClaimed: z.ZodBoolean;
     reason: z.ZodString;

package/dist/prompt-quality.d.ts

@@ -1,4 +1,4 @@
-import { type CompiledFlowPrompt, type FlowPromptSurfaceName, type FlowPromptVariant } from "./prompt-surfaces";
+import { type CompiledFlowPrompt, type FlowPromptSurfaceName, type FlowPromptVariant } from "./prompt-surfaces.js";
 export type PromptMetric = {
     surface: string;
     variant: FlowPromptVariant | "runtime";

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare function resolveFlowPluginVersion(): string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-plugin-flow",
-	"version": "4.4.0",
+	"version": "5.0.0",
 	"description": "Stateful planning and execution workflow plugin for OpenCode",
 	"type": "module",
 	"repository": {
@@ -26,10 +26,11 @@
 		"CHANGELOG.md"
 	],
 	"scripts": {
-		"build": "bun run build:plugin && bun run build:cli && bun run build:types",
+		"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",
+		"clean": "bun run scripts/clean-dist.ts",
 		"lint": "bunx biome check 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",
@@ -38,8 +39,7 @@
 		"smoke:live": "FLOW_LIVE_SMOKE=1 bun test tests/live-opencode-smoke.test.ts",
 		"test": "bun test tests",
 		"typecheck": "tsc --noEmit",
-		"uninstall:opencode": "bun run ./src/cli.ts uninstall",
-		"check": "bun run typecheck && bun run lint && bun run build && bun run test"
+		"check": "bun run typecheck && bun run lint && bun run prompt:quality && bun run build && bun run test"
 	},
 	"keywords": [
 		"opencode",
@@ -50,19 +50,24 @@
 	],
 	"author": "Douwe de Vries",
 	"license": "MIT",
+	"packageManager": "bun@1.3.14",
 	"engines": {
-		"node": ">=20.12.0"
+		"node": ">=24"
 	},
 	"peerDependencies": {
-		"@opencode-ai/plugin": ">=1.17.3 <2"
+		"@opencode-ai/plugin": ">=1.18.3 <2"
 	},
 	"dependencies": {
-		"zod": "4.1.8"
+		"zod": "4.4.3"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.2.6",
-		"@opencode-ai/plugin": "1.17.3",
-		"bun-types": "latest",
-		"typescript": "^6.0.2"
+		"@biomejs/biome": "2.5.4",
+		"@opencode-ai/plugin": "1.18.3",
+		"@types/bun": "1.3.14",
+		"@types/node": "24.13.3",
+		"typescript": "7.0.2"
+	},
+	"overrides": {
+		"@types/node": "24.13.3"
 	}
 }

package/dist/adapters/opencode/config.d.ts

@@ -1,3 +0,0 @@
-import { type MutableFlowConfig } from "../../config-shared";
-import type { ToolContext } from "./sdk";
-export declare function createConfigHook(ctx: Pick<ToolContext, "worktree" | "directory">): (config: MutableFlowConfig) => Promise<void>;

package/dist/adapters/opencode/tools.d.ts

@@ -1,322 +0,0 @@
-import { type ToolContext } from "./sdk";
-export declare function createTools(ctx: unknown): {
-    flow_status: {
-        description: string;
-        args: {};
-        execute(args: Record<string, never>, context: ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-    };
-    flow_plan_save: {
-        description: string;
-        args: {
-            goal: import("zod").ZodOptional<import("zod").ZodString>;
-            plan: import("zod").ZodOptional<import("zod").ZodObject<{
-                summary: import("zod").ZodString;
-                overview: import("zod").ZodString;
-                requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
-                decisions: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
-                finalReviewPolicy: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    broad: "broad";
-                    detailed: "detailed";
-                }>>;
-                features: import("zod").ZodArray<import("zod").ZodObject<{
-                    summary: import("zod").ZodString;
-                    id: import("zod").ZodString;
-                    title: import("zod").ZodString;
-                    status: import("zod").ZodOptional<import("zod").ZodEnum<{
-                        pending: "pending";
-                        in_progress: "in_progress";
-                        completed: "completed";
-                        blocked: "blocked";
-                    }>>;
-                    reviewDepth: import("zod").ZodOptional<import("zod").ZodEnum<{
-                        quick: "quick";
-                        standard: "standard";
-                        detailed: "detailed";
-                    }>>;
-                    targets: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    validation: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    dependsOn: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                }, import("zod/v4/core").$strict>>;
-            }, import("zod/v4/core").$strict>>;
-        };
-        execute(args: {
-            goal?: string | undefined;
-            plan?: {
-                summary: string;
-                overview: string;
-                requirements: string[];
-                decisions: string[];
-                features: {
-                    summary: string;
-                    id: string;
-                    title: string;
-                    status?: "pending" | "in_progress" | "completed" | "blocked" | undefined;
-                    reviewDepth?: "quick" | "standard" | "detailed" | undefined;
-                    targets?: string[] | undefined;
-                    validation?: string[] | undefined;
-                    dependsOn?: string[] | undefined;
-                }[];
-                finalReviewPolicy?: "broad" | "detailed" | undefined;
-            } | undefined;
-        }, context: ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-    };
-    flow_plan_approve: {
-        description: string;
-        args: {};
-        execute(args: Record<string, never>, context: ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-    };
-    flow_run_start: {
-        description: string;
-        args: {
-            featureId: import("zod").ZodOptional<import("zod").ZodString>;
-            phaseBoundaryAck: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        };
-        execute(args: {
-            featureId?: string | undefined;
-            phaseBoundaryAck?: boolean | undefined;
-        }, context: ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-    };
-    flow_feature_complete: {
-        description: string;
-        args: {
-            status: import("zod").ZodEnum<{
-                ok: "ok";
-                needs_input: "needs_input";
-            }>;
-            featureId: import("zod").ZodString;
-            summary: import("zod").ZodString;
-            artifactsChanged: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-                path: import("zod").ZodString;
-            }, import("zod/v4/core").$strict>>>;
-            validationRun: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-                command: import("zod").ZodString;
-                status: import("zod").ZodEnum<{
-                    passed: "passed";
-                    failed: "failed";
-                }>;
-                summary: import("zod").ZodString;
-            }, import("zod/v4/core").$strict>>>;
-            validationScope: import("zod").ZodOptional<import("zod").ZodEnum<{
-                targeted: "targeted";
-                broad: "broad";
-            }>>;
-            featureReviewDepth: import("zod").ZodOptional<import("zod").ZodEnum<{
-                quick: "quick";
-                standard: "standard";
-                detailed: "detailed";
-            }>>;
-            featureReview: import("zod").ZodOptional<import("zod").ZodObject<{
-                status: import("zod").ZodEnum<{
-                    passed: "passed";
-                    failed: "failed";
-                }>;
-                summary: import("zod").ZodString;
-                blockingFindings: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
-                    summary: import("zod").ZodString;
-                    severity: import("zod").ZodDefault<import("zod").ZodEnum<{
-                        blocking: "blocking";
-                        advisory: "advisory";
-                    }>>;
-                }, import("zod/v4/core").$strict>>>;
-            }, import("zod/v4/core").$strict>>;
-            finalReview: import("zod").ZodOptional<import("zod").ZodObject<{
-                status: import("zod").ZodEnum<{
-                    passed: "passed";
-                    failed: "failed";
-                }>;
-                summary: import("zod").ZodString;
-                blockingFindings: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
-                    summary: import("zod").ZodString;
-                    severity: import("zod").ZodDefault<import("zod").ZodEnum<{
-                        blocking: "blocking";
-                        advisory: "advisory";
-                    }>>;
-                }, import("zod/v4/core").$strict>>>;
-                reviewDepth: import("zod").ZodEnum<{
-                    broad: "broad";
-                    detailed: "detailed";
-                }>;
-            }, import("zod/v4/core").$strict>>;
-            outcome: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
-                kind: import("zod").ZodDefault<import("zod").ZodEnum<{
-                    completed: "completed";
-                    blocked: "blocked";
-                    needs_input: "needs_input";
-                    replan_required: "replan_required";
-                }>>;
-                summary: import("zod").ZodOptional<import("zod").ZodString>;
-                resolutionHint: import("zod").ZodOptional<import("zod").ZodString>;
-            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                kind: import("zod").ZodDefault<import("zod").ZodEnum<{
-                    blocked: "blocked";
-                    needs_input: "needs_input";
-                    replan_required: "replan_required";
-                }>>;
-                summary: import("zod").ZodString;
-                resolutionHint: import("zod").ZodOptional<import("zod").ZodString>;
-            }, import("zod/v4/core").$strict>]>>;
-            orchestrationPasses: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                kind: import("zod").ZodEnum<{
-                    validation: "validation";
-                    audit: "audit";
-                    candidate: "candidate";
-                    discovery: "discovery";
-                    review: "review";
-                    verification: "verification";
-                    "implementation-decision": "implementation-decision";
-                }>;
-                decision: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    parallel: "parallel";
-                    serial: "serial";
-                    "candidate-exact-path": "candidate-exact-path";
-                    "candidate-worktree": "candidate-worktree";
-                    tournament: "tournament";
-                    skipped: "skipped";
-                }>>;
-                decisionReason: import("zod").ZodOptional<import("zod").ZodString>;
-                candidateEligibility: import("zod").ZodDefault<import("zod").ZodEnum<{
-                    eligible: "eligible";
-                    not_eligible: "not_eligible";
-                    unknown: "unknown";
-                }>>;
-                candidateDecision: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    skipped: "skipped";
-                    used: "used";
-                    serial_required: "serial_required";
-                }>>;
-                decisionFactors: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodEnum<{
-                    shared_state: "shared_state";
-                    overlapping_files: "overlapping_files";
-                    small_slice: "small_slice";
-                    needs_manager_judgment: "needs_manager_judgment";
-                    independent_surface: "independent_surface";
-                    validation_available: "validation_available";
-                }>>>;
-                modes: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodEnum<{
-                    evidence: "evidence";
-                    validation: "validation";
-                    audit: "audit";
-                    verifier: "verifier";
-                    review: "review";
-                    "candidate-implementation": "candidate-implementation";
-                }>>>;
-                workerCount: import("zod").ZodDefault<import("zod").ZodNumber>;
-                candidateWorkerCount: import("zod").ZodDefault<import("zod").ZodNumber>;
-                verifierWorkerCount: import("zod").ZodDefault<import("zod").ZodNumber>;
-                sliceIds: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
-                dependsOn: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
-                writeScope: import("zod").ZodDefault<import("zod").ZodEnum<{
-                    none: "none";
-                    "manager-serial": "manager-serial";
-                    "exact-path": "exact-path";
-                    "isolated-worktree": "isolated-worktree";
-                    mixed: "mixed";
-                }>>;
-                handoffRefs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
-                verificationStatus: import("zod").ZodDefault<import("zod").ZodEnum<{
-                    pending: "pending";
-                    passed: "passed";
-                    failed: "failed";
-                    mixed: "mixed";
-                    "not-needed": "not-needed";
-                    downgraded: "downgraded";
-                }>>;
-                outcome: import("zod").ZodDefault<import("zod").ZodEnum<{
-                    accepted: "accepted";
-                    modified: "modified";
-                    rejected: "rejected";
-                    partial: "partial";
-                    "not-covered": "not-covered";
-                    superseded: "superseded";
-                }>>;
-                synthesisRef: import("zod").ZodOptional<import("zod").ZodString>;
-            }, import("zod/v4/core").$strict>>>;
-        };
-        execute(args: {
-            status: "ok" | "needs_input";
-            featureId: string;
-            summary: string;
-            artifactsChanged?: {
-                path: string;
-            }[] | undefined;
-            validationRun?: {
-                command: string;
-                status: "passed" | "failed";
-                summary: string;
-            }[] | undefined;
-            validationScope?: "targeted" | "broad" | undefined;
-            featureReviewDepth?: "quick" | "standard" | "detailed" | undefined;
-            featureReview?: {
-                status: "passed" | "failed";
-                summary: string;
-                blockingFindings: {
-                    summary: string;
-                    severity: "blocking" | "advisory";
-                }[];
-            } | undefined;
-            finalReview?: {
-                status: "passed" | "failed";
-                summary: string;
-                blockingFindings: {
-                    summary: string;
-                    severity: "blocking" | "advisory";
-                }[];
-                reviewDepth: "broad" | "detailed";
-            } | undefined;
-            outcome?: {
-                kind: "completed" | "blocked" | "needs_input" | "replan_required";
-                summary?: string | undefined;
-                resolutionHint?: string | undefined;
-            } | {
-                kind: "blocked" | "needs_input" | "replan_required";
-                summary: string;
-                resolutionHint?: string | undefined;
-            } | undefined;
-            orchestrationPasses?: {
-                id: string;
-                kind: "validation" | "audit" | "candidate" | "discovery" | "review" | "verification" | "implementation-decision";
-                candidateEligibility: "eligible" | "not_eligible" | "unknown";
-                decisionFactors: ("shared_state" | "overlapping_files" | "small_slice" | "needs_manager_judgment" | "independent_surface" | "validation_available")[];
-                modes: ("evidence" | "validation" | "audit" | "verifier" | "review" | "candidate-implementation")[];
-                workerCount: number;
-                candidateWorkerCount: number;
-                verifierWorkerCount: number;
-                sliceIds: string[];
-                dependsOn: string[];
-                writeScope: "none" | "manager-serial" | "exact-path" | "isolated-worktree" | "mixed";
-                handoffRefs: string[];
-                verificationStatus: "pending" | "passed" | "failed" | "mixed" | "not-needed" | "downgraded";
-                outcome: "accepted" | "modified" | "rejected" | "partial" | "not-covered" | "superseded";
-                decision?: "parallel" | "serial" | "candidate-exact-path" | "candidate-worktree" | "tournament" | "skipped" | undefined;
-                decisionReason?: string | undefined;
-                candidateDecision?: "skipped" | "used" | "serial_required" | undefined;
-                synthesisRef?: string | undefined;
-            }[] | undefined;
-        }, context: ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-    };
-    flow_feature_reset: {
-        description: string;
-        args: {
-            featureId: import("zod").ZodString;
-        };
-        execute(args: {
-            featureId: string;
-        }, context: ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-    };
-    flow_session_close: {
-        description: string;
-        args: {
-            kind: import("zod").ZodEnum<{
-                completed: "completed";
-                deferred: "deferred";
-                abandoned: "abandoned";
-            }>;
-            summary: import("zod").ZodOptional<import("zod").ZodString>;
-        };
-        execute(args: {
-            kind: "completed" | "deferred" | "abandoned";
-            summary?: string | undefined;
-        }, context: ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-    };
-};

package/dist/distribution/flow-skill-definitions.d.ts

@@ -1,9 +0,0 @@
-export type FlowSkillFile = {
-    relativePath: string;
-    content: string;
-};
-export type FlowSkillDefinition = {
-    name: string;
-    files: FlowSkillFile[];
-};
-export declare const FLOW_SKILL_DEFINITIONS: readonly FlowSkillDefinition[];