opencode-plugin-flow 6.9.0 → 7.0.1

package/dist/index.js

@@ -56,7 +56,8 @@ never silently fall back.
    refreshed projection. This cleanup precedes goal alignment and grants no work.
    Before another manager mutation, align the compact-projected goal with the
    request. Continue only for the same goal or a narrowing that preserves every
-   outcome. Close a completed session as completed before new work. If the user
+   outcome; authority the request adds over those same outcomes is continuation,
+   not expansion. Close a completed session as completed before new work. If the user
    explicitly chooses deferred or abandoned closure for a non-completed session,
    call \`flow_session_close\` with compact session id/revision, fresh operation
    id, that kind, and optional summary; handle **Recovery**, follow a projected
@@ -546,9 +547,9 @@ checks from the changed behavior and risk:
   sufficient alone only for genuinely mechanical or documentation-only work.
 - UI claims need visual inspection when a runnable target is available.
 - Cleanup claims need behavior-preservation evidence, not formatting alone.
-- \`scope: "broad"\` is a claim about coverage, not a stronger label. Use it only
-  for the repository's canonical applicable gate or a justified equivalent
-  that covers the delivered repository state.
+- \`scope: "broad"\` is a coverage claim, not a stronger label. Use it only for the
+  repository's canonical applicable gate or a justified equivalent covering the
+  delivered repository state.
 
 Immediately before each evidence Bash command, call \`flow_validation_start\`
 with current revision, feature id, exact command, and \`scope\` (\`focused\` or
@@ -561,11 +562,13 @@ A failed, incomplete, or source-drifted exact plan-listed observation creates a
 freshness boundary. Before new review admission, that gate needs a complete
 exit-zero observation for current source recorded after its latest relevant
 failure or drift; returning to an older digest does not revive an earlier pass,
-and substitute broad validation cannot discharge it. If that gate cannot pass,
-the normal completed path remains unavailable; fix the gate or ask the user to
-choose deferred or abandoned closure. Plan-listed validation prose that has never
-run as an exact command remains reviewer judgment, not a fabricated pass or
-failure.
+and substitute broad validation cannot discharge it. Plan-listed validation prose
+that has never run as an exact command remains reviewer judgment, not a fabricated
+pass or failure.
+
+A gate that cannot pass withholds completed closure, and reporting the blocker is
+half the move. Fix the gate, or ask the user to choose deferred or abandoned
+closure. Ending the turn having done neither leaves the workflow with no next step.
 
 Every host-observed validation advances the session revision, so the revision
 that armed a completed command is stale. The \`[flow-validation]\` marker reports
@@ -577,7 +580,7 @@ Use focused validation for ordinary features. For the final feature, run the
 repository's broad applicable gate after the last relevant edit. A source edit
 invalidates earlier applicability. Failed or unavailable checks are blockers,
 not passing evidence. If the canonical gate cannot run, explain why the chosen
-equivalent is broad enough; otherwise record the narrower evidence as focused.
+equivalent is broad enough.
 
 Immediately before review admission, reconcile the preflight inventory against
 the recorded current-source observations. Do not call \`flow_review_start\` while
@@ -653,13 +656,12 @@ stops. Under \`/flow-auto\`, return to its lifecycle loop.
 `;
 
 // src/guidance/ids.ts
-var FLOW_GUIDANCE_TOPICS = [
+var FLOW_GUIDANCE_IDS = [
   "flow",
   "flow-plan",
   "flow-run",
   "flow-review"
 ];
-var FLOW_GUIDANCE_IDS = FLOW_GUIDANCE_TOPICS;
 
 // src/guidance/catalog.ts
 var FLOW_MANAGER_KERNEL = [
@@ -696,12 +698,7 @@ ${FLOW_MANAGER_KERNEL}
 `,
   "flow-review": SKILL_default3
 };
-var FLOW_GUIDANCE_DOCUMENTS = FLOW_GUIDANCE_TOPICS.map((name) => ({
-  relativePath: "SKILL.md",
-  content: GUIDANCE_CONTENT[name],
-  id: name,
-  topic: name
-}));
+var FLOW_GUIDANCE_DOCUMENTS = FLOW_GUIDANCE_IDS.map((id) => ({ id, content: GUIDANCE_CONTENT[id] }));
 var FLOW_GUIDANCE_BY_ID = new Map(FLOW_GUIDANCE_DOCUMENTS.map((document) => [document.id, document]));
 function getFlowGuidance(id) {
   const document = FLOW_GUIDANCE_BY_ID.get(id);
@@ -709,9 +706,6 @@ function getFlowGuidance(id) {
     throw new Error(`Missing bundled Flow guidance '${id}'.`);
   return document;
 }
-if (FLOW_GUIDANCE_BY_ID.size !== FLOW_GUIDANCE_IDS.length) {
-  throw new Error("Bundled Flow guidance ids and documents are out of sync.");
-}
 
 // src/prompt-surfaces.ts
 var FLOW_WORKER_PROMPT = [
@@ -939,17 +933,11 @@ function createFlowCoreConfigEntries(options) {
         ...FLOW_CORE_AGENTS["flow-reviewer"],
         ...model ? { model } : {},
         ...steps ? { steps } : {},
-        permission: {
-          ...FLOW_CORE_AGENTS["flow-reviewer"].permission,
-          task: { "*": "deny" }
-        }
+        permission: structuredClone(FLOW_CORE_AGENTS["flow-reviewer"].permission)
       },
       "flow-worker": {
         ...FLOW_CORE_AGENTS["flow-worker"],
-        permission: {
-          ...FLOW_CORE_AGENTS["flow-worker"].permission,
-          task: { "*": "deny" }
-        }
+        permission: structuredClone(FLOW_CORE_AGENTS["flow-worker"].permission)
       }
     },
     command: Object.fromEntries(Object.entries(FLOW_CORE_COMMANDS).map(([name, value]) => [
@@ -1240,6 +1228,24 @@ var LONGEST_VALIDATION_INELIGIBLE_REASON = VALIDATION_INELIGIBLE_REASONS.reduce(
 function isValidationEligible(observation, sourceDigest) {
   return observation.ineligibleReason === undefined && observation.exitCode === 0 && observation.outputComplete && (sourceDigest === undefined || observation.sourceDigest === sourceDigest);
 }
+var NARROWING_FLAGS = new Set([
+  "-t",
+  "--test-name-pattern",
+  "--testNamePattern",
+  "-k",
+  "-run",
+  "--grep",
+  "--filter"
+]);
+function narrowingArguments(command) {
+  return command.split(/\s+/).slice(1).filter((token) => {
+    if (token.startsWith("-")) {
+      return NARROWING_FLAGS.has(token.split("=")[0] ?? token);
+    }
+    const file = token.split("/").pop() ?? "";
+    return /\.(?:test|spec)\./.test(file) || /_test\.[a-z]+$/.test(file) || /^test_.+\.py$/.test(file);
+  });
+}
 function recordValidation(session, input) {
   if (input.captureId.length < 1 || input.captureId.length > MAX_VALIDATION_ID_LENGTH) {
     throw new FlowTransitionError(`Validation capture id must contain 1-${MAX_VALIDATION_ID_LENGTH} characters.`);
@@ -1267,6 +1273,12 @@ function recordValidation(session, input) {
   if (run.validations.length >= MAX_VALIDATIONS_PER_RUN) {
     throw new FlowTransitionError(`A feature run may contain at most ${MAX_VALIDATIONS_PER_RUN} validation observations.`);
   }
+  if (input.scope === "broad") {
+    const narrowing = narrowingArguments(input.command);
+    if (narrowing.length > 0) {
+      throw new FlowTransitionError(`A broad observation cannot select which tests it runs (${narrowing.join(", ")}). Arm the repository's canonical gate, or record this command as focused.`);
+    }
+  }
   const revision = session.revision + 1;
   const observation = {
     id: input.captureId,
@@ -1298,15 +1310,13 @@ function recordValidation(session, input) {
 function isValidationFresh(session, run, observation) {
   return session.runs.filter((candidate) => candidate.featureId === run.featureId).flatMap((candidate) => candidate.validations).every((candidate) => candidate.command !== observation.command || isValidationEligible(candidate) || candidate.recordedRevision < observation.recordedRevision);
 }
-function unresolvedKnownFailedPlanCommands(session, run, sourceDigest) {
-  if (session.approval !== "approved")
-    return [];
-  const feature = session.plan?.features.find((candidate) => candidate.id === run.featureId);
-  if (!feature)
-    return [];
-  const validations = session.runs.filter((candidate) => candidate.featureId === run.featureId).flatMap((candidate) => candidate.validations);
-  const commands = [...new Set(feature.validation)];
-  return commands.filter((command) => validations.some((observation) => observation.command === command && !isValidationEligible(observation)) && !run.validations.some((observation) => observation.command === command && isValidationEligible(observation, sourceDigest) && isValidationFresh(session, run, observation)));
+function unresolvedVetoedCommands(session, run, sourceDigest) {
+  const planned = session.approval === "approved" ? session.plan?.features.find((candidate) => candidate.id === run.featureId)?.validation ?? [] : [];
+  const failed = session.runs.filter((candidate) => candidate.featureId === run.featureId).flatMap((candidate) => candidate.validations).filter((observation) => !isValidationEligible(observation));
+  const commands = [
+    ...new Set(failed.filter((observation) => observation.scope === "broad" || planned.includes(observation.command)).map((observation) => observation.command))
+  ];
+  return commands.filter((command) => !run.validations.some((observation) => observation.command === command && isValidationEligible(observation, sourceDigest) && isValidationFresh(session, run, observation)));
 }
 
 // src/domain/transitions.ts
@@ -1561,9 +1571,9 @@ function startReview(session, input, environment) {
   if (run.reviews.length > 0) {
     fail("Reset the feature before starting another full review.");
   }
-  const unresolved = unresolvedKnownFailedPlanCommands(session, run, input.sourceDigest);
+  const unresolved = unresolvedVetoedCommands(session, run, input.sourceDigest);
   if (unresolved.length > 0) {
-    fail(`Review requires passing exact planned commands for the current workspace content: ${unresolved.map((command) => JSON.stringify(command)).join(", ")}.`);
+    fail(`Review requires passing these exact commands for the current workspace content: ${unresolved.map((command) => JSON.stringify(command)).join(", ")}. A different command cannot discharge one that failed.`);
   }
   const kind = isFinalFeatureRun(session, run) ? "final" : "feature";
   const applicable = run.validations.filter((validation) => isValidationEligible(validation, input.sourceDigest) && isValidationFresh(session, run, validation));
@@ -1760,6 +1770,40 @@ function closeSession(session, input) {
     fail("Flow could not record the closure.");
   return { session: next, value: closure, replayed: false };
 }
+
+// src/application/errors.ts
+class UnreadableFlowSessionError extends Error {
+  code = "UNREADABLE_FLOW_SESSION";
+  reason;
+  constructor(message, reason) {
+    super(message);
+    this.name = "UnreadableFlowSessionError";
+    this.reason = reason;
+  }
+}
+
+class UnsupportedFlowSessionVersionError extends Error {
+  code = "UNSUPPORTED_FLOW_SESSION_VERSION";
+  actualVersion;
+  constructor(actualVersion) {
+    super("Flow v6 supports only Session v5 active state. Close active older sessions before upgrading; archived history remains inert.");
+    this.name = "UnsupportedFlowSessionVersionError";
+    this.actualVersion = actualVersion;
+  }
+}
+
+class ArchiveCollisionError extends Error {
+  code = "FLOW_ARCHIVE_COLLISION";
+  constructor(message) {
+    super(message);
+    this.name = "ArchiveCollisionError";
+  }
+}
+
+// src/application/schema.ts
+import { z } from "zod";
+
+// src/domain/session-invariants.ts
 function featurePassedBefore(session, featureId, revision) {
   return session.runs.some((run) => run.featureId === featureId && run.reviews.some((review) => review.result?.verdict === "passed" && review.result.recordedRevision < revision));
 }
@@ -1795,11 +1839,9 @@ function sessionInvariantIssues(session) {
       issues.push("Runs require a plan.");
     return issues;
   }
-  try {
-    assertPlan(session.plan);
-  } catch (error) {
-    issues.push(error instanceof Error ? error.message : String(error));
-  }
+  const planProblem = planIssue(session.plan);
+  if (planProblem)
+    issues.push(planProblem);
   const featureIds = new Set(session.plan.features.map((feature) => feature.id));
   const runIds = new Set;
   const validationIds = new Set;
@@ -1888,11 +1930,9 @@ function sessionInvariantIssues(session) {
         if (review.result.recordedRevision <= review.createdRevision || review.result.recordedRevision > session.revision) {
           issues.push(`Review '${review.id}' has an invalid result revision.`);
         }
-        try {
-          assertReviewResult(review.result);
-        } catch (error) {
-          issues.push(error instanceof Error ? error.message : String(error));
-        }
+        const resultProblem = review.result.findings.length > MAX_REVIEW_FINDINGS ? `A review may contain at most ${MAX_REVIEW_FINDINGS} findings.` : reviewResultSemanticIssues(review.result)[0]?.message;
+        if (resultProblem)
+          issues.push(resultProblem);
       }
     }
     const last = run.reviews.at(-1);
@@ -1921,37 +1961,7 @@ function sessionInvariantIssues(session) {
   return issues;
 }
 
-// src/application/errors.ts
-class UnreadableFlowSessionError extends Error {
-  code = "UNREADABLE_FLOW_SESSION";
-  reason;
-  constructor(message, reason) {
-    super(message);
-    this.name = "UnreadableFlowSessionError";
-    this.reason = reason;
-  }
-}
-
-class UnsupportedFlowSessionVersionError extends Error {
-  code = "UNSUPPORTED_FLOW_SESSION_VERSION";
-  actualVersion;
-  constructor(actualVersion) {
-    super("Flow v6 supports only Session v5 active state. Close active older sessions before upgrading; archived history remains inert.");
-    this.name = "UnsupportedFlowSessionVersionError";
-    this.actualVersion = actualVersion;
-  }
-}
-
-class ArchiveCollisionError extends Error {
-  code = "FLOW_ARCHIVE_COLLISION";
-  constructor(message) {
-    super(message);
-    this.name = "ArchiveCollisionError";
-  }
-}
-
 // src/application/schema.ts
-import { z } from "zod";
 var encoder = new TextEncoder;
 function boundedText(label, options) {
   const maxBytes = options?.maxBytes ?? MAX_TEXT_BYTES;
@@ -1960,6 +1970,7 @@ function boundedText(label, options) {
 var FeatureIdSchema = z.string().max(MAX_SESSION_ID_LENGTH).regex(FEATURE_ID_PATTERN, FEATURE_ID_MESSAGE);
 var OperationIdSchema = z.string().min(1).max(128).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/);
 var ReviewAssignmentIdSchema = z.string().min(1).max(256);
+var RunIdSchema = z.string().min(1).max(256);
 var RevisionSchema = z.number().int().safe().nonnegative();
 var SourceDigestSchema = z.custom((value) => typeof value === "string" && /^sha256:[a-f0-9]{64}$/.test(value), "Expected a sha256: content digest.");
 var PlanFeatureSchema = z.object({
@@ -2000,10 +2011,14 @@ var PublicReviewResultSchema = z.object({
     context.addIssue({ code: "custom", ...issue });
   }
 });
+var ReviewPacketSchema = z.object({
+  summary: boundedText("Review packet summary"),
+  riskLenses: z.array(boundedText("Review risk lens")).max(16).default([])
+}).strict();
 var ValidationObservationSchema = z.object({
   id: z.string().min(1).max(MAX_VALIDATION_ID_LENGTH),
   featureId: FeatureIdSchema,
-  runId: z.string().min(1).max(256),
+  runId: RunIdSchema,
   scope: z.enum(["focused", "broad"]),
   command: boundedText("Validation command"),
   sourceDigest: SourceDigestSchema,
@@ -2024,19 +2039,16 @@ var ReviewAssignmentSchema = z.object({
   id: ReviewAssignmentIdSchema,
   operationId: OperationIdSchema,
   featureId: FeatureIdSchema,
-  runId: z.string().min(1).max(256),
+  runId: RunIdSchema,
   kind: z.enum(["feature", "final"]),
   sourceDigest: SourceDigestSchema,
   validationIds: z.array(z.string().min(1).max(MAX_VALIDATION_ID_LENGTH)).min(1).max(MAX_VALIDATIONS_PER_RUN),
-  packet: z.object({
-    summary: boundedText("Review packet summary"),
-    riskLenses: z.array(boundedText("Review risk lens")).max(16).default([])
-  }).strict(),
+  packet: ReviewPacketSchema,
   createdRevision: RevisionSchema,
   result: PersistedReviewResultSchema.nullable()
 }).strict();
 var FeatureRunSchema = z.object({
-  id: z.string().min(1).max(256),
+  id: RunIdSchema,
   featureId: FeatureIdSchema,
   attempt: z.number().int().safe().positive(),
   state: z.enum(["active", "completed", "blocked", "superseded"]),
@@ -2109,10 +2121,7 @@ var ReviewStartInputSchema = z.object({
     ...guarded,
     featureId: FeatureIdSchema,
     artifactsChanged: z.array(ArtifactSchema).max(MAX_ARTIFACTS),
-    packet: z.object({
-      summary: boundedText("Review packet summary"),
-      riskLenses: z.array(boundedText("Review risk lens")).max(16).default([])
-    }).strict()
+    packet: ReviewPacketSchema
   }).strict()
 }).strict();
 var FeatureCompleteInputSchema = z.object({
@@ -2274,7 +2283,7 @@ function nextAction(session, pendingReviewSourceStale = false, blockedFeature =
   const hasPassingValidation = run.validations.some((validation) => isValidationEligible(validation) && isValidationFresh(session, run, validation) && (!finalRun || validation.scope === "broad"));
   if (!hasPassingValidation)
     return "flow_validation_start";
-  if (unresolvedKnownFailedPlanCommands(session, run).length > 0) {
+  if (unresolvedVetoedCommands(session, run).length > 0) {
     return "flow_validation_start";
   }
   return "flow_review_start";
@@ -4149,8 +4158,10 @@ function registerFlowPluginInstance(scopeId, input) {
   });
 }
 
-// src/platform/opencode/tools.ts
+// src/platform/opencode/sdk.ts
 import { tool } from "@opencode-ai/plugin";
+
+// src/platform/opencode/tools.ts
 var host = tool.schema;
 var encoder2 = new TextEncoder;
 function boundedHostText(label, options) {
@@ -4191,7 +4202,9 @@ var plan = host.object({
 var reviewFinding = host.object({
   severity: host.enum(["blocking", "advisory"]),
   summary: text,
-  evidence: text.optional()
+  evidence: text.optional(),
+  scopeBlocker: host.boolean().optional(),
+  findingId: host.string().max(MAX_SESSION_ID_LENGTH).regex(FINDING_ID_PATTERN, FINDING_ID_MESSAGE).optional()
 }).strict();
 var reviewResult = host.object({
   verdict: host.enum(["passed", "failed"]),
@@ -4761,4 +4774,4 @@ export {
   plugin_default as default
 };
 
-//# debugId=44D653D2BF79482464756E2164756E21
+//# debugId=F9B2A9081022601764756E2164756E21