opencode-codeops 2.2.0 → 2.3.0

package/discovery-ui/dist/index.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="csp-nonce" content="__CSP_NONCE__" />
+    <link
+      rel="icon"
+      href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII="
+    />
+    <title>Discovery</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" nonce="__CSP_NONCE__" src="/assets/app.js"></script>
+  </body>
+</html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-codeops",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Specification-first engineering for complex systems — CodeOps plugin for OpenCode",
   "type": "module",
   "engines": {
@@ -11,14 +11,17 @@
   "exports": {
     ".": "./plugin/index.ts",
     "./server": "./plugin/index.ts",
-    "./tui": "./plugin/tui.tsx"
+    "./tui": "./plugin/tui.js"
   },
   "bin": {
     "opencode-codeops": "bin/index.mjs"
   },
   "scripts": {
     "test": "node --test",
-    "typecheck": "tsc --noEmit",
+    "build:tui": "node scripts/build-tui.mjs",
+    "build:discovery": "node scripts/build-discovery-ui.mjs",
+    "prepack": "npm run build:discovery",
+    "typecheck": "tsc --noEmit && tsc -p discovery-ui --noEmit",
     "check:version": "node scripts/check-version.mjs",
     "verify": "npm run typecheck && npm run test && npm run check:version",
     "prepublishOnly": "npm run verify"
@@ -39,6 +42,8 @@
     "!bin/*.test.mjs",
     "!bin/*.spec.test.mjs",
     "references/",
+    "discovery-ui/dist/",
+    "!discovery-ui/src/",
     "schemas/",
     "install.sh",
     "README.md",
@@ -71,9 +76,17 @@
     "@opencode/plugin": "^2.0.24"
   },
   "devDependencies": {
+    "@fluentui/react-components": "^9.74.11",
+    "@fluentui/react-icons": "^2.0.344",
+    "@griffel/react": "^1.7.8",
     "@opentui/core": "0.5.17",
     "@opentui/solid": "0.5.17",
     "@types/node": "^22.20.2",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "esbuild": "^0.28.2",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
     "solid-js": "1.9.12",
     "typescript": "^5.0.0"
   },

package/plugin/index.ts

@@ -14,6 +14,11 @@ import {
   registerCodeOpsProgressTool,
 } from "../bin/lib/codeops-progress.mjs"
 import { registerCodeOpsRpc } from "../bin/lib/codeops-rpc.mjs"
+import {
+  createDiscoveryController,
+  registerDiscoveryTools,
+} from "../bin/lib/discovery-tools.mjs"
+import { resolveDataDir } from "../bin/lib/discovery-store.mjs"
 import {
   appendEffortTrace,
   applyEffort,
@@ -221,6 +226,13 @@ export default Plugin.define({
   async setup(ctx) {
     const directory = ctx.location.directory
 
+    // Discovery is opt-in; the controller is declared here so the
+    // session.deleted branch below can reach it.
+    let discovery: ReturnType<typeof createDiscoveryController> | null = null
+    // Read through a function so the later assignment is visible to the
+    // long-lived event loop without a cast.
+    const currentDiscovery = () => discovery
+
     // Reasoning-effort state lives for the lifetime of this plugin instance:
     // the latest dispatch-marker level per session, plus a deduplication set
     // for unsupported-level warnings.
@@ -255,6 +267,7 @@ export default Plugin.define({
           if (event.type === "session.deleted") {
             effortMarkers.delete(event.data.sessionID)
             progress.clearSession(event.data.sessionID)
+            await currentDiscovery()?.onSessionDeleted(event.data.sessionID)
           }
         }
       } catch {
@@ -438,11 +451,39 @@ export default Plugin.define({
     }
 
     // ---------------------------------------------------------------------
-    // Plugin cleanup: stop listening for events. The runtime's scratch
-    // directory is deliberately left in place — other sessions may still be
-    // using it — and the startup sweep reclaims abandoned directories.
+    // Discovery: opt-in browser-based question rounds. The controller owns the
+    // process-wide listener and its store; a disabled project creates nothing,
+    // so the plugin behaves exactly as before.
+    // ---------------------------------------------------------------------
+    try {
+      const controllerForDiscovery = createDiscoveryController(ctx, {
+        directory,
+        dataDir: resolveDataDir(process.env),
+        assetsDir: join(PACKAGE_ROOT, "discovery-ui", "dist"),
+        version: packageVersion,
+        warn: warnContentFree,
+      })
+      discovery = controllerForDiscovery
+      await controllerForDiscovery.sync()
+      await ctx.session.hook("context", async () => {
+        await discovery?.sync()
+      })
+      const registered = await registerDiscoveryTools(ctx, controllerForDiscovery)
+      if (!registered) {
+        warnContentFree("The Discovery tools are unavailable in this OpenCode build.")
+      }
+    } catch {
+      warnContentFree("Could not set up Discovery.")
+    }
+
+    // ---------------------------------------------------------------------
+    // Plugin cleanup: unregister Discovery, then stop listening for events.
+    // The runtime's scratch directory is deliberately left in place — other
+    // sessions may still be using it — and the startup sweep reclaims
+    // abandoned directories.
     // ---------------------------------------------------------------------
-    return () => {
+    return async () => {
+      await discovery?.dispose()
       controller.abort()
     }
   },

package/plugin/tui.js

@@ -0,0 +1,113 @@
+// Generated from plugin/tui.tsx — do not edit; run `npm run build:tui` to regenerate.
+import { insert as _$insert } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+/**
+ * The CodeOps TUI entry: the live run-progress view in the session sidebar.
+ *
+ * The view is deliberately honest: it shows only reported values from the
+ * server's run state, always with an as-of time, and it renders nothing when
+ * there is no run, when the host lacks the events API, or when every call
+ * fails. There are no timers — the text recomputes whenever the component
+ * re-renders — and no file access; all display and merge logic lives in the
+ * shared helper module so it can be tested under plain Node.
+ *
+ * @module tui
+ */
+
+import { Plugin, usePlugin } from "@opencode/plugin/tui";
+import { createEffect, createResource, createSignal, onCleanup, Show } from "solid-js";
+import { acceptRunCleared, acceptRunUpdate, describeRun, mergeRunState } from "../bin/lib/codeops-progress.mjs";
+import { CodeOpsRpc, requestProgress } from "../bin/lib/codeops-rpc.mjs";
+
+/**
+ * The live run-progress view.
+ *
+ * Resolves the session's location once, subscribes to the `updated` and
+ * `cleared` events before requesting an initial snapshot, and merges both
+ * delivery paths monotonically. A clear records its server-stamped
+ * `clearedAt`; both merge paths ignore deliveries at or before it, so a late
+ * snapshot or update can never resurrect a cleared run. Every failure path is
+ * silent: a host without the events API still renders from the snapshot, and
+ * an invalid or missing snapshot renders nothing.
+ *
+ * @returns The three display lines, or nothing when no run is known.
+ */
+function CodeOpsProgress() {
+  const context = usePlugin();
+  const location = context.location ?? context.data.location.default();
+  const directory = location?.directory ?? "";
+  const [run, setRun] = createSignal(null);
+  const [clearedAt, setClearedAt] = createSignal(0);
+
+  // Subscribe BEFORE the snapshot: events are live-only, so a snapshot
+  // fetched first could miss an update arriving in between. Guarded: a host
+  // without the events API still renders from the snapshot below.
+  const stops = [];
+  try {
+    const events = context.client.rpc(CodeOpsRpc).events;
+    const stopUpdated = events.on("updated", event => {
+      const snapshot = acceptRunUpdate(event, directory);
+      if (snapshot && snapshot.updatedAt > clearedAt()) {
+        setRun(current => mergeRunState(current, snapshot));
+      }
+    });
+    stops.push(stopUpdated);
+    const stopCleared = events.on("cleared", event => {
+      const cleared = acceptRunCleared(event, directory);
+      if (!cleared) return;
+      // Record the clear time for every accepted clear, before the identity
+      // gate: a clear that arrives before the initial snapshot must still
+      // suppress that snapshot, or a cleared run could reappear.
+      setClearedAt(cleared.clearedAt);
+      const current = run();
+      if (current && cleared.plan === current.plan && cleared.sessionID === current.sessionID) {
+        setRun(null);
+      }
+    });
+    stops.push(stopCleared);
+  } catch {
+    // Events unavailable: the snapshot-only view below still renders.
+  }
+  onCleanup(() => stops.forEach(stop => stop()));
+
+  // Initial snapshot; null or a failure means "nothing known". The clear
+  // guard applies here too: a snapshot at or before the last clear is ignored.
+  const [initial] = createResource(async () => requestProgress(context.client, {
+    location
+  }));
+  createEffect(() => {
+    const snapshot = initial();
+    if (snapshot && snapshot.updatedAt > clearedAt()) {
+      setRun(current => mergeRunState(current, snapshot));
+    }
+  });
+  return _$createComponent(Show, {
+    get when() {
+      return run();
+    },
+    children: snapshot => {
+      const view = () => describeRun(snapshot(), Date.now());
+      return _$memo(() => view().lines.map(line => (() => {
+        var _el$ = _$createElement("text");
+        _$insert(_el$, line);
+        return _el$;
+      })()));
+    }
+  });
+}
+
+/**
+ * The opencode-codeops TUI plugin: claims the sidebar content slot with the
+ * live run view. The host disposes the claim when the plugin unloads.
+ */
+export default Plugin.define({
+  id: "opencode-codeops-tui",
+  setup(context) {
+    return context.ui.slot({
+      append: "sidebar.content",
+      render: () => _$createComponent(CodeOpsProgress, {})
+    });
+  }
+});

package/schemas/codeops-config.schema.json

@@ -46,6 +46,14 @@
         }
       }
     },
+    "discovery": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {"type": "boolean"},
+        "chatMaxQuestions": {"type": "integer", "minimum": 0}
+      }
+    },
     "metrics": {
       "type": "object",
       "additionalProperties": false,

package/scripts/build-discovery-ui.mjs

@@ -0,0 +1,59 @@
+/**
+ * Build the Discovery web app into a self-contained bundle.
+ *
+ * esbuild bundles `discovery-ui/src/main.tsx` into `<outdir>/assets/app.js`
+ * and copies the HTML template beside it. The listener serves that directory;
+ * no remote asset is referenced, so the page works offline and under the
+ * nonce-based CSP.
+ *
+ * @module build-discovery-ui
+ */
+
+import { cpSync, mkdirSync, rmSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+
+import { build } from "esbuild"
+
+/** The repository root. */
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
+
+/**
+ * Build the app.
+ *
+ * @param {{ outdir?: string, metafile?: boolean }} [options] - Output directory
+ *   (defaults to `discovery-ui/dist`) and whether to return the metafile.
+ * @returns {Promise<{ metafile?: object }>} The esbuild metafile when requested.
+ */
+export async function buildDiscoveryUi(options = {}) {
+  const outdir = options.outdir ?? join(ROOT, "discovery-ui", "dist")
+  const metafile = options.metafile !== false
+  rmSync(outdir, { recursive: true, force: true })
+  mkdirSync(join(outdir, "assets"), { recursive: true })
+
+  const result = await build({
+    absWorkingDir: ROOT,
+    entryPoints: [join(ROOT, "discovery-ui", "src", "main.tsx")],
+    outfile: join(outdir, "assets", "app.js"),
+    bundle: true,
+    format: "esm",
+    minify: true,
+    target: "es2022",
+    jsx: "automatic",
+    define: { "process.env.NODE_ENV": '"production"' },
+    metafile,
+    logLevel: "silent",
+  })
+
+  cpSync(join(ROOT, "discovery-ui", "index.html"), join(outdir, "index.html"))
+  return { metafile: result.metafile }
+}
+
+const invokedDirectly =
+  process.argv[1] !== undefined && resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+
+if (invokedDirectly) {
+  const { metafile } = await buildDiscoveryUi()
+  const outputs = Object.keys(metafile?.outputs ?? {})
+  console.error(`Discovery UI built: ${outputs.join(", ")}`)
+}

package/scripts/build-tui.mjs

@@ -0,0 +1,73 @@
+/**
+ * Build the packaged TUI entry.
+ *
+ * OpenCode transpiles plugin TSX with its OpenTUI renderer runtime only for
+ * files outside `node_modules`. A published package always installs into
+ * `node_modules`, so a source `.tsx` entry falls back to the default React
+ * JSX transform and fails to load ("Cannot find package 'react'"). Compiling
+ * `plugin/tui.tsx` with `@opentui/solid`'s own transform — the same pipeline
+ * the host applies to project-local plugins — produces a plain-JavaScript
+ * entry whose runtime imports (`@opentui/solid`, `solid-js`) the host
+ * rewrites to its bundled renderer.
+ *
+ * The generated artifact `plugin/tui.js` is committed and shipped as the
+ * `./tui` export; `scripts/tui-entry-build.spec.test.mjs` fails when it is
+ * stale, so the release verification blocks a stale entry.
+ *
+ * @module build-tui
+ */
+
+import { readFileSync, writeFileSync } from "node:fs"
+import { createRequire } from "node:module"
+import { dirname, join } from "node:path"
+import { fileURLToPath, pathToFileURL } from "node:url"
+
+/** Repository root: this file lives in `<root>/scripts/`. */
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
+
+/** Source of the TUI entry, authored as TSX. */
+const SOURCE = join(ROOT, "plugin", "tui.tsx")
+
+/** Generated JavaScript entry shipped as `./tui`. */
+const TARGET = join(ROOT, "plugin", "tui.js")
+
+/** Header marking the artifact as generated. */
+const HEADER =
+  "// Generated from plugin/tui.tsx — do not edit; run `npm run build:tui` to regenerate.\n"
+
+/**
+ * Load `@opentui/solid`'s Solid JSX transform.
+ *
+ * The transform module is not part of the package's public exports map, so it
+ * is resolved through the package root: resolve the package entry point, then
+ * import the transform beside it.
+ *
+ * @returns The `transformSolidSource(code, options)` function.
+ */
+async function loadTransform() {
+  const require = createRequire(join(ROOT, "scripts", "build-tui.mjs"))
+  const packageEntry = require.resolve("@opentui/solid")
+  const modulePath = join(dirname(packageEntry), "scripts", "solid-transform.js")
+  const module = await import(pathToFileURL(modulePath).href)
+  return module.transformSolidSource
+}
+
+/**
+ * Compile the current `plugin/tui.tsx` into the shipped entry source.
+ *
+ * @returns The complete `plugin/tui.js` content, header included.
+ */
+export async function buildTuiSource() {
+  const transformSolidSource = await loadTransform()
+  const source = readFileSync(SOURCE, "utf8")
+  const transformed = await transformSolidSource(source, { filename: SOURCE })
+  const code = typeof transformed === "string" ? transformed : transformed.code
+  return HEADER + code
+}
+
+// When run directly (`npm run build:tui`), regenerate the committed artifact.
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const code = await buildTuiSource()
+  writeFileSync(TARGET, code)
+  console.log(`built plugin/tui.js (${code.length} chars)`)
+}

package/skills/analyze-project/SKILL.md

@@ -26,6 +26,25 @@ description: Analyze the current repository and create or refresh concise CodeOp
 9. Validate every recorded command or mark it explicitly unverified.
 10. Specialist coverage: read `codeops/specialist-check.json` when present and include a `Specialist coverage:` line in the managed section — `up to date (<YYYY-MM-DD>)` (from `checkedAt`) when the recorded plan set matches the current one; `check due — run analyze-agents` otherwise; when the state is absent or corrupt, render `check due — run analyze-agents (never checked)`. The `analyze-agents` skill runs the check (criteria: [../../_shared/specialist-agents.md](../../_shared/specialist-agents.md)); when a specialization signal is strong and no specialist covers it, report the candidate with evidence and recommend the `setup-routing` creation flow; never write agent files here. Preserve the `<!-- CODEOPS-SPECIALISTS:START -->` / `<!-- CODEOPS-SPECIALISTS:END -->` block byte-for-byte when refreshing the managed section.
 
+## Discovery switch
+
+`analyze-project` accepts `--with-discovery` and `--without-discovery`; passing both flags is a usage error. Both flags validate `codeops/codeops.json` against `schemas/codeops-config.schema.json` before changing anything: an invalid file stops the run with its schema errors and writes nothing (never discard malformed quality, routing, or metrics policy). Refuse to write when `codeops/` or `codeops/codeops.json` is a symlink or not a regular file; never write through a link.
+
+- `--with-discovery`: set `discovery.enabled: true`, keeping every other key. When no file exists, create the minimal AR-35 file with the layout resolved from `_shared/layout-convention.md` (`nested` → `codeops`, `flat` → `.`):
+  ```json
+  {
+    "schema": 1,
+    "mode": "strict",
+    "artifacts": { "layout": "flat", "root": "." },
+    "discovery": { "enabled": true }
+  }
+  ```
+  A newly created file always contains the `discovery` object. Preview the config change, then write it.
+- `--without-discovery`: set `discovery.enabled: false`, keeping `chatMaxQuestions` and every other key. When no config exists, change no config; the managed line is simply removed.
+- **Managed block (derived state).** On every run, including runs with neither flag, render this line immediately after `Specialist coverage:` when `discovery.enabled` is true:
+  `- Discovery: enabled — question rounds open in the local Discovery page`
+  Keep exactly one copy and replace it in place. On `--without-discovery` remove it by full-line match, including the em dash. Write with the file's dominant line ending. If the `CODEOPS-PROJECT` markers are missing, duplicated, or reversed, stop without writing and name the manual fix. The `CODEOPS-SPECIALISTS` block stays byte-for-byte.
+
 Keep `AGENTS.md` small. Operational routing belongs in `codeops/codeops.json` or `opencode.json`, not prose.
 
 ---

package/skills/make-plan/SKILL.md

@@ -34,6 +34,10 @@ than one or an invalid level is an argument error; announce
 [../../_shared/reasoning-effort.md](../../_shared/reasoning-effort.md) §Auto-effort option. The
 run clears the level before its final summary.
 
+## Discovery option
+
+If `$ARGUMENTS` contains exactly one exact standalone `--no-discovery` token before the first `--` sentinel, remove it before resolving targets, paths, or modes; more than one occurrence is invalid; when present, every question round stays in chat for this run. Read [../../_shared/discovery.md](../../_shared/discovery.md) when Discovery applies.
+
 ## Plan readiness proof
 
 A plan is not ready merely because its documents exist. Before presenting it as executable,
@@ -165,6 +169,8 @@ When a `requirements/` directory exists with `RD-XX-*.md` files (produced by the
 
 Cover at minimum: **Feature scope** (what it does / does NOT do, boundaries), **Technical context** (affected code, existing patterns, constraints), **Dependencies** (prerequisites, external deps), and **Success criteria** (definition of done, required tests, required docs).
 
+When Discovery applies, publish the interview per [../../_shared/discovery.md](../../_shared/discovery.md): groups by category with Scope first, and every question with `why`, `evidence`, and a recommendation. A round within `chatMaxQuestions` stays in chat.
+
 ### 1.2 Analyze current implementation
 
 Read relevant source files; identify affected components; find similar/reference patterns; note technical debt; review project docs and AGENTS.md. If `docs/index.md` exists with `techdocs: true` frontmatter, read the relevant architecture sections first (see the techdocs skill).
@@ -194,7 +200,7 @@ Register is created. No exceptions, no overrides, no "good enough."** Plans buil
 produce code the user did not ask for. Every item in every plan document must trace to an explicit,
 user-confirmed decision.
 
-The mechanism is the **Ambiguity Register** (`00-ambiguity-register.md`): a numbered inventory of every gap, ambiguity, unstated assumption, and open question, hunted systematically across all 12 categories. The full category checklist, register template, gate-enforcement rules, named-deferral policy, traceability requirement, surface-during-authoring rule, and interactions with the grill-me / upgrade-plan skills are in **[zero-ambiguity-gate.md](zero-ambiguity-gate.md)** — **read it now, before Phase 2.**
+The mechanism is the **Ambiguity Register** (`00-ambiguity-register.md`): a numbered inventory of every gap, ambiguity, unstated assumption, and open question, hunted systematically across all 12 categories. When Discovery applies, publish the register review per [../../_shared/discovery.md](../../_shared/discovery.md): one group per register category with Scope first; the register remains the authoritative record. Questions that surface while writing documents stay in chat when the round stays within `chatMaxQuestions`; otherwise add them to a new group on the same plan and republish the full question set. The full category checklist, register template, gate-enforcement rules, named-deferral policy, traceability requirement, surface-during-authoring rule, and interactions with the grill-me / upgrade-plan skills are in **[zero-ambiguity-gate.md](zero-ambiguity-gate.md)** — **read it now, before Phase 2.**
 
 That shared protocol also owns the always-active **Complexity Escalation Gate**. A new layer,
 dependency, harness, framework, infrastructure surface, cross-cutting refactor, or other material

package/skills/preflight/SKILL.md

@@ -43,6 +43,10 @@ as a suggestion only, more than one or an invalid level is an argument error; an
 [../../_shared/reasoning-effort.md](../../_shared/reasoning-effort.md) §Auto-effort option. The
 run clears the level before its final summary.
 
+## Discovery option
+
+If `$ARGUMENTS` contains exactly one exact standalone `--no-discovery` token before the first `--` sentinel, remove it before resolving targets, paths, or modes; more than one occurrence is invalid; when present, every finding stays in chat for this run. Read [../../_shared/discovery.md](../../_shared/discovery.md) when Discovery applies.
+
 Run a rigorous quality audit of the artifact named in `$ARGUMENTS`, **grounded in the actual
 codebase**. Find every issue, ambiguity, contradiction, gap, and risk; verify every claim and
 assumption against the real code; present each finding with options + a recommendation; iterate

package/skills/preflight/report-format.md

@@ -121,6 +121,10 @@ Use the severity icons from SKILL.md (red/orange/yellow/blue circles) in the act
    proposal and collect a distinct `Keep`, `Defer`, or `Discard` ruling. In strict scope, optional
    remediations are not reported.
 
+### Discovery path
+
+When Discovery applies, after the challenger has run, publish all findings as a `preflight` plan grouped **CRITICAL**, **MAJOR**, **MINOR**, and **OBSERVATION**. Each finding is `PF-NNN` of type `single-other`: its options plus "Other" for a custom decision or a dismissal with reasoning. A Defer is recorded as **Accepted Risk** with decision, owner, and revisit. Answers come back as `**User Decision:**` lines. The batch pacing rules below apply only to chat presentation; the previous-decisions rule is unchanged.
+
 ### Batch presentation rules
 
 - **<= 5 findings** — present all at once, let the user respond to each.