@plainconceptsplatform/agent-harness 3.8.2 → 3.9.0-alpha.1

package/harness/.opencode/plugins/pc-subagent-tiers.js

@@ -1,367 +1,56 @@
-// pc-subagent-tiers: on startup, reads *-engineer.md templates and creates
-// tier variant agent files with the resolved model, plus the two primary agents
-// the user actually talks to. Everything generated here is gitignored and
-// rebuilt every startup. Model resolution: user override > team config.
-//
-// Agent topology:
-//   build.md / plan.md      mode: primary   the only agents a human selects.
-//                                           Both are fullstack-engineer with a
-//                                           tier model; plan can neither edit
-//                                           nor spawn.
-//   planner.md              mode: all       fullstack-engineer on the plan tier
-//                                           that may write but not spawn. The
-//                                           thinking commands run on it, and a
-//                                           CI lead spawns it for propose and
-//                                           archive, so those steps take the
-//                                           plan model whatever the session's is.
-//   fullstack-engineer.md   mode: subagent  the shared body of build and plan,
-//                                           and the fallback worker.
-//   *-engineer.md           mode: subagent  specialists, spawned by subagent().
-//   *-engineer.<tier>.md    mode: subagent  the same specialist pinned to a tier.
-//
-// OpenCode 2 discovers agents from .opencode/agents/*.md and overrides a built-in
-// by ID, so the generated files replace the built-in build/plan. The plugin API's
-// agent editor can update or remove an existing agent but cannot add one, so file
-// generation is the mechanism: writing the files in setup, before agents resolve,
-// is what makes them visible.
+// pc-subagent-tiers: on startup, generates the primary agents, the spawnable
+// planner alias and the tier variants from *-engineer.md templates, then pins
+// the primaries in memory. The generation itself lives in
+// pc-subagent-tiers-core.js so a CI pre-start step can write the same files
+// before OpenCode builds its task enum.
 
-import { Plugin, Model } from "@opencode/plugin"
-import fs from "node:fs/promises"
-import path from "node:path"
-
-const TIERS = ["build", "fast", "plan"]
-
-// The two primaries, and the tier each takes its model from. plan denies edit
-// and subagent: a planning session cannot mutate the tree itself, and it cannot
-// spawn a worker that would do it on its behalf. shell stays allowed because the
-// planning skills shell out to git and openspec to read state, and
-// pc-system-reminders holds it to inspection commands.
-const PRIMARIES = {
-  build: {
-    tier: "build",
-    color: "primary",
-    description: "Implement changes in this repository. Full write access, spawns specialist engineers for parallel work.",
-    permissions: null,
-  },
-  plan: {
-    tier: "plan",
-    color: "warning",
-    description: "Explore and plan without touching the tree. Read-only: proposes work for build to carry out.",
-    permissions: [
-      { action: "edit", resource: "*", effect: "deny" },
-      { action: "subagent", resource: "*", effect: "deny" },
-    ],
-  },
-  planner: {
-    tier: "plan",
-    mode: "all",
-    color: "info",
-    description: "Write plans, proposals, stories, reviews and archives on the plan model. Edits the tree, never spawns workers.",
-    permissions: [{ action: "subagent", resource: "*", effect: "deny" }],
-  },
-}
-
-// opencode's theme keywords. Treated as unset so a name-derived hex wins: the
-// old /make-engineer template asked whoever ran it to pick one of these and
-// avoid collisions by hand, which does not survive more than a few agents.
-const THEME_COLORS = new Set(["primary", "secondary", "accent", "success", "warning", "error", "info"])
-
-// Fields V1 agent frontmatter used that V2 forbids. Stripped on sight so a repo
-// upgraded in place does not carry a definition V2 refuses to load.
-const LEGACY_FIELDS = [
-  "model",
-  "permission",
-  "prompt",
-  "disable",
-  "disabled",
-  "temperature",
-  "top_p",
-  "maxSteps",
-  "tools",
-]
-
-// Mirrors cli/utils/agent-color.js in the CLI, duplicated because a plugin has
-// to stand alone in the consumer repo. agent-color.test.js asserts the two stay
-// in step; change one and change the other.
-//
-// Only the hue is hashed. Fixed saturation and lightness are what keep every
-// result usable: hashing those too would eventually produce a near-grey,
-// near-black or near-white agent, invisible against one theme or the other.
-function agentColor(name) {
-  let h = 0x811c9dc5
-  for (let i = 0; i < name.length; i++) {
-    h ^= name.charCodeAt(i)
-    h = Math.imul(h, 0x01000193) >>> 0
-  }
-  const hue = (h >>> 0) % 360
-  const sat = 0.68
-  const light = 0.52
-  const c = (1 - Math.abs(2 * light - 1)) * sat
-  const x = c * (1 - Math.abs(((hue / 60) % 2) - 1))
-  const m = light - c / 2
-  const [r, g, b] =
-    hue < 60 ? [c, x, 0] :
-    hue < 120 ? [x, c, 0] :
-    hue < 180 ? [0, c, x] :
-    hue < 240 ? [0, x, c] :
-    hue < 300 ? [x, 0, c] :
-    [c, 0, x]
-  const toHex = v => Math.round((v + m) * 255).toString(16).padStart(2, "0")
-  return `#${toHex(r)}${toHex(g)}${toHex(b)}`.toUpperCase()
-}
-
-/** A theme keyword or a missing value yields to the derived hex; a hex stays. */
-function shouldDeriveColor(current) {
-  if (!current) return true
-  return THEME_COLORS.has(current.trim().toLowerCase())
-}
-
-/**
- * Render a colour for YAML frontmatter.
- *
- * A hex has to be quoted. `#` opens a comment in YAML, so `color: #D83155`
- * parses as null and opencode refuses the agent with "Invalid input color".
- * Theme keywords need no quoting and stay bare.
- */
-function yamlColor(value) {
-  return value.startsWith("#") ? `"${value}"` : value
-}
-
-function unquoteColor(raw) {
-  return (raw ?? "").trim().replace(/^["']/, "").replace(/["']$/, "")
-}
-
-function splitFrontmatter(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/)
-  if (!match) return { frontmatter: null, body: content }
-  return { frontmatter: match[1], body: content.slice(match[0].length) }
-}
-
-function stripLegacyFields(frontmatter) {
-  const lines = frontmatter.split(/\r?\n/)
-  const kept = []
-  for (let i = 0; i < lines.length; i++) {
-    const key = lines[i].match(/^([A-Za-z0-9_-]+):/)?.[1]
-    if (key && LEGACY_FIELDS.includes(key)) {
-      // Drop the key and any indented continuation lines that belong to it.
-      i++
-      while (i < lines.length && /^\s+\S/.test(lines[i])) i++
-      i--
-      continue
-    }
-    kept.push(lines[i])
-  }
-  return kept.join("\n").replace(/\n{3,}/g, "\n\n").trim()
-}
-
-function setScalar(frontmatter, key, value) {
-  const line = `${key}: ${value}`
-  // String operations rather than a built RegExp: `key` is one of this module's
-  // own constants, so the pattern would be safe, but a dynamic regexp here is a
-  // ReDoS-shaped pattern that static analysis rightly refuses to clear.
-  const lines = frontmatter.split(/\r?\n/)
-  const index = lines.findIndex(current => current.startsWith(`${key}:`))
-  if (index === -1) {
-    return frontmatter ? `${line}\n${frontmatter}` : line
-  }
-  lines[index] = line
-  return lines.join("\n")
-}
-
-function permissionsYaml(permissions) {
-  return [
-    "permissions:",
-    ...permissions.flatMap(p => [
-      `  - action: ${p.action}`,
-      `    resource: ${p.resource}`,
-      `    effect: ${p.effect}`,
-    ]),
-  ].join("\n")
-}
-
-/** The colour line an agent should have, or null when the current one is right. */
-function colorLineFor(name, rawCurrent) {
-  const current = unquoteColor(rawCurrent)
-  const target = shouldDeriveColor(current) ? agentColor(name) : current
-  const rendered = yamlColor(target)
-  return (rawCurrent ?? "").trim() === rendered ? null : `color: ${rendered}`
-}
-
-const FULLSTACK_NAME = "fullstack-engineer"
-const FULLSTACK_TEMPLATE = `${FULLSTACK_NAME}.md`
-
-/** Rewrite a template's frontmatter to a clean V2 subagent definition. */
-function normalizeTemplate(content, name) {
-  const { frontmatter, body } = splitFrontmatter(content)
-  if (frontmatter === null) return `---\nmode: subagent\ncolor: ${yamlColor(agentColor(name))}\n---\n\n${content}`
-
-  let fm = stripLegacyFields(frontmatter)
-  fm = setScalar(fm, "mode", "subagent")
-  const colorLine = colorLineFor(name, fm.match(/^color:\s*(.+)$/m)?.[1])
-  if (colorLine) fm = setScalar(fm, "color", colorLine.slice("color: ".length))
-  return `---\n${fm}\n---\n${body}`
-}
-
-/** A tier-pinned copy of a specialist: same body, resolved model. */
-function buildVariant(templateContent, model) {
-  const { frontmatter, body } = splitFrontmatter(templateContent)
-  let fm = stripLegacyFields(frontmatter ?? "")
-  fm = setScalar(fm, "mode", "subagent")
-  fm = setScalar(fm, "model", model)
-  // Hidden by default: a tier is chosen by whoever writes the task, not picked
-  // from the @ menu. Without this the menu lists every specialist once per tier.
-  fm = setScalar(fm, "hidden", "true")
-  if (!/^color:/m.test(fm)) {
-    const name = ""
-    fm = setScalar(fm, "color", name ? yamlColor(agentColor(name)) : yamlColor(agentColor("engineer")))
-  }
-  return `---\n${fm}\n---\n${body}`
-}
-
-/**
- * Build a primary from the fullstack body: same identity and the same
- * ## Abilities block, with our own frontmatter on top. The body is taken
- * verbatim so /make-engineer only has to maintain fullstack-engineer.md and
- * both primaries inherit whatever it lists.
- */
-function buildPrimary(spec, fullstackContent, model) {
-  const { body } = splitFrontmatter(fullstackContent)
-  const lines = [
-    "---",
-    `description: ${spec.description}`,
-    `mode: ${spec.mode ?? "primary"}`,
-  ]
-  if (model) lines.push(`model: ${model}`)
-  lines.push(`color: ${yamlColor(spec.color)}`)
-  if (spec.permissions) lines.push(permissionsYaml(spec.permissions))
-  lines.push("---")
-  return `${lines.join("\n")}\n\n${body.trim()}\n`
-}
-
-async function readJson(filePath) {
-  try {
-    return JSON.parse(await fs.readFile(filePath, "utf-8"))
-  } catch {
-    return null
-  }
-}
-
-async function scanEngineers(agentsDir) {
-  try {
-    const entries = await fs.readdir(agentsDir)
-    return {
-      templates: entries
-        .filter(f => /^[\w-]+-engineer\.md$/.test(f) && f !== FULLSTACK_TEMPLATE)
-        .map(f => f.replace(/\.md$/, "")),
-      variantFiles: entries.filter(f => /^[\w-]+-engineer\.(build|fast|plan)\.md$/.test(f)),
-      hasFullstack: entries.includes(FULLSTACK_TEMPLATE),
-    }
-  } catch {
-    return { templates: [], variantFiles: [], hasFullstack: false }
-  }
-}
-
-async function writeIfChanged(filePath, content) {
-  try {
-    if ((await fs.readFile(filePath, "utf-8")) === content) return
-  } catch {
-    // file missing, write it
-  }
-  const tmpPath = `${filePath}.tmp`
-  await fs.writeFile(tmpPath, content, "utf-8")
-  await fs.rename(tmpPath, filePath)
-}
+import { Plugin, Model } from "@opencode/plugin";
+import { PRIMARIES, generateAgents } from "./pc-subagent-tiers-core.js";
 
 export default Plugin.define({
   id: "pc.subagent-tiers",
   async setup(ctx) {
-    const root = ctx.location.directory
-    const agentsDir = path.join(root, ".opencode", "agents")
+    const root = ctx.location.directory;
 
     try {
-      const [user, team] = await Promise.all([
-        readJson(path.join(root, ".opencode", "harness.user.json")),
-        readJson(path.join(root, ".opencode", "harness.json")),
-      ])
-      const models = {}
-      for (const tier of TIERS) {
-        models[tier] = user?.models?.[tier] ?? team?.models?.[tier] ?? null
+      const result = await generateAgents({ root });
+
+      console.error(
+        `[pc-subagent-tiers] Wrote primaries: build (${result.models.build ?? "session model"}), plan and planner (${result.models.plan ?? "session model"})`,
+      );
+      if (result.variants.length > 0) {
+        console.error(
+          `[pc-subagent-tiers] Created ${result.variants.length} variant files (${result.templates.length} engineers x ${Object.values(result.models).filter(Boolean).length} tiers)`,
+        );
+      } else if (result.templates.length > 0) {
+        console.error(`[pc-subagent-tiers] No variants created. Models: ${JSON.stringify(result.models)}`);
       }
-      const available = TIERS.filter(t => models[t])
-
-      const { templates, variantFiles, hasFullstack } = await scanEngineers(agentsDir)
-
-      if (hasFullstack) {
-        const fullstackPath = path.join(agentsDir, FULLSTACK_TEMPLATE)
-        const rawFullstack = await fs.readFile(fullstackPath, "utf-8")
-        const fullstack = normalizeTemplate(rawFullstack, FULLSTACK_NAME)
-        if (fullstack !== rawFullstack) {
-          await writeIfChanged(fullstackPath, fullstack)
-          console.error("[pc-subagent-tiers] Normalized fullstack-engineer.md (V2 subagent)")
-        }
-
-        for (const [name, spec] of Object.entries(PRIMARIES)) {
-          await writeIfChanged(
-            path.join(agentsDir, `${name}.md`),
-            buildPrimary(spec, fullstack, models[spec.tier]),
-          )
-        }
-        console.error(`[pc-subagent-tiers] Wrote primaries: build (${models.build ?? "session model"}), plan and planner (${models.plan ?? "session model"})`)
-      } else {
-        console.error(`[pc-subagent-tiers] ${FULLSTACK_TEMPLATE} missing: build and plan not generated`)
-      }
-
-      const keepSet = new Set()
-      const variantsToWrite = []
-      for (const name of templates) {
-        const rawContent = await fs.readFile(path.join(agentsDir, `${name}.md`), "utf-8")
-        const content = normalizeTemplate(rawContent, name)
-        if (content !== rawContent) {
-          await writeIfChanged(path.join(agentsDir, `${name}.md`), content)
-          console.error(`[pc-subagent-tiers] Normalized ${name}.md (V2 subagent)`)
-        }
-        for (const tier of available) {
-          const file = `${name}.${tier}.md`
-          variantsToWrite.push({ file, path: path.join(agentsDir, file), content: buildVariant(content, models[tier]) })
-          keepSet.add(file)
-        }
-      }
-
-      await Promise.all(variantsToWrite.map(v => writeIfChanged(v.path, v.content)))
-      await Promise.all(
-        variantFiles.filter(f => !keepSet.has(f)).map(f => fs.unlink(path.join(agentsDir, f)).catch(() => {})),
-      )
-
-      if (variantsToWrite.length > 0) {
-        console.error(`[pc-subagent-tiers] Created ${variantsToWrite.length} variant files (${templates.length} engineers x ${available.length} tiers)`)
-      } else if (templates.length > 0) {
-        console.error(`[pc-subagent-tiers] No variants created. Models: ${JSON.stringify(models)}`)
+      for (const warning of result.warnings) {
+        console.error(`[pc-subagent-tiers] Warning: ${warning}`);
       }
 
-      // Best effort: if V2 already discovered these agents (same startup), pin
-      // the primaries' model and plan's read-only permissions in memory too.
       if (typeof ctx.agent?.transform === "function") {
-        await ctx.agent.transform(editor => {
+        await ctx.agent.transform((editor) => {
           for (const [id, spec] of Object.entries(PRIMARIES)) {
-            const existing = editor.get(id)
-            if (!existing) continue
-            const model = models[spec.tier]
+            const existing = editor.get(id);
+            if (!existing) continue;
+            const model = result.models[spec.tier];
             if (model) {
               try {
-                existing.model = Model.Ref.parse(model)
+                existing.model = Model.Ref.parse(model);
               } catch {
-                // invalid model ref; leave undefined so session model applies
+                // invalid model ref; leave undefined so the session model applies
               }
             }
-            existing.mode = spec.mode ?? "primary"
-            existing.description = spec.description
-            if (spec.permissions) existing.permissions = spec.permissions
+            existing.mode = spec.mode ?? "primary";
+            existing.description = spec.description;
+            if (spec.permissions) existing.permissions = spec.permissions;
           }
-        })
-        await ctx.agent.reload?.()
+        });
+        await ctx.agent.reload?.();
       }
     } catch (error) {
-      console.error(`[pc-subagent-tiers] Error: ${error?.message}`)
+      console.error(`[pc-subagent-tiers] Error: ${error?.message}`);
     }
   },
-})
+});

package/harness/.opencode/scripts/harness-doctor.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+// Print the effective model routing and the generated agents. --strict exits 1
+// on any warning, a missing planner-sub, or a manifest older than its configs.
+
+import fs from "node:fs";
+import path from "node:path";
+
+const args = process.argv.slice(2);
+const rootIndex = args.indexOf("--root");
+const root = rootIndex !== -1 ? path.resolve(args[rootIndex + 1]) : process.cwd();
+const strict = args.includes("--strict");
+const manifestPath = path.join(root, ".opencode", "harness-models.json");
+
+function fail(message, code = 1) {
+  console.error(message);
+  process.exit(code);
+}
+
+if (!fs.existsSync(manifestPath)) {
+  fail(`harness-doctor: ${manifestPath} is missing; run node .opencode/scripts/sync-agents.mjs`, 2);
+}
+
+let manifest;
+try {
+  manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+} catch (error) {
+  fail(`harness-doctor: ${manifestPath} is not valid JSON: ${error.message}`, 2);
+}
+
+const models = manifest.models ?? {};
+const sources = manifest.source ?? {};
+const warnings = Array.isArray(manifest.warnings) ? manifest.warnings : [];
+const agents = manifest.agents ?? {};
+const planner = agents["planner-sub"] ?? agents.planner;
+const plannerFile = planner?.file ? path.join(root, ".opencode", "agents", planner.file) : null;
+const plannerExists = plannerFile ? fs.existsSync(plannerFile) : false;
+
+console.log("Model routing");
+console.log(`  ${"tier".padEnd(6)} ${"effective".padEnd(40)} source`);
+for (const tier of ["plan", "build", "fast"]) {
+  console.log(`  ${tier.padEnd(6)} ${String(models[tier] ?? "(session)").padEnd(40)} ${sources[tier] ?? "missing"}`);
+}
+console.log(`  ${"lead".padEnd(6)} ${"session model (ci-workflow-agent)".padEnd(40)} session`);
+console.log(`  ${"planner".padEnd(6)} ${String(planner?.model ?? "(session)").padEnd(40)} ${planner?.mode ?? "missing"}`);
+console.log(`  planner file: ${plannerFile ? `${planner.file}${plannerExists ? "" : " (missing)"}` : "missing"}`);
+console.log(`  agents: ${Object.keys(agents).length} entries, ${warnings.length} warning(s)`);
+
+for (const warning of warnings) console.error(`warning: ${warning}`);
+
+if (strict && (!planner || !plannerExists || warnings.length > 0)) {
+  process.exit(1);
+}

package/harness/.opencode/scripts/harness-doctor.test.mjs

@@ -0,0 +1,58 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, describe, expect, it } from "vitest";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const SCRIPT = path.join(HERE, "harness-doctor.mjs");
+let root;
+
+function fixture(manifest) {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), "harness-doctor-"));
+  const opencode = path.join(root, ".opencode");
+  fs.mkdirSync(path.join(opencode, "agents"), { recursive: true });
+  fs.writeFileSync(path.join(opencode, "harness-models.json"), JSON.stringify(manifest, null, 2));
+  return opencode;
+}
+
+afterEach(() => {
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe("harness doctor", () => {
+  it("prints the effective routing and the planner alias", () => {
+    fixture({
+      models: {
+        plan: "plainconcepts/glm-5-3",
+        build: "plainconcepts/glm-5-2",
+        fast: "plainconcepts/glm-5-2",
+      },
+      source: { plan: "team", build: "team", fast: "team" },
+      agents: {
+        "planner-sub": { file: "planner-sub.md", mode: "subagent", model: "plainconcepts/glm-5-3" },
+      },
+      warnings: [],
+    });
+    fs.writeFileSync(path.join(root, ".opencode", "agents", "planner-sub.md"), "---\nmode: subagent\n---\n");
+
+    const output = execFileSync(process.execPath, [SCRIPT, "--root", root, "--strict"], { encoding: "utf8" });
+    expect(output).toContain("Model routing");
+    expect(output).toContain("plainconcepts/glm-5-3");
+    expect(output).toContain("planner-sub.md");
+  });
+
+  it("fails strict when the planner alias is missing", () => {
+    fixture({
+      models: { plan: "p/plan", build: "p/build", fast: "p/fast" },
+      source: { plan: "team", build: "team", fast: "team" },
+      agents: {},
+      warnings: [],
+    });
+
+    const result = spawnSync(process.execPath, [SCRIPT, "--root", root, "--strict"], { encoding: "utf8" });
+    expect(result.status).toBe(1);
+    expect(result.stdout).toContain("planner file: missing");
+  });
+});

package/harness/.opencode/scripts/sync-agents.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// Generate the build/plan/planner/planner-sub agents and the tier variants
+// before OpenCode starts. CI runs this in a pre-agent step so the task tool's
+// enum includes them from the first turn. Local users can run it too.
+
+import path from "node:path";
+import { generateAgents } from "../plugins/pc-subagent-tiers-core.js";
+
+const args = process.argv.slice(2);
+const rootIndex = args.indexOf("--root");
+const root = rootIndex !== -1 ? path.resolve(args[rootIndex + 1]) : process.cwd();
+const strict = args.includes("--strict");
+
+try {
+  const result = await generateAgents({ root });
+  console.log(`Model routing (${path.join(root, ".opencode", "harness-models.json")})`);
+  for (const tier of ["plan", "build", "fast"]) {
+    console.log(`  ${tier.padEnd(6)} ${String(result.models[tier] ?? "(session)").padEnd(40)} ${result.sources[tier]}`);
+  }
+  console.log(
+    `  agents ${result.templates.length} engineer template(s), ${result.variants.length} variant(s), ` +
+      `${result.hasFullstack ? "planner + planner-sub" : "planner missing (no fullstack)"}`,
+  );
+  for (const warning of result.warnings) console.error(`warning: ${warning}`);
+  if (strict && result.warnings.length > 0) process.exit(1);
+} catch (error) {
+  console.error(`sync-agents: ${error?.message ?? error}`);
+  process.exit(1);
+}

package/harness/AGENTS.md

@@ -43,7 +43,13 @@ The `pc-plan-apply` skill is authoritative for subagent waves, dependency orderi
 
 ## Skills
 
-Skills live in `.agents/skills/`. Always installed: `@pc-guardrails-generic`, `@pc-guardrails-project`, and `@browser-automation`. An entry under `## Abilities` is not a passive reference: call the `skill` tool once per `@skill-name`, guardrails first. Editing, shell and spawning stay blocked until you have (`pc-system-reminders`), and a loaded skill can require further loads.
+Skills live in `.agents/skills/`. Always installed: `@pc-guardrails-generic`, `@pc-guardrails-project`, and `@browser-automation`.
+
+<!-- PC-PLATFORM-SKILLS-START -->
+Mandatory, before any edit, shell command or subagent spawn: read `.agents/skills/pc-guardrails-generic/SKILL.md`, then `.agents/skills/pc-guardrails-project/SKILL.md` if present. They are instructions, not references: a loaded skill may name further skills, and those load too before the work they cover.
+<!-- PC-PLATFORM-SKILLS-END -->
+
+An entry under `## Abilities` is not a passive reference: call the `skill` tool once per `@skill-name`, guardrails first. Editing, shell and spawning stay blocked until you have (`pc-system-reminders`), and a loaded skill can require further loads.
 
 <!-- PC-PLATFORM-SKILLS-GUIDE-START -->
 <!-- PC-PLATFORM-SKILLS-GUIDE-END -->

package/harness/opencode.jsonc

@@ -2,9 +2,9 @@
   "$schema": "https://opencode.ai/config.json",
   "mcp": {
     "servers": {
-      "agent-browser": {
+      "browse": {
         "type": "local",
-        "command": ["agent-browser", "mcp", "--tools", "core"],
+        "command": ["browse", "mcp"],
         "disabled": false
       }
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plainconceptsplatform/agent-harness",
-  "version": "3.8.2",
+  "version": "3.9.0-alpha.1",
   "description": "Installs the Plain Concepts Platform Harness into any codebase, and keeps it up to date. Wires OpenCode, OpenSpec, codegraph, and agentmemory into a multi-agent workflow that runs on native parallel subagents.",
   "keywords": [
     "opencode",

package/skills/agent-harness-cli/SKILL.md

@@ -40,7 +40,7 @@ copy            Copy agents, skills, commands, docs into the repo
 openspec        Initialize the OpenSpec workspace
 models          Choose plan / build / fast models
 optimization    Configure RTK, quota, Simple English, codegraph, agentmemory, humanizer
-browser         Install agent-browser (npm package + its Chrome for Testing)
+browser         Install browse (npm package + browser extension pairing)
 metadata        Rewrite .opencode/harness.json
 ```