opencode-plugin-flow 8.1.3 → 8.2.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 One short entry per release, written for users deciding whether to upgrade.
 
+## [8.2.0] - 2026-08-31
+
+Reviewer selection is now native plugin configuration, and Flow reports enough
+derived evidence for a bounded delivery handoff.
+
+- OpenCode plugin tuple options can select the reviewer model and step budget.
+  Flow resolves the selection once per process and reports it in `/flow-status`.
+  Environment variables remain fallback configuration.
+- Every accepted close returns a deterministic, versioned delivery summary with
+  feature attempts, outcomes, terminal findings, changed-artifact declarations,
+  and tiered assurance. The handoff grants no external action authority.
+- A new quickstart and structured external pilot cover installation, reviewer
+  selection, first-run checks, recovery, and feedback without telemetry.
+- Report-only evals now measure repository gate discovery and task-specific risk
+  questions. Eval host configuration uses the same reviewer tuple as production,
+  and release notes derive their provider evidence from retained artifacts.
+- **Session v5 schema:** unchanged. Runtime tools, commands, guides, and agents
+  keep their existing names and inputs.
+
+Install or update:
+
+```bash
+opencode plugin opencode-plugin-flow@8.2.0 --global --force
+```
+
 ## [8.1.3] - 2026-08-28
 
 Release claims now come from retained evidence instead of trusted summaries.

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@8.1.3 --global --force
+opencode plugin opencode-plugin-flow@8.2.0 --global --force
 ```
 
 Omit `--global` for project scope. Version pins are exact and never update on
@@ -51,10 +51,28 @@ The equivalent manual project configuration is:
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugin": ["opencode-plugin-flow@8.1.3"]
+  "plugin": ["opencode-plugin-flow@8.2.0"]
 }
 ```
 
+For an explicit reviewer model, use OpenCode's plugin tuple options:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    [
+      "opencode-plugin-flow@8.2.0",
+      { "reviewer": { "model": "provider/model", "steps": 80 } }
+    ]
+  ]
+}
+```
+
+The tuple values take precedence over `OPENCODE_FLOW_REVIEWER_MODEL` and
+`OPENCODE_FLOW_REVIEWER_STEPS`. `/flow-status` reports the process-local
+selection, but only a successful reviewer run confirms model availability.
+
 Restart OpenCode after changing configuration. OpenCode owns installation and
 configuration; see its
 [plugin documentation](https://opencode.ai/docs/plugins/). Flow has no installer
@@ -68,6 +86,9 @@ remain inert history, and there is no migration or rollback layer.
 
 ## Quick start
 
+For a clean installation and reviewer-configuration check, follow the
+[quickstart](docs/quickstart.md).
+
 ```text
 /flow-auto add rate limiting to the public API
 ```
@@ -127,9 +148,10 @@ you granted.
 6. A passing review advances the plan. A failed feature is never picked up again
    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, terminal findings, and tiered assurance with
-   explicit limitations.
+   accepted close returns a versioned delivery summary derived from recorded state:
+   each feature's attempts, latest outcome, terminal findings, and tiered assurance
+   with explicit limitations. Delivery grants no PR, merge, publish, or release
+   authority.
 
 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

@@ -184,6 +184,14 @@ without rediscovering the goal.
   context. Do not dispatch \`flow-worker\` while planning; that role is only for
   authorized implementation slices after approval. Ask only for a missing
   product choice that materially changes the outcome.
+- Discover evidence in order: repository instructions such as \`AGENTS.md\` and
+  \`CONTRIBUTING.md\`, maintained development docs, CI workflows, then build and
+  test manifests. Compare candidates with the requested behavior and current
+  platform. Prefer an explicit whole-repository command over a conveniently
+  named narrow script. Probe command fitness when it is observable without
+  mutation. Record the chosen source and rationale in \`decisions\` when the gate
+  is not obvious. Discovery never counts as passing evidence; only an armed
+  observation does.
 
 ## Plan contract
 
@@ -532,8 +540,15 @@ last relevant edit.
 
 After successful applicable validation, call \`flow_review_start\` with a fresh
 operation id, current revision, feature id, \`artifactsChanged\`, and a bounded
-packet. Dispatch only reserved \`flow-reviewer\`. Never review or submit its
-verdict in manager context.
+packet. For persistence, schema, migration, replay, or recovery work, add only
+the relevant full questions to \`riskLenses\`: can interruption leave partial
+state; are retry and replay idempotent; can older state or readers fail visibly;
+does rollback preserve data? For public API, config, command, package, or
+documented-contract work, ask whether existing callers keep their defaults,
+invalid inputs fail at the boundary, and the packed artifact exposes the
+approved contract. Leave \`riskLenses\` empty for ordinary low-risk changes.
+Dispatch only reserved \`flow-reviewer\`. Never review or submit its verdict in
+manager context.
 
 After dispatch, read compact status. On top-level error, report exact
 summary/recovery and stop without further mutation. If status remains running,
@@ -666,31 +681,22 @@ var FLOW_WORKER_PROMPT = [
 var FLOW_STATUS_PROMPT = [
   'Call `flow_status { request: { view: "compact" } }` first.',
   "Do not mutate.",
+  "Report `workflowData.reviewerConfiguration.report` verbatim when present and label it process-local, not persisted state.",
+  "Report `workflowData.statusReport` verbatim when present; do not reconstruct lifecycle or recovery facts from the projection.",
   "If the top-level response status is `error`, report its exact summary and",
   "`workflowData.failure.recovery` when present; otherwise say no recovery guidance was supplied.",
-  "When `workflowData.delivery` is present, also report its `report` lines verbatim.",
+  "When `workflowData.delivery` is present, report its `report` lines verbatim.",
   "For the terminal ID map use only `outcomeSummary` and `terminalFindings`: IDs are `verified`",
   "only when proven, otherwise `incomplete` or explicitly `deferred`; `fixed` needs later passing",
   "review plus current evidence, `recurring` current confirmation, `residual` a confirmed nonblocker,",
   "and `abandoned` remains the closure kind.",
   "Missing IDs are unavailable.",
-  "State that `/flow-status` made no Git or release mutation, report any lifecycle state effect",
-  "disclosed by the response, and stop.",
+  "State that `/flow-status` made no Git or release mutation, note any lifecycle effect, and stop.",
   "Do not interpret recovery guidance as a blocked review.",
   "If `projection.status` is `blocked` or `projection.nextAction` is `await-user-direction`,",
   'call `flow_status { request: { view: "detail" } }` exactly once and label the result overall incomplete.',
-  "From that detail projection, report the goal and progress; any blocked feature, attempt,",
-  "`failedReviewCount`, and findings; every retry-required feature whose latest relevant reviewed",
-  "outcome remains failed; completed and untouched features; validations and `artifactsChanged`",
-  "as Flow-reported artifact evidence; and the exact status and `nextAction`.",
-  "For a blocked first failed review, explain that `flow_feature_reset` is the projected default.",
-  "For blocked `await-user-direction`, explain that an authorized retry or independent choice",
-  "uses atomic `flow_feature_reset` with `nextFeatureId`.",
-  "For ready `await-user-direction`, explain that no blocked run remains, so an authorized retry",
-  "uses `flow_run_start` with an explicit `featureId`, never reset or default selection.",
-  "When `workflowData.autoTiming` is present, report `activeMs` as non-authoritative process-local",
-  "wall time classified active, not CPU or pure work, and `waitingForUserMs` as only projected",
-  "`flow_plan_approve` plus `await-user-direction` time for the latest `/flow-auto`.",
+  "Report the detail `workflowData.statusReport` verbatim when present; it owns retry, evidence, artifact, and recovery text.",
+  "When `workflowData.autoTiming` is present, report `activeMs` as non-authoritative process-local wall time, not CPU or pure work, and `waitingForUserMs` as only projected `flow_plan_approve` plus `await-user-direction` time for the latest `/flow-auto`.",
   "State that paused, inactive, errored, and unprojected waits are excluded.",
   "Otherwise report the compact projection and its exact `nextAction`, state that `/flow-status`",
   "made no lifecycle, Git, or release mutation, and stop."
@@ -854,13 +860,104 @@ function reviewerSteps(env, onWarning) {
   }
   return Number(raw);
 }
-var SHARED_REVIEWER_MODEL_NOTICE = "Flow: no OPENCODE_FLOW_REVIEWER_MODEL is set, so the independent reviewer runs on the same model as the manager. Independence is stronger with a different model family; set OPENCODE_FLOW_REVIEWER_MODEL to a provider/model this host can reach.";
-function createFlowCoreConfigEntries(options) {
+function pluginReviewerOptions(options, onWarning) {
+  const reviewer = options?.reviewer;
+  if (reviewer === undefined)
+    return {};
+  if (typeof reviewer !== "object" || reviewer === null || Array.isArray(reviewer)) {
+    onWarning?.("Flow plugin option reviewer must be an object; ignoring it.");
+    return {};
+  }
+  return Object.fromEntries(Object.entries(reviewer));
+}
+function pluginReviewerModel(reviewer, onWarning) {
+  if (!Object.hasOwn(reviewer, "model"))
+    return;
+  const value = reviewer.model;
+  if (typeof value !== "string") {
+    onWarning?.("Flow plugin option reviewer.model must be a non-empty string; ignoring it.");
+    return;
+  }
+  const model = value.trim();
+  if (!model) {
+    onWarning?.("Flow plugin option reviewer.model must be a non-empty string; ignoring it.");
+    return;
+  }
+  return model;
+}
+function pluginReviewerSteps(reviewer, onWarning) {
+  if (!Object.hasOwn(reviewer, "steps"))
+    return;
+  const value = reviewer.steps;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > 1000) {
+    onWarning?.("Flow plugin option reviewer.steps must be an integer from 1 through 1000; ignoring it.");
+    return;
+  }
+  return value;
+}
+function resolveFlowReviewerConfiguration(options) {
   const env = options?.env ?? process.env;
-  const model = envValue(env, "OPENCODE_FLOW_REVIEWER_MODEL");
+  const reviewer = pluginReviewerOptions(options?.pluginOptions, options?.onWarning);
+  const configuredModel = pluginReviewerModel(reviewer, options?.onWarning);
+  const configuredSteps = pluginReviewerSteps(reviewer, options?.onWarning);
+  const environmentModel = configuredModel ? undefined : envValue(env, "OPENCODE_FLOW_REVIEWER_MODEL");
+  const environmentSteps = configuredSteps === undefined ? reviewerSteps(env, options?.onWarning) : undefined;
+  return {
+    model: configuredModel ? { kind: "explicit", source: "plugin-option", value: configuredModel } : environmentModel ? {
+      kind: "explicit",
+      source: "environment",
+      value: environmentModel
+    } : { kind: "shared-with-manager" },
+    steps: configuredSteps !== undefined ? {
+      kind: "explicit",
+      source: "plugin-option",
+      value: configuredSteps
+    } : environmentSteps !== undefined ? {
+      kind: "explicit",
+      source: "environment",
+      value: environmentSteps
+    } : { kind: "host-default" }
+  };
+}
+function flowReviewerStatus(reviewer) {
+  const model = reviewer.model.kind === "explicit" ? {
+    kind: "explicit",
+    source: reviewer.model.source,
+    requested: reviewer.model.value
+  } : {
+    kind: "shared-manager-model",
+    source: "host-default",
+    requested: null
+  };
+  const steps = reviewer.steps.kind === "explicit" ? {
+    kind: "explicit",
+    source: reviewer.steps.source,
+    requested: reviewer.steps.value
+  } : {
+    kind: "host-default",
+    source: "host-default",
+    requested: null
+  };
+  return {
+    scope: "current-plugin-process",
+    model,
+    steps,
+    availability: "unverified",
+    report: [
+      reviewer.model.kind === "explicit" ? "Reviewer selection: explicit." : "Reviewer selection: shared manager model.",
+      model.kind === "explicit" ? `Requested reviewer model: ${model.requested} (from ${model.source}).` : "Requested reviewer model: none; the reviewer inherits the manager model.",
+      reviewer.steps.kind === "host-default" ? "Requested reviewer step budget: host default." : `Requested reviewer step budget: ${reviewer.steps.value} (from ${reviewer.steps.source}).`,
+      "Reviewer model availability: unverified; configuration proves only what Flow requested from OpenCode."
+    ]
+  };
+}
+var SHARED_REVIEWER_MODEL_NOTICE = "Flow: no reviewer model is set, so the independent reviewer runs on the same model as the manager. Independence is stronger with a different model family; use the plugin reviewer.model option or OPENCODE_FLOW_REVIEWER_MODEL.";
+function createFlowCoreConfigEntries(options) {
+  const reviewer = options?.reviewerConfiguration ?? resolveFlowReviewerConfiguration(options);
+  const model = reviewer.model.kind === "explicit" ? reviewer.model.value : undefined;
   if (!model)
     options?.onNotice?.(SHARED_REVIEWER_MODEL_NOTICE);
-  const steps = reviewerSteps(env, options?.onWarning);
+  const steps = reviewer.steps.kind === "explicit" ? reviewer.steps.value : undefined;
   return {
     agent: {
       "flow-reviewer": {
@@ -883,7 +980,9 @@ function createFlowCoreConfigEntries(options) {
 function applyFlowConfig(config, options) {
   const entries = createFlowCoreConfigEntries({
     ...options?.onWarning ? { onWarning: options.onWarning } : {},
-    ...options?.onNotice ? { onNotice: options.onNotice } : {}
+    ...options?.onNotice ? { onNotice: options.onNotice } : {},
+    ...options?.pluginOptions ? { pluginOptions: options.pluginOptions } : {},
+    ...options?.reviewerConfiguration ? { reviewerConfiguration: options.reviewerConfiguration } : {}
   });
   for (const name of Object.keys(entries.agent)) {
     if (config.agent && name in config.agent)
@@ -2551,6 +2650,8 @@ function formatReport(delivery) {
     ]
   ]);
   return [
+    `Handoff format: ${delivery.handoff.formatVersion}`,
+    `External action authority: ${delivery.handoff.externalActionAuthority}`,
     `Goal: ${delivery.goal}`,
     `Closure: ${delivery.closure.kind}${delivery.closure.summary ? ` — ${delivery.closure.summary}` : ""}`,
     `Progress: ${delivery.progress.completed} of ${delivery.progress.total} features complete`,
@@ -2580,6 +2681,7 @@ function deliveryProjection(session) {
   const allArtifacts = new Set(session.runs.flatMap((run) => run.artifactsChanged.map((item) => item.path)));
   const digest2 = findingsDigest(session);
   const delivery = {
+    handoff: { formatVersion: 1, externalActionAuthority: "not-granted" },
     goal: session.goal,
     closure: { kind: session.closure.kind, summary: session.closure.summary },
     progress: {
@@ -2608,6 +2710,124 @@ function deliveryProjection(session) {
 }
 
 // src/application/session-projection.ts
+function actionGuidance(projection) {
+  const action = projection.nextAction;
+  switch (action) {
+    case "flow_plan_save":
+      return "Action guidance: inspect the repository and save one draft plan with flow_plan_save.";
+    case "flow_plan_approve":
+      return "Action guidance: review the draft and approve it only with explicit or prior implementation authority.";
+    case "flow_run_start":
+      return projection.status === "ready" ? "Action guidance: start one exact dependency-ready feature with flow_run_start." : "Action guidance: refresh status before starting another feature.";
+    case "flow_feature_reset":
+      return projection.status === "blocked" ? "Action guidance: reset the failed feature and select the exact authorized retry or independent feature with flow_feature_reset." : "Action guidance: reset the source-stale active feature; do not redispatch its reviewer.";
+    case "await-user-direction":
+      if (projection.status === "ready")
+        return "Action guidance: choose the exact failed feature to retry with flow_run_start; do not use default selection.";
+      if (projection.status === "blocked")
+        return "Action guidance: choose an exact retry or dependency-independent feature through flow_feature_reset with nextFeatureId.";
+      return "Action guidance: supply the missing declared evidence or explicitly choose deferred or abandoned closure.";
+    case "flow_session_close":
+      return "archiveRetry" in projection && projection.archiveRetry ? "Action guidance: replay the projected flow_session_close request byte-for-byte before any other recovery action." : "Action guidance: close the completed session with flow_session_close.";
+    case "flow_status":
+      return "Action guidance: refresh Flow status before another lifecycle action.";
+    case "dispatch-flow-reviewer":
+      return "Action guidance: dispatch the existing pending assignment to flow-reviewer.";
+    case "flow_validation_start":
+      return "Action guidance: arm the exact next validation command with flow_validation_start.";
+    case "flow_review_start":
+      return "Action guidance: create one independent review assignment with flow_review_start.";
+    default: {
+      const exhaustive = action;
+      return exhaustive;
+    }
+  }
+}
+function compactReport(projection) {
+  return [
+    `View: ${projection.view}`,
+    `Session: ${projection.sessionId}`,
+    `Status: ${projection.status}`,
+    `Approval: ${projection.approval}`,
+    `Revision: ${projection.revision}`,
+    `Goal: ${projection.goal}`,
+    `Progress: ${projection.progress.completed} of ${projection.progress.total} features complete; ${projection.progress.remaining} remaining`,
+    `Active feature: ${projection.activeFeatureId ?? "none"}`,
+    `Active run: ${projection.activeRunId ?? "none"}`,
+    ...projection.blockedFeature ? [
+      `Blocked feature: ${projection.blockedFeature.featureId}`,
+      `Blocked attempt: ${projection.blockedFeature.attempt}`,
+      `Failed review count: ${projection.blockedFeature.failedReviewCount}`,
+      `Scope blocker: ${projection.blockedFeature.scopeBlocker ? "yes" : "no"}`
+    ] : [],
+    `Next action: ${projection.nextAction}`,
+    `Archive retry: ${projection.archiveRetry ? "yes" : "no"}`,
+    actionGuidance(projection),
+    ...digestReportLines(projection.findingsDigest)
+  ];
+}
+function retryRequiredFeatureIds(projection) {
+  return (projection.plan?.features ?? []).flatMap((feature) => {
+    const run = projection.runs.findLast((candidate) => candidate.featureId === feature.id);
+    const reviewed = run?.reviews.findLast((review) => review.result !== null);
+    return reviewed?.result?.verdict === "failed" ? [feature.id] : [];
+  });
+}
+function statusReport(projection) {
+  if (!("sessionId" in projection)) {
+    return [
+      `View: ${projection.view}`,
+      "Status: idle",
+      "Revision: 0",
+      "Next action: flow_plan_save",
+      "No active Flow session.",
+      actionGuidance(projection),
+      ...digestReportLines(projection.findingsDigest)
+    ];
+  }
+  if (projection.view === "reviewer") {
+    return [
+      "View: reviewer",
+      `Session: ${projection.sessionId}`,
+      `Revision: ${projection.revision}`,
+      `Goal: ${projection.goal}`,
+      `Feature: ${projection.feature ? `${projection.feature.id} - ${projection.feature.title}` : "unavailable"}`,
+      `Reviewer assignment: ${projection.assignment.id}`,
+      `Assignment kind: ${projection.assignment.kind}`,
+      `Review feature: ${projection.assignment.featureId}`,
+      `Risk lenses: ${projection.assignment.packet.riskLenses.join(", ") || "none"}`,
+      `Artifacts changed: ${projection.artifactsChanged.length}`,
+      `Validations: ${projection.validations.length}`,
+      `Completed features: ${projection.completedFeatureIds.length}`,
+      `Prior findings: ${projection.priorFindings.length}`,
+      `Next finding id prefix: ${projection.nextFindingIdPrefix}`
+    ];
+  }
+  const common = compactReport(projection);
+  if (projection.view === "execution") {
+    return [
+      ...common,
+      `Feature: ${projection.feature ? `${projection.feature.id} - ${projection.feature.title}` : "none"}`,
+      `Run: ${projection.run ? `${projection.run.id}; state ${projection.run.state}` : "none"}`
+    ];
+  }
+  if (projection.view === "detail") {
+    const retryRequired = retryRequiredFeatureIds(projection);
+    const validations = projection.runs.reduce((total, run) => total + run.validations.length, 0);
+    const artifacts = new Set(projection.runs.flatMap((run) => run.artifactsChanged.map((artifact) => artifact.path)));
+    return [
+      ...common,
+      `Plan features: ${projection.plan?.features.length ?? 0}`,
+      `Runs: ${projection.runs.length}`,
+      `Retry-required features: ${retryRequired.join(", ") || "none"}`,
+      `Validation observations: ${validations}`,
+      `Flow-reported artifacts: ${[...artifacts].sort().join(", ") || "none"}`,
+      `Closure: ${projection.closure ? `${projection.closure.kind} - ${projection.closure.summary || "none"}` : "none"}`,
+      `Operations recorded: ${projection.operations.length}`
+    ];
+  }
+  return common;
+}
 function featureProgress(session) {
   const total = session.plan?.features.length ?? 0;
   const completed = session.plan?.features.filter((feature) => isFeatureComplete(session, feature.id)).length ?? 0;
@@ -4605,6 +4825,7 @@ function createConfigHook(ctx, options) {
       return;
     }
     applyFlowConfig(config, {
+      ...options?.reviewerConfiguration ? { reviewerConfiguration: options.reviewerConfiguration } : {},
       onWarning: (warning) => log("warn", warning),
       onNotice: (notice) => log("info", notice),
       onCollision: (kind, name) => log("warn", `Flow replaced a user-defined ${kind} named '${name}'; rename the local entry while Flow is enabled.`)
@@ -4839,6 +5060,13 @@ function bestEffort(read) {
 }
 function withAutoContext(response, options, view) {
   let workflowData = response.workflowData;
+  const reviewer = options.reviewerConfiguration;
+  if (reviewer) {
+    workflowData = {
+      ...workflowData,
+      reviewerConfiguration: flowReviewerStatus(reviewer)
+    };
+  }
   if (options.runtimeIdentity)
     workflowData = {
       ...workflowData,
@@ -4890,7 +5118,17 @@ function createTools(_ctx, options) {
     flow_status: defineFlowTool({
       description: "Read compact, execution, detail, or reviewer Flow state.",
       schema: StatusInputSchema,
-      execute: (args, context) => execute(context, async (workspace) => withAutoContext(await workspace.status(args), options, args.request.view))
+      execute: (args, context) => execute(context, async (workspace) => {
+        const response = await workspace.status(args);
+        const workflowData = "projection" in response.workflowData ? {
+          ...response.workflowData,
+          statusReport: statusReport(response.workflowData.projection)
+        } : response.workflowData;
+        return withAutoContext({
+          ...response,
+          workflowData
+        }, options, args.request.view);
+      })
     }),
     flow_plan_save: defineFlowTool({
       description: "Create or replace the active draft plan.",
@@ -5266,8 +5504,12 @@ function guardTools(tools, runtimeGuard, autoDrive) {
     }
   ]));
 }
-var FlowPlugin = async (ctx) => {
+var FlowPlugin = async (ctx, pluginOptions) => {
   const log = createFlowLog(ctx);
+  const reviewerConfiguration = resolveFlowReviewerConfiguration({
+    pluginOptions,
+    onWarning: (warning) => log("warn", warning)
+  });
   const version = resolveFlowPluginVersion();
   const pluginEntrySha256 = `sha256:${createHash6("sha256").update(await readFile2(fileURLToPath(import.meta.url))).digest("hex")}`;
   const runtimeGuard = registerFlowPluginInstance(ctx.worktree ?? ctx.directory, {
@@ -5320,11 +5562,13 @@ var FlowPlugin = async (ctx) => {
     prepareValidation: prepareWorkspaceValidation,
     autoTimingSnapshot: () => autoDrive.timingSnapshot(),
     autoContinuationSupport: () => autoDrive.continuationSupport(),
+    reviewerConfiguration,
     runtimeIdentity: { packageVersion: version, pluginEntrySha256 }
   });
   return {
     config: createConfigHook(ctx, {
-      assertOperational: (action) => runtimeGuard.assertOperational(action)
+      assertOperational: (action) => runtimeGuard.assertOperational(action),
+      reviewerConfiguration
     }),
     tool: guardTools(tools, runtimeGuard, autoDrive),
     "command.execute.before": createCommandHook((action) => runtimeGuard.assertOperational(action), autoDrive, workspace),
@@ -5387,4 +5631,4 @@ export {
   plugin_default as default
 };
 
-//# debugId=B115FE46858F6B0164756E2164756E21
+//# debugId=29653CBC4F7B7BAE64756E2164756E21