opencode-plugin-flow 4.1.11 → 4.1.14

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 One short line per release. For the full rationale behind each entry, see the
 commit history and review evidence.
 
+## [4.1.14] - 2026-06-22
+
+Publish Flow through npm trusted publishing so release CI no longer depends on expiring npm tokens.
+
+## [4.1.13] - 2026-06-21
+
+Teach Flow's parallel orchestration lore to walk a full wave while pinning hidden worker permissions to tested docs.
+
+## [4.1.12] - 2026-06-18
+
+Harden Flow's hidden worker lore, scriptable doctor checks, typed package smoke, and session edge contracts without widening the v4 runtime surface.
+
 ## [4.1.11] - 2026-06-17
 
 Give bundled Flow command lore a real title seed so OpenCode can name new chats while keeping the heavy instructions synthetic.

package/README.md

@@ -21,8 +21,8 @@ The manager still owns every Flow state change. Workers gather evidence; they do
 Use OpenCode's plugin installer when your OpenCode version supports it:
 
 ```bash
-opencode plugin opencode-plugin-flow@4.1.11 --global --force
-npx -y opencode-plugin-flow@4.1.11 sync
+opencode plugin opencode-plugin-flow@4.1.14 --global --force
+npx -y opencode-plugin-flow@4.1.14 sync
 ```
 
 The first command adds Flow to your global OpenCode plugin config or replaces an
@@ -48,7 +48,7 @@ OpenCode config manually instead:
 
 ```json
 {
-  "plugin": ["opencode-plugin-flow@4.1.11"]
+  "plugin": ["opencode-plugin-flow@4.1.14"]
 }
 ```
 
@@ -59,7 +59,7 @@ duplicate entry.
 Then run the same pre-start skill sync and start or restart OpenCode:
 
 ```bash
-npx -y opencode-plugin-flow@4.1.11 sync
+npx -y opencode-plugin-flow@4.1.14 sync
 ```
 
 Project-local skill overrides still work through OpenCode's normal lookup:
@@ -84,9 +84,21 @@ version in your global `opencode.json`.
 To inspect the installed skill set:
 
 ```bash
-npx -y opencode-plugin-flow@4.1.11 doctor
+npx -y opencode-plugin-flow@4.1.14 doctor
 ```
 
+For automation, keep the default human-readable `doctor` output and opt into
+machine behavior explicitly:
+
+```bash
+npx -y opencode-plugin-flow@4.1.14 doctor --json
+npx -y opencode-plugin-flow@4.1.14 doctor --check
+```
+
+`doctor --check` and `doctor --strict` exit nonzero when the health status is
+`sync_required` or `action_required`; plain `doctor` remains advisory and exits
+successfully.
+
 If a command reports `Skill "flow-review" not found. Available skills...` or a
 similar Flow skill-loading error after upgrading, it is usually an older
 OpenCode process or stale resolved command body. Flow command preflight replaces
@@ -99,7 +111,7 @@ above first. Missing, incomplete, or outdated managed skills can still be
 repaired with:
 
 ```bash
-npx -y opencode-plugin-flow@4.1.11 sync
+npx -y opencode-plugin-flow@4.1.14 sync
 ```
 
 Then restart OpenCode so the refreshed registry is loaded. `sync` manages all
@@ -122,6 +134,13 @@ native skill discovery for the required Flow loop:
 | `/flow-review` | Run a read-only review. |
 | `/flow-status` | Show the active session and next action. |
 
+Flow reserves its public command IDs (`flow-auto`, `flow-plan`, `flow-run`,
+`flow-review`, `flow-status`) and internal worker IDs (`flow-reviewer`,
+`flow-evidence-worker`, `flow-validation-worker`, `flow-audit-worker`,
+`flow-candidate-worker`, `flow-verifier-worker`) while the plugin is enabled.
+The plugin injects those entries to keep command preflight and worker permission
+boundaries safe.
+
 `flow-test` and `flow-commit` are managed helper skills, not public commands in
 this release. `flow-commit` is user-triggered only and stays outside the
 autonomous Flow runtime loop.
@@ -160,6 +179,12 @@ The runtime owns only safety:
 - Non-final completion requires `validationScope: "targeted"`.
 - Final completion requires `validationScope: "broad"` and a passing final review matching the plan's `finalReviewPolicy`.
 - `flow_session_close` accepts `kind: "completed"` only after an approved plan has passed final completion.
+- Reset keeps prior history entries as audit/provenance data. Current state comes
+  from `features`, `activeFeature`, `status`, `progress`, and `closure`, not from
+  old completion summaries.
+- Deferred and abandoned closures archive the session with its status at the time
+  of closure, clear the active session file, and remove the generated instruction
+  projection.
 
 Planning quality, decomposition, review depth, validation adequacy, orchestration, and recovery judgment live in the skills.
 
@@ -201,7 +226,7 @@ First remove `opencode-plugin-flow` from your OpenCode plugin config so future
 OpenCode startups stop loading Flow. Then remove Flow-owned synced skills:
 
 ```bash
-npx -y opencode-plugin-flow@4.1.11 uninstall
+npx -y opencode-plugin-flow@4.1.14 uninstall
 ```
 
 Restart OpenCode after both steps. This removes Flow-owned synced skills when

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

@@ -0,0 +1,3 @@
+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/logging.d.ts

@@ -0,0 +1,3 @@
+type FlowLogLevel = "info" | "warn" | "error";
+export declare function createFlowLog(ctx: unknown): (level: FlowLogLevel, message: string) => void;
+export {};

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

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

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

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

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

@@ -0,0 +1,211 @@
+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";
+                    }>>;
+                    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;
+                    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>;
+        };
+        execute(args: {
+            featureId?: string | 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";
+            }>>;
+            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>]>>;
+        };
+        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;
+            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;
+        }, 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/cli.d.ts

@@ -0,0 +1 @@
+export {};