opencode-plugin-flow 4.3.8 → 4.4.0

package/dist/prompt-baseline-fixtures.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Frozen historical prompt assembly used only for comparative evaluation.
+ *
+ * These strings capture the pre-compiler public startup and hidden-worker
+ * prompts. They are not production prompt sources and must never be selected by
+ * the default compiled Flow surfaces. Keep the exception explicit so manual
+ * baseline text cannot be mistaken for a maintained projection of skill rules.
+ */
+export declare const LEGACY_PROMPT_BASELINE: Readonly<{
+    publicCommandPreflight: string;
+    workerPrompts: Readonly<{
+        "flow-evidence-worker": "Use Flow evidence mode. Inspect only the assigned slice, do not edit files, do not call state-changing Flow tools, and return coverage, evidence inspected, confidence-tagged findings or facts, gaps, and manager follow-ups. Return only the assigned Flow handoff. Cite or drop every claim, label single-source, inferred, and unsettled claims, and report blocked if the assigned scope, expected coverage, or handoff shape is missing. Empty or unstructured output is a failed handoff; return blocked with the missing elements instead.";
+        "flow-validation-worker": "Use Flow validation mode. Run only manager-specified commands or propose focused checks, do not edit files, do not call state-changing Flow tools, and report exact command, status, raw outcome summary, coverage, confidence, gaps, and manager follow-ups. Return only the assigned Flow handoff. Cite or drop every claim, label single-source, inferred, and unsettled claims, and report blocked if the assigned scope, expected coverage, or handoff shape is missing. Empty or unstructured output is a failed handoff; return blocked with the missing elements instead.";
+        "flow-audit-worker": "Use Flow audit mode. Inspect only the assigned slice, actively refute candidate findings before reporting them, do not edit files, do not call state-changing Flow tools, and return coverage, evidence, guards checked, confidence, gaps, and manager follow-ups. Return only the assigned Flow handoff. Cite or drop every claim, label single-source, inferred, and unsettled claims, and report blocked if the assigned scope, expected coverage, or handoff shape is missing. Empty or unstructured output is a failed handoff; return blocked with the missing elements instead.";
+        "flow-candidate-worker": "Use Flow candidate-implementation mode only when the manager assigned an isolated worktree or exact non-overlapping path ownership. Do not edit .flow/**, do not call state-changing Flow tools, do not complete Flow state, and return changed or proposed patch, verification run, coverage, confidence, merge risks, and manager follow-ups. Return only the assigned Flow handoff. Cite or drop every claim, label single-source, inferred, and unsettled claims, and report blocked if the assigned scope, expected coverage, or handoff shape is missing. Empty or unstructured output is a failed handoff; return blocked with the missing elements instead.";
+        "flow-verifier-worker": "Use Flow verifier mode. Verify only the assigned claims against the provided sources, commands, counts, or current docs. Do not generate new scope, do not edit files, do not call state-changing Flow tools, and return supported, partly-supported, unsupported, or source-not-found per claim with evidence, confidence, gaps, and manager follow-ups. Return only the assigned Flow handoff. Cite or drop every claim, label single-source, inferred, and unsettled claims, and report blocked if the assigned scope, expected coverage, or handoff shape is missing. Empty or unstructured output is a failed handoff; return blocked with the missing elements instead.";
+    }>;
+    reviewerSections: readonly string[];
+}>;

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

@@ -0,0 +1,99 @@
+import { z } from "zod";
+import { type FlowPromptVariant } from "./prompt-surfaces";
+declare const ModelDecisionSchema: z.ZodObject<{
+    id: z.ZodString;
+    route: z.ZodEnum<{
+        "flow-plan": "flow-plan";
+        "flow-run": "flow-run";
+        "flow-review": "flow-review";
+        "flow-evidence-worker": "flow-evidence-worker";
+        "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";
+    }>;
+    workers: z.ZodArray<z.ZodString>;
+    stateOwner: z.ZodEnum<{
+        "root-manager": "root-manager";
+        worker: "worker";
+    }>;
+    callsStatusFirst: z.ZodBoolean;
+    planOnly: z.ZodBoolean;
+    reviewFirst: z.ZodBoolean;
+    validation: z.ZodArray<z.ZodEnum<{
+        broad: "broad";
+        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";
+    }>;
+    manifestComplete: z.ZodBoolean;
+    coverage: z.ZodEnum<{
+        missing: "missing";
+        partial: "partial";
+        not_applicable: "not_applicable";
+        complete: "complete";
+    }>;
+    handoffStatus: z.ZodEnum<{
+        blocked: "blocked";
+        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";
+    }>;
+    completionClaimed: z.ZodBoolean;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export type ModelDecision = z.infer<typeof ModelDecisionSchema>;
+export type ModelEvaluationGrade = {
+    passedScenarios: number;
+    totalScenarios: number;
+    passedCriteria: number;
+    totalCriteria: number;
+    scenarios: Array<{
+        id: string;
+        passed: boolean;
+        passedCriteria: number;
+        totalCriteria: number;
+        failures: string[];
+    }>;
+};
+export declare function buildPromptModelEvaluationPacket(variant: FlowPromptVariant): string;
+export declare function parseModelDecisionResponse(text: string): ModelDecision[];
+export declare function gradeModelDecisions(decisions: readonly ModelDecision[]): ModelEvaluationGrade;
+export {};

package/dist/prompt-quality.d.ts

@@ -0,0 +1,73 @@
+import { type CompiledFlowPrompt, type FlowPromptSurfaceName, type FlowPromptVariant } from "./prompt-surfaces";
+export type PromptMetric = {
+    surface: string;
+    variant: FlowPromptVariant | "runtime";
+    sources: string[];
+    characters: number;
+    words: number;
+    approximateTokens: number;
+    actionableInstructions: number;
+    exactDuplicateLines: number;
+    repeatedFiveGrams: number;
+    nearDuplicateLinePairs: number;
+    negativeInstructions: number;
+    negativeInstructionDensity: number;
+    codeFences: number;
+    conditionalFragments: string[];
+    roleInapplicableFragments: string[];
+    roleInapplicableLines: number;
+    criticalRulePositions: Record<string, number | null>;
+    structurallyEnforcedRulesPresent: string[];
+    terminologyWarnings: string[];
+};
+export type PromptEvaluationResult = {
+    variant: FlowPromptVariant;
+    scenariosPassed: number;
+    scenariosTotal: number;
+    criteriaPassed: number;
+    criteriaTotal: number;
+    staticApproximateTokens: number;
+    roleInapplicableLines: number;
+    exactDuplicateLines: number;
+    scenarios: Array<{
+        id: string;
+        name: string;
+        passed: boolean;
+        passedCriteria: number;
+        totalCriteria: number;
+        failures: string[];
+    }>;
+};
+export type PromptRepetitionClassification = {
+    id: string;
+    classification: "keep" | "consolidate" | "enforce-structurally" | "load-conditionally" | "remove" | "evaluate";
+    occurrences: string[];
+    rationale: string;
+};
+export declare function measurePromptText(options: {
+    surface: string;
+    variant: FlowPromptVariant | "runtime";
+    text: string;
+    compiled?: CompiledFlowPrompt;
+}): PromptMetric;
+export declare function measureCompiledPrompt(compiled: CompiledFlowPrompt): PromptMetric;
+type PromptScenario = {
+    id: string;
+    name: string;
+    input: string;
+    expectedRoute: FlowPromptSurfaceName;
+    surface: FlowPromptSurfaceName;
+    required: Array<{
+        label: string;
+        pattern: RegExp;
+    }>;
+    forbidden?: Array<{
+        label: string;
+        pattern: RegExp;
+    }>;
+};
+export declare const PROMPT_EVALUATION_SCENARIOS: readonly PromptScenario[];
+export declare function evaluatePromptVariant(variant: FlowPromptVariant): PromptEvaluationResult;
+export declare const PROMPT_REPETITION_CLASSIFICATIONS: readonly PromptRepetitionClassification[];
+export declare function promptInventoryForVariant(variant: FlowPromptVariant): PromptMetric[];
+export {};

package/dist/prompt-surfaces.d.ts

@@ -0,0 +1,28 @@
+export type FlowPromptVariant = "baseline" | "lexically-deduplicated" | "surface-specific" | "surface-specific-bookended";
+export type FlowPromptSurfaceName = "flow-auto" | "flow-plan" | "flow-run" | "flow-review" | "flow-status" | "flow-reviewer" | "flow-evidence-worker" | "flow-validation-worker" | "flow-audit-worker" | "flow-candidate-worker" | "flow-verifier-worker";
+export type FlowPromptRole = "manager" | "reviewer" | "evidence-worker" | "validation-worker" | "audit-worker" | "candidate-worker" | "verifier-worker";
+export type FlowPromptFragmentKind = "purpose" | "invariant" | "procedure" | "reference" | "schema" | "checkpoint";
+export type FlowPromptFragment = {
+    id: string;
+    source: string;
+    origin: "skill-source" | "compiler";
+    kind: FlowPromptFragmentKind;
+    text: string;
+    roles: readonly FlowPromptRole[];
+    conditional?: boolean;
+};
+export type CompiledFlowPrompt = {
+    surface: FlowPromptSurfaceName;
+    variant: FlowPromptVariant;
+    role: FlowPromptRole;
+    text: string;
+    fragments: readonly FlowPromptFragment[];
+};
+export type FlowWorkerHandoffKind = "evidence" | "validation" | "audit" | "review-slice" | "verifier" | "candidate";
+export declare function compileFlowPromptSurface(surface: FlowPromptSurfaceName, variant?: FlowPromptVariant): CompiledFlowPrompt;
+export declare const FLOW_STATIC_PROMPT_SURFACES: readonly FlowPromptSurfaceName[];
+export declare function compiledFlowPromptSurfaces(variant?: FlowPromptVariant): Record<FlowPromptSurfaceName, CompiledFlowPrompt>;
+export declare function validateFlowWorkerHandoff(kind: FlowWorkerHandoffKind, text: string): {
+    ok: boolean;
+    errors: string[];
+};

package/dist/runtime/api.d.ts

@@ -127,29 +127,47 @@ export declare const FlowFeatureCompleteToolSchema: z.ZodObject<{
     orchestrationPasses: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         kind: z.ZodEnum<{
-            discovery: "discovery";
+            validation: "validation";
             audit: "audit";
+            candidate: "candidate";
+            discovery: "discovery";
             review: "review";
-            validation: "validation";
             verification: "verification";
-            candidate: "candidate";
             "implementation-decision": "implementation-decision";
         }>;
         decision: z.ZodOptional<z.ZodEnum<{
-            serial: "serial";
             parallel: "parallel";
+            serial: "serial";
             "candidate-exact-path": "candidate-exact-path";
             "candidate-worktree": "candidate-worktree";
             tournament: "tournament";
             skipped: "skipped";
         }>>;
         decisionReason: z.ZodOptional<z.ZodString>;
+        candidateEligibility: z.ZodDefault<z.ZodEnum<{
+            eligible: "eligible";
+            not_eligible: "not_eligible";
+            unknown: "unknown";
+        }>>;
+        candidateDecision: z.ZodOptional<z.ZodEnum<{
+            skipped: "skipped";
+            used: "used";
+            serial_required: "serial_required";
+        }>>;
+        decisionFactors: z.ZodDefault<z.ZodArray<z.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: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            audit: "audit";
-            review: "review";
-            validation: "validation";
             evidence: "evidence";
+            validation: "validation";
+            audit: "audit";
             verifier: "verifier";
+            review: "review";
             "candidate-implementation": "candidate-implementation";
         }>>>;
         workerCount: z.ZodDefault<z.ZodNumber>;
@@ -175,6 +193,7 @@ export declare const FlowFeatureCompleteToolSchema: z.ZodObject<{
         }>>;
         outcome: z.ZodDefault<z.ZodEnum<{
             accepted: "accepted";
+            modified: "modified";
             rejected: "rejected";
             partial: "partial";
             "not-covered": "not-covered";