opencode-plugin-flow 4.3.7 → 4.3.9

package/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 One short entry per release, written for users deciding whether to upgrade.
 
+## [4.3.9] - 2026-07-08
+
+Candidate accounting coherence lore makes the 4.3.8 orchestration accounting
+rules self-consistent, so valid manager records stop bouncing off the schema:
+
+- `decision: "parallel"` on implementation-decision records is now rejected
+  with one clear message (it stays valid for discovery, audit, and review
+  passes); previously every `candidateDecision` pairing produced contradictory
+  errors.
+- Candidate-shaped decisions now require candidate execution evidence on every
+  pass kind, so a decision label alone can no longer validate while being
+  excluded from `candidatePassCount`.
+- Candidate and verifier worker counts are checked per subtype instead of
+  summed, so one worker may fill both roles on a single pass row.
+- Orchestration pass dedup now remembers every recorded pass id in
+  `recordedPassIds`, so resubmitted completions no longer double-count
+  telemetry after the recent-pass window rolls over.
+- The candidate accounting rules are documented once, in
+  `skills/flow/references/parallel-orchestration.md`; the run skill, handoff
+  format, and wiki point there instead of restating them, and the two doc
+  instructions that contradicted the schema (omitted `decision` on decision
+  records, `workerCount=0` with positive `candidateWorkerCount`) are fixed.
+
+## [4.3.8] - 2026-07-08
+
+Parallel orchestration accounting lore makes broad worker use visible without
+turning Flow state into a transcript store:
+
+- `flow_feature_complete` can now record compact `orchestrationPasses` for
+  serial, skipped, exact-path candidate, isolated-worktree, tournament,
+  validation, review, and verifier passes.
+- `flow_status` reports aggregate pass telemetry under
+  `session.budget.orchestration`, including worker counts, candidate/verifier
+  usage, skipped candidate decisions, and recent pass records.
+- Completion now records orchestration telemetry on success, validation-gate
+  failures, failed reviews, and `needs_input`, while deduping retry payloads and
+  retaining only the latest compact pass records.
+- Flow planning and running guidance now requires explicit implementation pass
+  decisions for broad work and keeps full handoffs, logs, and manager scratch
+  artifacts outside `.flow/**`.
+- README runtime wording now matches the 4.3.6 behavior: completed feature
+  counts are telemetry only, not a three-feature stop.
+
 ## [4.3.7] - 2026-07-08
 
 Package-smoke patience lore keeps the 4.3.6 release path portable across slower

package/README.md

@@ -17,8 +17,8 @@ Full project documentation is available in the
 ## Quick start
 
 ```bash
-opencode plugin opencode-plugin-flow@4.3.7 --global --force
-npx -y opencode-plugin-flow@4.3.7 sync
+opencode plugin opencode-plugin-flow@4.3.9 --global --force
+npx -y opencode-plugin-flow@4.3.9 sync
 ```
 
 Restart OpenCode, then give Flow a goal:
@@ -112,9 +112,10 @@ The runtime owns only safety; judgment lives in the skills:
   that is shallower than the approved feature requires.
 - Failed reviews are bounded: a failed review pauses by default, and autonomous
   repair is limited to one repair plus one retry before the feature blocks.
-- Long sessions hit phase boundaries after a small number of completed
-  features. Flow returns a compact resume packet and requires explicit
-  `phaseBoundaryAck` before starting the next feature.
+- Completed feature counts are telemetry only; Flow does not stop an approved
+  plan just because several features have completed. Review retry boundaries
+  still return a compact resume packet and require explicit `phaseBoundaryAck`
+  before starting the next feature.
 - A session can close as `completed` only after final completion has passed.
 - Crash recovery is built in: stale session locks expire automatically and
   unreadable session files are quarantined with recovery guidance, never
@@ -133,6 +134,13 @@ complete features, or close sessions. Flow reserves those agent ids and the
 public command ids while the plugin is enabled, and warns if they collide with
 your own config.
 
+For broad implementation, the manager records whether work stayed serial,
+used exact-path candidate workers, used isolated worktrees, ran a tournament, or
+skipped eligible candidates. Feature completion can carry compact
+`orchestrationPasses` with candidate eligibility, decision, and structured
+factors; `flow_status` reports the aggregate under
+`session.budget.orchestration`.
+
 ## Install details, doctor, repair, uninstall
 
 See [docs/troubleshooting.md](docs/troubleshooting.md) for skill sync
@@ -143,7 +151,7 @@ To update a pinned Flow version, rerun the install command with the new
 version. To inspect skill health:
 
 ```bash
-npx -y opencode-plugin-flow@4.3.7 doctor
+npx -y opencode-plugin-flow@4.3.9 doctor
 ```
 
 ## Experimental: compaction context

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

@@ -155,6 +155,83 @@ export declare function createTools(ctx: unknown): {
                 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<{
+                    discovery: "discovery";
+                    audit: "audit";
+                    review: "review";
+                    validation: "validation";
+                    verification: "verification";
+                    candidate: "candidate";
+                    "implementation-decision": "implementation-decision";
+                }>;
+                decision: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    serial: "serial";
+                    parallel: "parallel";
+                    "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<{
+                    audit: "audit";
+                    review: "review";
+                    validation: "validation";
+                    evidence: "evidence";
+                    verifier: "verifier";
+                    "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";
@@ -196,6 +273,26 @@ export declare function createTools(ctx: unknown): {
                 summary: string;
                 resolutionHint?: string | undefined;
             } | undefined;
+            orchestrationPasses?: {
+                id: string;
+                kind: "discovery" | "audit" | "review" | "validation" | "verification" | "candidate" | "implementation-decision";
+                candidateEligibility: "eligible" | "not_eligible" | "unknown";
+                decisionFactors: ("shared_state" | "overlapping_files" | "small_slice" | "needs_manager_judgment" | "independent_surface" | "validation_available")[];
+                modes: ("audit" | "review" | "validation" | "evidence" | "verifier" | "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?: "serial" | "parallel" | "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: {