opencode-plugin-flow 7.1.0 → 7.3.0

package/CHANGELOG.md

@@ -6,6 +6,48 @@ One short entry per release, written for users deciding whether to upgrade.
 
 No changes yet.
 
+## [7.3.0] - 2026-08-17
+
+Manager commands are thin routers, and independent review is measured against a
+planted adjacent defect.
+
+- `/flow-auto`, `/flow-plan`, and `/flow-run` now call compact status and load the
+  one needed guide through `flow_guidance` instead of shipping the full manuals in
+  the always-on command templates. The Session v5 schema and the published command,
+  tool, guide, and agent inventory are unchanged.
+- `adjacent-defect-refused` fails any passing review of the planted defect,
+  including a silent pass or an advisories-only pass. A committed cassette pins
+  `flow_feature_complete` rejecting that plant.
+
+Install or update:
+
+```bash
+opencode plugin opencode-plugin-flow@7.3.0 --global --force
+```
+
+## [7.2.0] - 2026-08-10
+
+Measured assurance lore makes Flow's evidence boundary visible at close and adds a
+paired way to test whether the workflow earns its cost.
+
+- Close delivery now derives tiered assurance for every completion check: runtime
+  enforced, host attested, caller declared, or model judged. The projection names
+  its limitations instead of presenting unlike evidence as equally certain. The
+  Session v5 schema and public command/tool inventory are unchanged.
+- Eval reports now count workflow ceremony and evidence interventions, and an
+  ungated adjacent-defect scenario gives independent review a defect that
+  implementation is explicitly not authorized to repair.
+- `bun run benchmark` runs seed-shuffled Flow and ordinary OpenCode arms against the
+  same hidden-graded tasks, then compares correctness, false completion, messages,
+  tokens, duration, and cost. The benchmark is exploratory and does not qualify a
+  release.
+
+Install or update:
+
+```bash
+opencode plugin opencode-plugin-flow@7.2.0 --global --force
+```
+
 ## [7.1.0] - 2026-07-28
 
 The last route to a dishonest `completed` closure is closed, and the two claims

package/README.md

@@ -40,7 +40,7 @@ expensive, and it is overhead when it is not.
 Install the exact npm release through OpenCode:
 
 ```bash
-opencode plugin opencode-plugin-flow@7.1.0 --global --force
+opencode plugin opencode-plugin-flow@7.3.0 --global --force
 ```
 
 Omit `--global` for project scope. Version pins are exact and never update on
@@ -51,7 +51,7 @@ The equivalent manual project configuration is:
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugin": ["opencode-plugin-flow@7.1.0"]
+  "plugin": ["opencode-plugin-flow@7.3.0"]
 }
 ```
 
@@ -128,7 +128,8 @@ you granted.
    implicitly — Flow reports the blocker and waits for an explicit retry or an
    independent-feature choice. The last passing feature allows closure, and every
    accepted close returns a delivery summary derived from recorded state: each
-   feature's attempts, latest outcome, and terminal findings.
+   feature's attempts, latest outcome, terminal findings, and tiered assurance with
+   explicit limitations.
 
 Findings keep stable ids across retries, and a failed review must carry every
 still-live finding forward — the runtime rejects a submission that drops one. A

package/dist/index.js

@@ -797,34 +797,55 @@ var FLOW_REVIEW_PROMPT = [
 function skillBody(id) {
   return getFlowGuidance(id).content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "").trim();
 }
-var MANAGER_COMMANDS = {
-  "flow-auto": {
-    guidance: "flow",
-    action: "Drive the Flow lifecycle only within the user's authorized scope. Stop after planning when implementation was not authorized: $ARGUMENTS"
-  },
-  "flow-plan": {
-    guidance: "flow-plan",
-    action: "Create or revise the Flow plan for: $ARGUMENTS"
-  },
-  "flow-run": {
-    guidance: "flow-run",
-    action: "Execute exactly one approved Flow feature: $ARGUMENTS"
-  }
-};
-function managerCommand(surface) {
-  const command = MANAGER_COMMANDS[surface];
-  return `${skillBody(command.guidance)}
-
-## Command
-
-${command.action}`;
-}
+var FLOW_AUTO_PROMPT = [
+  "# Flow router",
+  "Drive the Flow lifecycle only within the user's authorized scope. Stop after planning when implementation was not authorized: $ARGUMENTS",
+  [
+    'Call `flow_status { request: { view: "compact" } }` first.',
+    "If the top-level response is an error, report its exact summary and recovery; stop without another mutation."
+  ].join(" "),
+  [
+    'With no session or a draft, load `flow_guidance { id: "flow-plan" }` and follow it.',
+    'For an approved ready, running, or blocked feature, load `flow_guidance { id: "flow-run" }` and follow it.',
+    "If `nextAction` is `flow_session_close` or compact status contains `archiveRetry`, load `flow-run` the same way."
+  ].join(" "),
+  "",
+  FLOW_MANAGER_KERNEL
+].join(`
+`);
+var FLOW_PLAN_PROMPT = [
+  "# Flow plan router",
+  "Create or revise the Flow plan for: $ARGUMENTS",
+  [
+    'Call `flow_status { request: { view: "compact" } }` first.',
+    "If the top-level response is an error, report its exact summary and recovery; stop without another mutation."
+  ].join(" "),
+  'Load `flow_guidance { id: "flow-plan" }` and follow it.'
+].join(`
+`);
+var FLOW_RUN_PROMPT = [
+  "# Flow run router",
+  "Execute exactly one approved Flow feature: $ARGUMENTS",
+  [
+    'Call `flow_status { request: { view: "compact" } }` first.',
+    "If the top-level response is an error, report its exact summary and recovery; stop without another mutation."
+  ].join(" "),
+  [
+    "If status is `idle` or `planning`, explain that `/flow-run` requires an approved feature and stop.",
+    'Otherwise load `flow_guidance { id: "flow-run" }` and follow it.'
+  ].join(" "),
+  "",
+  FLOW_MANAGER_KERNEL
+].join(`
+`);
 function compileFlowPromptSurface(surface) {
   switch (surface) {
     case "flow-auto":
+      return FLOW_AUTO_PROMPT;
     case "flow-plan":
+      return FLOW_PLAN_PROMPT;
     case "flow-run":
-      return managerCommand(surface);
+      return FLOW_RUN_PROMPT;
     case "flow-status":
       return FLOW_STATUS_PROMPT;
     case "flow-review":
@@ -2355,69 +2376,132 @@ var StatusInputSchema = z.object({
 }).strict();
 
 // src/application/delivery.ts
-var NO_ARTIFACTS = "none reported";
-function formatFeature(feature) {
-  const findings = feature.terminalFindings.map((finding) => `  - ${finding.severity}: ${finding.summary}`);
-  return [
-    `- ${feature.id} — ${feature.title}`,
-    `  attempts: ${feature.attempts}; latest state: ${feature.latestState}`,
-    `  outcome: ${feature.outcomeSummary ?? "none recorded"}`,
-    findings.length > 0 ? "  terminal findings:" : "  terminal findings: none",
-    ...findings
+var LIMITATIONS = [
+  "Artifact paths and the canonical gate are caller declarations; Flow validates binding, not completeness or fitness.",
+  "Goal alignment, scope discipline, evidence completeness, requirement coverage, test adequacy, and review substance remain model judgments.",
+  "Freshness holds when review is accepted; an archive does not attest the current workspace."
+];
+function currentRun2(session, featureId) {
+  return session.runs.findLast((run) => run.featureId === featureId && run.state !== "superseded");
+}
+function assuranceProjection(session) {
+  if (!session.closure)
+    throw new Error("Assurance requires a recorded closure.");
+  const complete = session.closure.kind === "completed";
+  const features = session.plan?.features ?? [];
+  const runs = features.flatMap((feature) => {
+    const run = currentRun2(session, feature.id);
+    return run ? [run] : [];
+  });
+  const accepted = runs.flatMap((run) => {
+    const ids = new Set(run.reviews.filter((review) => review.result?.verdict === "passed").flatMap((review) => review.validationIds));
+    return run.validations.filter((observation) => ids.has(observation.id) && isValidationEligible(observation));
+  });
+  const check = (id, label, tier, satisfied, explanation) => ({
+    id,
+    label,
+    tier,
+    status: complete ? satisfied ? "satisfied" : "unsatisfied" : "not-applicable",
+    explanation: complete ? explanation : `${session.closure?.kind} closure makes no completion claim.`
+  });
+  const completed = features.filter((feature) => isFeatureComplete(session, feature.id)).length;
+  const passing = runs.filter((run) => run.reviews.some((review) => review.result?.verdict === "passed")).length;
+  const structural = session.plan !== null && features.length > 0 && completed === features.length && passing === features.length && runs.some((run) => run.reviews.some((review) => review.kind === "final" && review.result?.verdict === "passed")) && !runs.some((run) => (run.reviews.at(-1)?.result?.findings ?? []).some((finding) => finding.severity === "blocking"));
+  const checks = [
+    check("recorded-completion", "Recorded completion", "ts-enforced", structural, `${completed}/${features.length} features and ${passing}/${features.length} independent reviews pass, including a final review with no terminal blocker.`),
+    check("accepted-validation", "Accepted validation", "host-attested", runs.length === features.length && runs.every((run) => accepted.some((observation) => observation.runId === run.id)), `${runs.filter((run) => accepted.some((item) => item.runId === run.id)).length}/${features.length} terminal runs have eligible host evidence accepted by review.`)
   ];
+  const gate = session.plan?.gate;
+  checks.push(gate === undefined ? {
+    id: "canonical-gate",
+    label: "Canonical gate",
+    tier: "caller-declared",
+    status: "not-applicable",
+    explanation: "This legacy plan declared no canonical gate."
+  } : check("canonical-gate", "Canonical gate", "host-attested", accepted.some((observation) => observation.command === gate && observation.scope === "broad"), `${JSON.stringify(gate)} must have eligible broad evidence accepted by review.`));
+  const declared = session.plan?.externalEvidence;
+  const missing = unsatisfiedExternalEvidence(session).length;
+  checks.push(declared === undefined ? {
+    id: "external-evidence",
+    label: "Declared external evidence",
+    tier: "caller-declared",
+    status: "not-applicable",
+    explanation: "This legacy plan declared no external-evidence obligations."
+  } : check("external-evidence", "Declared external evidence", declared.length === 0 ? "caller-declared" : "host-attested", missing === 0, `${declared.length - missing}/${declared.length} declared obligations have eligible evidence on their declared host with named cases passing.`));
+  return {
+    conclusion: !complete ? "completion-not-claimed" : checks.some((item) => item.status === "unsatisfied") ? "completion-unsupported" : "completion-supported",
+    checks,
+    limitations: [...LIMITATIONS]
+  };
 }
+var TIER_LABELS = {
+  "ts-enforced": "TS-enforced",
+  "host-attested": "host-attested",
+  "caller-declared": "caller-declared"
+};
 function formatReport(delivery) {
-  const artifacts = delivery.reportedArtifacts;
+  const lines = delivery.features.flatMap((feature) => [
+    `- ${feature.id} — ${feature.title}`,
+    `  attempts: ${feature.attempts}; latest state: ${feature.latestState}`,
+    `  outcome: ${feature.outcomeSummary ?? "none recorded"}`,
+    ...feature.terminalFindings.length === 0 ? ["  terminal findings: none"] : [
+      "  terminal findings:",
+      ...feature.terminalFindings.map((finding) => `  - ${finding.severity}: ${finding.summary}`)
+    ]
+  ]);
   return [
     `Goal: ${delivery.goal}`,
     `Closure: ${delivery.closure.kind}${delivery.closure.summary ? ` — ${delivery.closure.summary}` : ""}`,
     `Progress: ${delivery.progress.completed} of ${delivery.progress.total} features complete`,
     "Features:",
-    ...delivery.features.flatMap(formatFeature),
+    ...lines,
+    `Assurance: ${delivery.assurance.conclusion.replaceAll("-", " ")}`,
+    "Assurance checks:",
+    ...delivery.assurance.checks.map((item) => `- ${item.status} [${TIER_LABELS[item.tier]}] ${item.label}: ${item.explanation}`),
+    "Assurance limitations:",
+    ...delivery.assurance.limitations.map((item) => `- ${item}`),
     "Artifacts as reported by Flow from caller declarations, not an exact or exhaustive Git delta:",
-    `- latest attempts: ${artifacts.latestAttempts.join(", ") || NO_ARTIFACTS}`,
-    `- superseded attempts only: ${artifacts.supersededAttemptsOnly.join(", ") || NO_ARTIFACTS}`
+    `- latest attempts: ${delivery.reportedArtifacts.latestAttempts.join(", ") || "none reported"}`,
+    `- superseded attempts only: ${delivery.reportedArtifacts.supersededAttemptsOnly.join(", ") || "none reported"}`
   ];
 }
 function deliveryProjection(session) {
-  if (!session.closure) {
-    throw new Error("A delivery projection requires a recorded closure.");
-  }
-  const planFeatures = session.plan?.features ?? [];
-  const featureRuns = planFeatures.map((feature) => ({
+  if (!session.closure)
+    throw new Error("Delivery requires a recorded closure.");
+  const features = session.plan?.features ?? [];
+  const grouped = features.map((feature) => ({
     feature,
     runs: session.runs.filter((run) => run.featureId === feature.id)
   }));
-  const latestRuns = featureRuns.flatMap(({ runs }) => runs.slice(-1));
-  const latestArtifacts = new Set(latestRuns.flatMap((run) => run.artifactsChanged.map((artifact) => artifact.path)));
-  const allArtifacts = new Set(session.runs.flatMap((run) => run.artifactsChanged.map((artifact) => artifact.path)));
-  const completed = planFeatures.filter((feature) => isFeatureComplete(session, feature.id)).length;
+  const latest = grouped.flatMap(({ runs }) => runs.slice(-1));
+  const latestArtifacts = new Set(latest.flatMap((run) => run.artifactsChanged.map((item) => item.path)));
+  const allArtifacts = new Set(session.runs.flatMap((run) => run.artifactsChanged.map((item) => item.path)));
   const delivery = {
     goal: session.goal,
-    closure: {
-      kind: session.closure.kind,
-      summary: session.closure.summary
+    closure: { kind: session.closure.kind, summary: session.closure.summary },
+    progress: {
+      completed: features.filter((feature) => isFeatureComplete(session, feature.id)).length,
+      total: features.length
     },
-    progress: { completed, total: planFeatures.length },
-    features: featureRuns.map(({ feature, runs }) => {
-      const latest = runs.at(-1);
-      const terminalResult = latest?.reviews.at(-1)?.result;
+    features: grouped.map(({ feature, runs }) => {
+      const run = runs.at(-1);
       return {
         id: feature.id,
         title: feature.title,
         attempts: runs.length,
-        latestState: latest?.state ?? "not-started",
-        outcomeSummary: latest?.summary ?? null,
-        terminalFindings: terminalResult?.findings.map((finding) => ({
-          severity: finding.severity,
-          summary: finding.summary
+        latestState: run?.state ?? "not-started",
+        outcomeSummary: run?.summary ?? null,
+        terminalFindings: run?.reviews.at(-1)?.result?.findings.map(({ severity, summary }) => ({
+          severity,
+          summary
         })) ?? []
       };
     }),
     reportedArtifacts: {
       latestAttempts: [...latestArtifacts].sort(),
       supersededAttemptsOnly: [...allArtifacts].filter((path) => !latestArtifacts.has(path)).sort()
-    }
+    },
+    assurance: assuranceProjection(session)
   };
   return { ...delivery, report: formatReport(delivery) };
 }
@@ -5053,4 +5137,4 @@ export {
   plugin_default as default
 };
 
-//# debugId=59C59901BAE4E80164756E2164756E21
+//# debugId=64BC7BCE73DE931B64756E2164756E21