@webpresso/opencode-plugin 3.1.28 → 3.2.0

package/index.js

@@ -1,5 +1,7 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { accessSync, constants, existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
 const SESSION_START_HOOKS = ["sessionstart-routing"];
 const PRE_TOOL_HOOKS = ["pretool-guard"];
@@ -84,20 +86,112 @@ function shellQuote(value) {
   return `'${String(value).replaceAll("'", "'\\''")}'`;
 }
 
-async function resolveWpHookCommand($, directory, hookName) {
-  const repoLauncher = join(directory, "bin", process.platform === "win32" ? "wp.cmd" : "wp");
-  const candidates = [process.env.WEBPRESSO_WP_BIN, repoLauncher].filter(Boolean);
+function isExecutableFile(candidate) {
+  try {
+    const stat = statSync(candidate);
+    if (!stat.isFile()) return false;
+    if (process.platform !== "win32") accessSync(candidate, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isUsableWebpressoPackageRoot(packageRoot) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
+    return pkg.name === "@webpresso/agent-kit" && isExecutableFile(join(packageRoot, "bin", "wp"));
+  } catch {
+    return false;
+  }
+}
+
+function packageWpFromAdjacentNpmCmdShim(entryPath) {
+  if (!entryPath.toLowerCase().endsWith(".cmd")) return null;
+  const packageRoot = join(dirname(entryPath), "node_modules", "@webpresso", "agent-kit");
+  return isTrustedWebpressoPackageRoot(packageRoot) ? join(packageRoot, "bin", "wp") : null;
+}
+
+function isPathInsideOrEqual(parent, candidate) {
+  const parentRoot = realpathSync(parent);
+  const candidateRoot = realpathSync(candidate);
+  const rel = relative(resolve(parentRoot), resolve(candidateRoot));
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
+function isAgentKitWp(candidate, _projectRoot) {
+  if (candidate.toLowerCase().endsWith(".cmd")) return false;
+  if (!isExecutableFile(candidate)) return false;
+  try {
+    const resolved = realpathSync(candidate);
+    const packageRoot = dirname(dirname(resolved));
+    if (resolved !== join(packageRoot, "bin", "wp")) return false;
+    return isTrustedWebpressoPackageRoot(packageRoot);
+  } catch {
+    return false;
+  }
+}
 
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return `${shellQuote(candidate)} hook ${hookName}`;
+function currentAgentKitPackageRoot() {
+  let current = dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 12; depth += 1) {
+    const packagePath = join(current, "package.json");
+    if (existsSync(packagePath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(packagePath, "utf8"));
+        if (pkg.name === "@webpresso/agent-kit") return current;
+      } catch {
+        return null;
+      }
     }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+
+function trustedHomeInstallPackageRoots() {
+  const home = process.env.HOME || homedir();
+  return [
+    join(home, ".claude", "plugins", "cache", "webpresso", "agent-kit"),
+    join(home, ".bun", "install", "global", "node_modules", "@webpresso", "agent-kit"),
+  ];
+}
+
+function isTrustedWebpressoPackageRoot(packageRoot) {
+  try {
+    if (!isUsableWebpressoPackageRoot(packageRoot)) return false;
+    const realPackageRoot = realpathSync(packageRoot);
+    const sourceRoot = currentAgentKitPackageRoot();
+    if (sourceRoot !== null && realPackageRoot === realpathSync(sourceRoot)) return true;
+    return trustedHomeInstallPackageRoots().some(
+      (anchor) => existsSync(anchor) && isPathInsideOrEqual(anchor, realPackageRoot),
+    );
+  } catch {
+    return false;
+  }
+}
+
+async function resolveWpHookCommand($, directory, hookName) {
+  const explicit = process.env.WEBPRESSO_WP_BIN;
+  if (explicit) {
+    if (isAgentKitWp(explicit, directory)) {
+      return `${shellQuote(explicit)} hook ${hookName}`;
+    }
+    throw new Error(
+      `WEBPRESSO_WP_BIN points to ${explicit}, but that executable is not @webpresso/agent-kit`,
+    );
   }
 
   const found = await $`command -v wp`.cwd(directory).quiet().nothrow();
   const resolved = found.stdout?.toString().trim().split(/\r?\n/u)[0] ?? "";
   if ((found.exitCode === undefined || found.exitCode === 0) && resolved.length > 0) {
-    return `${shellQuote(resolved)} hook ${hookName}`;
+    const packageWp = packageWpFromAdjacentNpmCmdShim(resolved);
+    const command = packageWp ?? resolved;
+    if (isAgentKitWp(command, directory)) {
+      return `${shellQuote(command)} hook ${hookName}`;
+    }
   }
 
   throw new Error(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpresso/opencode-plugin",
-  "version": "3.1.28",
+  "version": "3.2.0",
   "private": false,
   "description": "OpenCode plugin adapter package for Webpresso agent-kit.",
   "homepage": "https://github.com/webpresso/agent-kit#readme",

package/plugin-skill-ownership.json

@@ -2,7 +2,7 @@
   "schemaVersion": 1,
   "host": "opencode",
   "packageName": "@webpresso/opencode-plugin",
-  "packageVersion": "3.1.28",
+  "packageVersion": "3.2.0",
   "runtimeDirs": [],
   "skills": {
     "ai-deslop": {
@@ -24,7 +24,7 @@
       "digest": "sha256:a97c243b11a25a893d3149a5545d3d111bc54e72c2e2acea9ce6fad3d333d2f1"
     },
     "codex": {
-      "digest": "sha256:07804f1e139e1e2e76f34f35dd5471895072aea5d8b3f5f412cf1328a8180b4b"
+      "digest": "sha256:7093f390749bed751038ad480d68c12380cfa2630e61881c16be46da7f75e238"
     },
     "deep-interview": {
       "digest": "sha256:e80d7e12e486397103108bb473e98e8e8656519770fa20701f8b3e9e66991939"
@@ -39,7 +39,7 @@
       "digest": "sha256:306355888da0827e3523022077f731845726bbaaf595ca12515cc91d8605b5e6"
     },
     "fix": {
-      "digest": "sha256:6761e335ca1327d0dd12822886d5ea7f1b683f27caba62046cd0529c7cda7e44"
+      "digest": "sha256:2508fbad15af4ef828b668084cac950c98b8a232ce25c8152135788738e5f243"
     },
     "grok": {
       "digest": "sha256:07f2cdc58889f13f0869ddc153d465423cf2f4aae7b9deb4c4e427d2dba78a34"
@@ -90,7 +90,7 @@
       "digest": "sha256:953ab2625287866e5f27e602a89f1752e054d47522d04e1fdc11880867dc2fde"
     },
     "verify": {
-      "digest": "sha256:4c9d534c358456c1d34f9b4b919e70dd013164c7c89ca8229181b77e31bdc914"
+      "digest": "sha256:47c1d75ef5d1d47b94ef48ac91b0fd4bbf6ba1ab32563cfc28518bb75c7798f0"
     }
   }
 }

package/skills/codex/SKILL.md

@@ -8,13 +8,37 @@ license: MIT
 
 Use this skill from Claude or another non-Codex host when the user wants Codex to independently review a diff, challenge a plan, or answer a repo question. Keep Codex read-only by default and treat its answer as external advice until independently verified.
 
+## Primary path: the `wp_review_run` MCP tool
+
+When the webpresso MCP server is available, call `wp_review_run` directly instead of any bash block below — it is the same `wp review run` typed runtime, called in-process, with two ergonomic wins: it takes a `prompt` string (no `--prompt-file` bookkeeping) and it runs the probe stage and the review stage in **one call** by default (the review stage is skipped automatically if the probe fails, so you never waste a full review invocation on a cold/broken provider).
+
+```jsonc
+// wp_review_run MCP tool call
+{
+  "prompt": "<diff summary + what to look for>",
+  "provider": "codex",
+  // model, effort, artifactRoot, idleSeconds are all optional and default
+  // the same way the `wp review run` CLI does. Omit `stage` for automatic
+  // probe-then-review; pass stage: "probe" or stage: "review" only for
+  // manual single-stage control.
+}
+```
+
+**Provider fallback lives in this one call.** If your primary provider (e.g. Codex) is unavailable — out of credits, auth expired — switch the `provider` parameter to another supported value (`claude`, `opencode`, `grok`) in the SAME `wp_review_run` call. Never shell into a different provider's CLI directly; that bypasses artifact capture under `.webpresso/reviews`, availability tracking, and the probe-then-review handshake this tool exists to provide. The pretool guard hook actively blocks shelling straight into a provider CLI's review-launching subcommand and redirects here.
+
+The bash blocks in this skill (below) are the **MCP-unavailable fallback only** — use them when the webpresso MCP server itself is not reachable in the current host, not as a provider-fallback mechanism.
+
 ## Single-shot budget (anti-stampede)
 
 - Default: **one** review invocation per request.
 - Do **not** fan out parallel multi-host review matrices unless the user set `review_budget`/`N` > 1.
-- Prefer `wp review run` / `wp review gate` over spawn/wait agent loops for review.
+- Prefer `wp_review_run` (MCP) or `wp review run` / `wp review gate` (CLI fallback) over spawn/wait agent loops for review.
 - Keep prompts bounded; no whole-repo paste.
 
+## MCP-unavailable fallback (raw CLI)
+
+Everything from here down is the manual `wp review run` CLI path documented for hosts or sessions where the webpresso MCP server is not reachable. Prefer `wp_review_run` above whenever MCP is available.
+
 ## Auth check
 
 ```bash

package/skills/fix/SKILL.md

@@ -122,12 +122,15 @@ Run the narrowest checks that prove the repaired behavior on the real repo surfa
 - `wp_test` / targeted tests for the repaired path
 - `wp_lint` / `wp_typecheck` for changed surfaces
 - `wp_qa` only when the blast radius needs the bookend
+- Before push: `wp ci-preflight` (local pre-push owner). Do not use remote CI
+  re-runs as the primary fix loop (`ci-cost-local-first`).
 
 Rules:
 
 - Prefer MCP `wp_*` over raw host Bash.
 - Reuse fresh logs / session-memory indexed output; do not re-run long commands just to re-read.
 - Read the exit code and summary before making a claim.
+- Never `git push --no-verify` to land an unproven fix.
 
 Escalate to `/verify <target>` (local) or `/verify <target> --merge-ready` when any of these are true:
 

package/skills/verify/SKILL.md

@@ -109,6 +109,9 @@ workflow:
 1. Identify target type (file / package / blueprint slug / all).
 2. Map each claim you plan to make to the exact command or log that proves it.
 3. If the target is a blueprint slug, run the repo's blueprint show/audit surface and record the acceptance boxes that still need proof.
+4. **CI cost / local-first:** treat remote CI as confirmation, not the first
+   debugger. Load `ci-cost-local-first` expectations: no hook skips, no
+   blind `gh run rerun`, Ubicloud for private non-release jobs.
 
 ## Phase 1 — Governance gates
 
@@ -130,12 +133,27 @@ Run the narrowest checks that prove the touched behavior:
 - `wp_test` / targeted tests
 - `wp_qa`, `wp_e2e`, build / package checks only when the change requires them
 
+**Before push or PR open/update**, run the pre-push owner end-to-end:
+
+```bash
+wp ci-preflight
+```
+
+That is fail-fast branch-scoped format → guardrails → typecheck → lint →
+test. Agent-kit itself enforces it from `.husky/pre-push`; consumer repos may
+keep pre-push checks user-owned, so run the command explicitly before pushing.
+Do **not** claim push-ready if preflight failed. Do **not** bypass hooks to ship
+red work.
+
 Rules:
 
 - Prefer MCP `wp_*` over raw underlying tools.
 - Reuse fresh logs / session-memory indexed output if the runner auto-saves them.
 - Never claim broader correctness than the commands actually proved.
 - If the repo documents a "full QA" bookend, reserve `wp_qa` / `--full` for the final broad pass rather than every iteration.
+- If CI is already red: read the failed job log, reproduce with the matching
+  local `wp` command, fix, re-run `wp ci-preflight`, then push **one**
+  corrective commit — do not burn another full matrix “to check.”
 
 ## Phase 3 — Cross-surface impact scan
 
@@ -217,8 +235,10 @@ Reviewer preference (pick **one** path):
 
 Approval evidence requirements:
 
-- Blueprint lifecycle: `wp review gate <blueprint-slug> --target HEAD --json` first.
-  Use `wp review log` / `wp review read` for inspection.
+- Blueprint lifecycle: `wp review gate <blueprint-slug> --purpose delivery --target HEAD --json`
+  first. Delivery gates automatically run declared Promotion Gates from the
+  Trust Dossier before outside-review provider probes. Use `wp review log` /
+  `wp review read` for inspection.
 - Each reviewer must return clear `APPROVED`/`BLOCKED` with enough evidence.
 - Record as PR comments when a PR exists (model/tool, verdict, reviewed commit).
 - Unavailable reviewer → try next preferred; if still short, report gap and