omakit 0.1.5 → 0.1.7

package/README.md

@@ -105,9 +105,9 @@ owner's behalf. Zero dependencies, plain ESM, one entry point, no build step.
 
 ```bash
 omakit setup                 # the environment, the pin, tab completion, and what to try first
-omakit submit <plugin-repo> --category <c> --tags <a,b>
+omakit submit <plugin-repo>  # every check, the issue title and body; asks for a category and tags at a terminal
 omakit watch <issue-url>     # the commit the marketplace validated, against the plugin's current HEAD
-omakit verify <plugin-repo>  # the official security baseline over the local transport, reported verbatim
+omakit verify <plugin-repo>  # the official security baseline over the local transport; --json for the document
 omakit parity                # the baseline over GitHub versus the local transport, on real listings; writes the evidence
 omakit doctor                # what is installed, what is pinned, and what has moved
 omakit pin                   # what setup does for the pin, on its own
@@ -126,6 +126,41 @@ that commit. The completion script knows the subcommands and their flags,
 completes a directory for `<target>`, and offers the categories and tags the
 pin's submission form actually has.
 
+`omakit verify` prints the official baseline result alone, with no Omakit
+check around it: the subject, the pin, the transport and what the local
+adapter assumes, then the marketplace's own outcome, each finding as a block
+with its rule id, whether it blocks publication under the pinned policy, the
+file and line, and the official text verbatim, then the marketplace's own
+statement. `--json` prints the document itself, unchanged from earlier
+releases, and `--out <file>` writes it; agents and the skills use those.
+
+`omakit submit` reads the marketplace's registry first, and a run has three
+outcomes. `READY`, exit 0: every blocking check passed and the title and body
+follow. `REFUSED`, exit 1: a blocking check failed and no body is produced.
+`LISTED`, exit 0: the plugin is already listed by its own repository (the
+manifest id is in the catalog, and the listing's repository is the subject's
+declared `origin`, compared as owner and name), so the submission form is not
+the route. Nothing is wrong and nothing was refused: `identity.available`
+passes with the listing's record (since when, which commit, verified or not),
+the five checks that exist only for the body are omitted, nothing is asked,
+and the closing block names the commit the marketplace lists, the local
+commit, whether they are the same, and the marketplace's verification form
+with the choice that lists a newer commit, read from the pin's
+`verify-plugin.yml`. Measured on 0.1.6: this state printed `FAIL
+identity.available`, `REFUSED`, and "Fix it, then run submit again" under a
+remedy that said there was nothing to submit. An id taken by another
+repository, a retired id or a reserved one is still refused. In `--json`, the
+outcome is `outcome: "ready" | "refused" | "listed"`, `ready` stays a boolean
+that is true for the first only, and a listed run carries a `listing` object.
+
+An unlisted plugin needs a category and tags, and they are an editorial
+choice nobody else can make: at a terminal it asks, once each, with the form's
+own lists numbered and the marketplace's own default for the manifest's kinds
+offered where it is on the list; in a pipe, from an agent, or with `--json` it
+is the usage error with the same lists, exit 2. A listed plugin is asked for
+neither. A `READY` or `REFUSED` report ends with the command line that repeats
+the run without asking, and `--json` carries it as `reproduce`.
+
 There is nothing to authenticate. If you have `gh auth login` done, omakit
 reads that credential for GET requests and stores nothing; a token in
 `GH_TOKEN` or `GITHUB_TOKEN` reaches it the same way, because `gh` honours

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omakit",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "The safe place to find out: everything knowable about an Omarchy Quattro plugin submission before you post it, on your own machine. Agent-first, read-only, posts nothing, zero dependencies.",
   "license": "MIT",
   "author": "Maarten Tolhuijs",

package/skills/omarchy-plugin-submit/SKILL.md

@@ -12,6 +12,19 @@ the issue is a separate, explicit act that needs the plugin owner's approval
 first, which is what the marketplace's own agent instructions require. Show the
 owner the title, the body and the verdicts, ask, and only then post it.
 
+## If omakit is not installed
+
+```bash
+npm install --global omakit   # Omarchy ships Node and npm through mise
+omakit doctor                 # node, git, the pin, the credential source, and whether omakit is on PATH
+```
+
+If `omakit` is not found after the install, run
+`"$(npm prefix --global)/bin/omakit" setup`: it prints the one line that puts
+npm's bin on PATH for the shell in `$SHELL`. Keep it current with
+`omakit upgrade`, which updates the tool through npm at the exact version the
+registry names and never moves the marketplace pin.
+
 ## Run it
 
 ```bash
@@ -19,14 +32,32 @@ omakit pin     # once, and after any pin change: fetches the pinned marketplace
 omakit submit <path-to-the-plugin-repo> --category <category> --tags <a,b>
 ```
 
+The pin is a sparse read-only checkout of one marketplace commit under
+`$XDG_CACHE_HOME/omakit/marketplace` (or `~/.cache/omakit/marketplace`). Every
+rule is read from it; nothing about the format is written in the tool.
+
 The plugin's name and id come from the root `manifest.json`. The repository URL
 comes from `origin`. You supply the category and the tags, because nobody else
 can: they are an editorial choice about where the plugin belongs.
 
 If you do not know which category and tags are allowed, run the command without
-them: that is a usage error (exit 2) whose message lists the controlled values,
-read from the pinned form, before any check runs. With `--json` the same lists
-come back under `usage`.
+them: for you, in a pipe or with `--json`, that is a usage error (exit 2) whose
+message lists the controlled values, read from the pinned form; with `--json`
+the same lists come back under `usage`. A person at a terminal is asked
+instead, once each, with the marketplace's own default for the manifest's
+kinds. It is decided after the registry is read: a plugin that is already
+listed is asked for nothing. A `READY` or `REFUSED` report ends with the
+command line that repeats the run without asking, and `--json` carries it as
+`reproduce`.
+
+To see the official baseline result alone, with no Omakit check around it:
+
+```bash
+omakit verify <path-to-the-plugin-repo> --json
+```
+
+`verify` without `--json` prints a report for a person; `--json` is the
+document, unchanged between releases.
 
 Useful flags: `--notes` for the Maintainer notes field, `--suggest-tag` for the
 optional suggestion, `--name` when the manifest has no name, `--json` for a
@@ -41,9 +72,34 @@ HEAD, tell the owner and choose another id.
 
 ## Reading the result
 
-Exit code 0 means every blocking check passed and the output contains the issue
-title and body. Exit code 1 means it refused, and no body was produced. Exit
-code 2 is a usage error: nothing was checked.
+A run ends one of three ways; `--json` carries it as `outcome`.
+
+- `READY`, exit 0, `outcome: "ready"`: every blocking check passed and the
+  output contains the issue title and body.
+- `REFUSED`, exit 1, `outcome: "refused"`: a blocking check failed and no body
+  was produced.
+- `LISTED`, exit 0, `outcome: "listed"`: the plugin is already listed by its
+  own repository. Nothing is wrong and nothing was refused, and there is no
+  body, because the submission form is not the route. See below.
+
+Exit code 2 is a usage error: nothing was checked.
+
+**If the outcome is `listed`, stop.** Do not open a submission issue, and
+never change the plugin id to get past it: the id is listed by this very
+repository, and a renamed id would be a second listing of the same plugin.
+Tell the owner the update route, which the output states: the marketplace
+lists `verificationCommit`; the local commit is `localCommit`, and
+`sameCommit` says whether they are the same; to get a newer commit listed,
+open the marketplace's verification form (its name and the choice to pick,
+"Verify and publish a newer upstream commit", are printed from the pin's own
+form, under `listing.updateRoute` in `--json`), and `omakit watch <the
+submission issue>` shows which commit is listed now. A listed plugin is asked
+for no category and no tags, and the five body checks are omitted rather than
+shown as waiting.
+
+An id listed by a *different* repository is a refusal, `identity.available`
+names that repository, and the remedy is another id. That is the one case
+where changing the id is the fix.
 
 A check drawn as `▒ ?` did not run because one it depends on failed; its detail
 names that check. It is not a failure of its own, and the closing refusal lists

package/skills/omarchy-plugin-validation-watch/SKILL.md

@@ -29,6 +29,12 @@ push came after a review comment had also commented: engaged, and stuck.
 omakit watch https://github.com/omacom/omarchy-plugin-marketplace/issues/<number>
 ```
 
+If `omakit` is not installed: `npm install --global omakit` (Omarchy ships Node
+and npm through mise), then `omakit doctor`; if the command is not found after
+the install, `"$(npm prefix --global)/bin/omakit" setup` prints the one line
+that puts npm's bin on PATH. `omakit upgrade` keeps it current through npm.
+Add `--json` for a machine-readable result.
+
 Read-only. It does not comment, label, or edit anything, and it cannot. It reads
 the default branch through the REST API when a credential is available, taking
 it from the operator's `gh` login (which itself honours `GH_TOKEN` and
@@ -38,7 +44,11 @@ it from the operator's `gh` login (which itself honours `GH_TOKEN` and
 If the diagnosis ends in a resubmission under a new id, run `omakit submit`
 online: never pass `--offline` to get around a listed id, because that reads
 the listed ids from the pin, which is stale within hours, and the marketplace
-refuses against its current registry.
+refuses against its current registry. If `omakit submit` ends `LISTED`
+(`outcome: "listed"` in `--json`), the plugin is already listed by its own
+repository: stop, do not change the id, and tell the owner the update route
+the output names, the marketplace's verification form with the choice "Verify
+and publish a newer upstream commit", read from the pin.
 
 ## Acting on each verdict
 

package/tools/marketplace/README.md

@@ -10,34 +10,36 @@ local commit through the transport seam the marketplace tests itself
 | `pin.mjs` | The pin identity (one home) and the reproducible setup: `omakit pin` fetches exactly that commit into `$XDG_CACHE_HOME/omakit/marketplace` and refuses a modified checkout. |
 | `local-transport.mjs` | Answers the four request shapes the official resolver makes, from a local clone at the exact commit. No network, no credentials, no writes. |
 | `run-baseline.mjs` | Runs the pinned official baseline over either transport and reports the pin identity beside the result. |
-| `verify.mjs` | Builds the `marketplaceBaseline` section: pin, transport, assumptions, the official result verbatim, the statement. |
+| `verify.mjs` | Builds the `marketplaceBaseline` section: pin, transport, assumptions, the official result verbatim, the statement. `omakit verify` renders it for a person (`renderVerify` in `report.mjs`) and prints the document itself behind `--json` and `--out`. |
 | `preflight.mjs` | Translates that result into what it will cause on submission, using the pinned policy, and renders the marketplace's own report text with its attestation marker stripped and asserted absent. |
 | `yaml.mjs` | A deliberately small YAML reader for the pinned issue form. Accepts that subset and throws on anything else. |
-| `form.mjs` | The submission contract, read from the form and cross-checked against the marketplace's own constants. |
-| `registry.mjs` | The plugin-id and repository universe: the reserved namespace from the pinned catalog builder, the listed and retired ids and listed repositories from `registry.json` and `site/catalog.json` at the marketplace's current HEAD when the network is there (cached under `$XDG_CACHE_HOME/omakit/registry/<commit>/`, never in the pin) and at the pin with `--offline`; `liveFileUrl()` is the only way to the raw file host, at a 40-character commit, for those two files. |
+| `form.mjs` | The submission contract, read from the form and cross-checked against the marketplace's own constants. Also the route for a plugin that is already listed: the marketplace's verification form and its "newer commit" choice, read from `verify-plugin.yml` at the pin and cross-checked against `plugin-verification-request.mjs`. |
+| `registry.mjs` | The plugin-id and repository universe: the reserved namespace from the pinned catalog builder, the listed and retired ids and listed repositories from `registry.json` and `site/catalog.json` at the marketplace's current HEAD when the network is there (cached under `$XDG_CACHE_HOME/omakit/registry/<commit>/`, never in the pin) and at the pin with `--offline`; `liveFileUrl()` is the only way to the raw file host, at a 40-character commit, for those two files. `sameRepository()` is the one rule for "the subject's own repository" (owner and name, case-insensitively, a trailing `.git` ignored), and `listingOf()` is what the catalog records about a listing: since when, which commit, verified or not, checked when. |
 | `tree.mjs` | The installable tree of a subject at one exact commit, from the Git object database. |
 | `plugin.mjs` | The root files the submission contract needs, and the declared plugin identity. |
 | `agent-control.mjs` | The recursive agent-control warning, and its remedy. |
 | `issue.mjs` | Renders the issue the way the form would, then has the marketplace's own parser judge it. |
-| `submit.mjs` | Assembles every check with its measured reason, and withholds the body when a blocking check fails. |
+| `submit.mjs` | Assembles every check with its measured reason, and withholds the body when a blocking check fails. Three outcomes: `ready` (the body), `refused` (a blocking check failed) and `listed` (the plugin is already listed by its own repository: `identity.available` passes with the listing's record, the five body checks are omitted rather than drawn as waiting, no body exists on purpose, and `listing` carries the listed commit against the local one and the form to use for a newer commit). Decides the category and tags after the registry: a listed plugin, own or taken, is asked for neither; an unlisted one without them is asked through `ask.mjs` at a terminal, and is a usage error otherwise. Ends with `reproduce`, the command line that repeats the run without asking. |
+| `ask.mjs` | The two questions `submit` asks a person at a terminal, and only there: category and tags, numbered from the pinned form, with the marketplace's own presentation for the manifest's kinds (read from the pinned catalog builder) as the default where it is on the list. Prompts on stderr, nothing persisted. |
 | `watch.mjs` | The validation watch: validated commit versus current default-branch HEAD, and the one action that refreshes it. |
 | `github.mjs` | Read-only GitHub access. GET only. The credential is your `gh` login, read through one frozen `gh auth token` call, and is never written anywhere. |
 | `style.mjs` | The visual system, defined once: the palette, the status vocabulary, the block ramp, the columns, the motion budgets, and the composition helpers every command draws with. `docs/TUI.md` explains it. |
-| `report.mjs` | Text rendering of submit, watch and doctor for the agent that runs this tool, and the person reading over its shoulder. |
+| `report.mjs` | Text rendering of submit, watch, doctor and verify for the agent that runs this tool, and the person reading over its shoulder. |
 | `path-hint.mjs` | Is `omakit` reachable as a bare command, and if not, the one line that makes it so for the install that is here: a symlink for a clone, the npm prefix's `bin` on PATH for a package, said for the shell in `$SHELL`. `setup` and `doctor` print it; nothing writes an rc file. |
 | `usage.mjs` | The help text, as data. |
 | `completion.mjs` | A completion script for bash, zsh or fish, derived from the help data and the pin's form: the subcommands and flags are read out of `COMMANDS`, the categories and tags out of the pinned submission form, and the script says which pin it came from. `setup` installs it for the shell in `$SHELL`, the one file this tool writes outside its own checkout. |
 | `banner.mjs` | The wordmark, on a bare `omakit` and in `setup` only. |
 | `effect.mjs` | The one text effect: the wordmark through `ttfx` where it is drawn, with frozen arguments, a hard budget, no colour of its own, and nothing at all when `ttfx` is not there. |
 | `progress.mjs` | The progress line, on stderr, only when a person is looking. |
-| `cli.mjs` | The one entry point behind `bin/omakit`, and the one register every failure is reported in. |
+| `cli.mjs` | The one entry point behind `bin/omakit`, and the one register every failure is reported in. `submit` exits on the outcome: 1 for `refused`, 0 for `ready` and `listed`. |
 
 ```text
 omakit pin
+omakit submit /path/to/plugin-repo                       # asks for the category and tags at a terminal
 omakit submit /path/to/plugin-repo --category Widgets --tags bar,quickshell
 omakit submit https://github.com/owner/repo@<40-char sha> --category System --tags system
 omakit watch https://github.com/omacom/omarchy-plugin-marketplace/issues/4829
-omakit verify /path/to/plugin-repo
+omakit verify /path/to/plugin-repo                       # --json for the document
 omakit parity --count 30
 ```
 

package/tools/marketplace/ask.mjs

@@ -0,0 +1,140 @@
+// The two questions `omakit submit` asks a person at a terminal, and only
+// there: the category and the tags, which are an editorial choice nobody else
+// can make. Measured before this: `omakit submit <a listed plugin>` exited 2
+// asking for --category and --tags, and would then have refused at
+// identity.available with "nothing to submit"; and an unlisted plugin got the
+// same exit 2 from a person sitting at a terminal who could simply have been
+// asked. So the questions come after the registry, and only when stdin and
+// stdout are both terminals and --json is absent. An agent, a pipe or --json
+// gets the usage error, unchanged.
+//
+// The prompt goes to stderr, so stdout stays the report. The default offered
+// is the marketplace's own presentation for the manifest's kinds, read from
+// the pinned catalog builder (registry.mjs catalogPresentation), and offered
+// only when it is on the form's list. Nothing typed here is written anywhere:
+// the report ends with the command line that repeats the run without asking.
+
+import { createInterface } from "node:readline"
+import { colourEnabled, STEP, action, styler, wrap } from "./style.mjs"
+import { resolveCategory, resolveTags } from "./form.mjs"
+
+export class AskError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = "AskError"
+    this.code = "usage"
+  }
+}
+
+/**
+ * Lines from stdin, one at a time, whether they arrive as they are typed or
+ * were all there before the first question (a scripted run). readline emits
+ * every buffered line at once, so they are queued rather than dropped; the
+ * end of stdin answers null.
+ */
+function reader(input) {
+  const rl = createInterface({ input, terminal: false })
+  const pending = []
+  const waiting = []
+  let closed = false
+  rl.on("line", (line) => (waiting.length ? waiting.shift()(line) : pending.push(line)))
+  rl.on("close", () => {
+    closed = true
+    while (waiting.length) waiting.shift()(null)
+  })
+  return {
+    next: () => (pending.length ? Promise.resolve(pending.shift()) : closed ? Promise.resolve(null) : new Promise((resolve) => waiting.push(resolve))),
+    close: () => rl.close(),
+  }
+}
+
+/** Ask one question until an answer resolves; `parse` returns { ok, value } or { ok: false, reason }. */
+async function question(lines, output, c, { name, heading, options, defaultIndexes, parse }) {
+  const step = " ".repeat(STEP)
+  output.write(`${wrap(heading, {}, c).join("\n")}\n`)
+  for (const [index, option] of options.entries()) {
+    output.write(`${step}${c("typeable", String(index + 1).padStart(2))}  ${option}\n`)
+  }
+  const fallback = defaultIndexes.length ? defaultIndexes.map((index) => index + 1).join(",") : null
+  const prompt = `${action(fallback ? `${name} [${fallback}]:` : `${name}:`, c, { indent: 0 })[0]} `
+  for (;;) {
+    output.write(prompt)
+    const raw = await lines.next()
+    if (raw === null) {
+      output.write("\n")
+      throw new AskError(`stdin ended before the ${name} was answered; pass --${name} on the command line`)
+    }
+    const text = raw.trim() || (fallback ?? "")
+    const parsed = parse(text)
+    if (parsed.ok) return parsed.value
+    output.write(`${wrap(parsed.reason, {}, c).join("\n")}\n`)
+  }
+}
+
+/** A comma-separated answer of numbers or names, resolved against a list. */
+function pick(text, options) {
+  const parts = String(text).split(",").map((part) => part.trim()).filter(Boolean)
+  const chosen = []
+  for (const part of parts) {
+    const number = /^\d+$/.test(part) ? Number(part) : null
+    const option = number !== null
+      ? options[number - 1]
+      : options.find((candidate) => candidate.toLowerCase() === part.toLowerCase())
+    if (!option) return { ok: false, reason: `"${part}" is not a number from 1 to ${options.length}, nor one of the names.` }
+    if (!chosen.includes(option)) chosen.push(option)
+  }
+  return { ok: true, value: chosen }
+}
+
+/**
+ * @param {{ contract: object, defaults: { category: string|null, tags: string[]|null }, missing: string[],
+ *           input?: NodeJS.ReadStream, output?: NodeJS.WriteStream, colour?: boolean }} options
+ *   `defaults` are the marketplace's own presentation for the manifest, offered
+ *   only where they are on the form's list. `missing` names which of
+ *   `--category` and `--tags` to ask for.
+ * @returns {Promise<{ category?: string, tags?: string[] }>}
+ */
+export async function askChoices({ contract, defaults, missing, input = process.stdin, output = process.stderr, colour = colourEnabled(output) }) {
+  const c = styler(colour)
+  const lines = reader(input)
+  const answers = {}
+  try {
+    if (missing.includes("--category")) {
+      const known = defaults.category ? resolveCategory(contract, defaults.category) : { ok: false }
+      const index = known.ok ? contract.categories.indexOf(known.value) : -1
+      answers.category = await question(lines, output, c, {
+        name: "category",
+        heading: `category: one of the form's ${contract.categories.length}${index >= 0 ? `; the marketplace's own choice for this manifest's kinds is ${known.value}` : ""}`,
+        options: contract.categories,
+        defaultIndexes: index >= 0 ? [index] : [],
+        parse: (text) => {
+          if (!text) return { ok: false, reason: `There is no default for this manifest; answer with a number from 1 to ${contract.categories.length}.` }
+          const picked = pick(text, contract.categories)
+          if (!picked.ok) return picked
+          if (picked.value.length !== 1) return { ok: false, reason: "Exactly one category." }
+          return { ok: true, value: picked.value[0] }
+        },
+      })
+    }
+    if (missing.includes("--tags")) {
+      const known = defaults.tags?.length ? resolveTags(contract, defaults.tags.filter((tag) => resolveTags(contract, [tag]).ok)) : { ok: false }
+      const indexes = known.ok ? known.value.map((label) => contract.tagLabels.indexOf(label)) : []
+      answers.tags = await question(lines, output, c, {
+        name: "tags",
+        heading: `tags: 1 to ${contract.maximumTags} of the form's ${contract.tagLabels.length}, comma-separated${indexes.length ? `; the marketplace's own choice for this manifest's kinds is ${known.value.join(", ")}` : ""}`,
+        options: contract.tagLabels,
+        defaultIndexes: indexes,
+        parse: (text) => {
+          if (!text) return { ok: false, reason: `There is no default for this manifest; answer with 1 to ${contract.maximumTags} numbers, comma-separated.` }
+          const picked = pick(text, contract.tagLabels)
+          if (!picked.ok) return picked
+          const resolved = resolveTags(contract, picked.value)
+          return resolved.ok ? { ok: true, value: resolved.value } : { ok: false, reason: `${resolved.reason}.` }
+        },
+      })
+    }
+  } finally {
+    lines.close()
+  }
+  return answers
+}

package/tools/marketplace/cli.mjs

@@ -14,13 +14,14 @@
 import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
 import { dirname, resolve } from "node:path"
 import { fileURLToPath } from "node:url"
-import { ensurePin, MARKETPLACE_PIN } from "./pin.mjs"
+import { ensurePin, MARKETPLACE_PIN, requirePin } from "./pin.mjs"
 import { marketplaceBaselineSection } from "./verify.mjs"
 import { resolveSubject, SubjectError } from "../subject/resolve.mjs"
-import { missingSubmitFlags, submitPreflight } from "./submit.mjs"
-import { submissionContract } from "./form.mjs"
+import { submitPreflight } from "./submit.mjs"
+import { askChoices } from "./ask.mjs"
 import { validationWatch } from "./watch.mjs"
-import { renderSubmit, renderWatch, renderDoctor } from "./report.mjs"
+import { renderSubmit, renderWatch, renderDoctor, renderVerify } from "./report.mjs"
+import { consequence } from "./preflight.mjs"
 import { doctor } from "./doctor.mjs"
 import { setup } from "./setup.mjs"
 import { upgrade } from "./upgrade.mjs"
@@ -98,29 +99,20 @@ function emit(args, text) {
 async function cmdSubmit(args) {
   const target = positionals(args)[0]
   if (!target) fail("usage", "submit needs a target: `omakit submit <target> --category <c> --tags <a,b>`", 2)
-  // A missing category or tag list is a usage error, decided before any check
-  // runs and before the spinner starts: nothing can be rendered without them,
-  // and the values the form accepts are the answer, read from the pin.
-  let usage = null
-  try {
-    usage = missingSubmitFlags(await submissionContract({ repoRoot: ROOT }), { category: option(args, "--category"), tags: option(args, "--tags") })
-  } catch (error) {
-    failFrom(error)
-  }
-  if (usage) {
-    if (args.includes("--json")) {
-      process.stdout.write(`${JSON.stringify({ usage }, null, 2)}\n`)
-      process.exit(2)
+  const json = args.includes("--json")
+  const spinner = json ? { phase: () => {}, done: () => {} } : progress()
+  // A missing --category or --tags on an unlisted plugin is asked for, once
+  // each, when a person is at a terminal on both ends and no machine is
+  // reading the result. Anything else, a pipe, an agent, --json, gets the
+  // usage error with the form's lists, exit 2. Decided after the registry:
+  // a listed plugin is never asked for a choice that does not matter.
+  const interactive = !json && Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY)
+  const chooser = interactive
+    ? async (asked) => {
+      spinner.done()
+      return askChoices({ ...asked, input: process.stdin, output: process.stderr })
     }
-    const flags = usage.missing.join(" and ")
-    fail("usage", `submit needs ${flags}: ${usage.missing.length === 1 ? "it is" : "they are"} an editorial choice nobody else can make, from the pinned form's own lists.`, 2,
-      `omakit submit ${target} --category <c> --tags <a,b>`,
-      (c) => [
-        ...labelled("categories", usage.categories.join(", "), c),
-        ...labelled(`tags, 1 to ${usage.maximumTags}`, usage.tags.join(", "), c),
-      ])
-  }
-  const spinner = args.includes("--json") ? { phase: () => {}, done: () => {} } : progress()
+    : undefined
   let result
   try {
     result = await submitPreflight({
@@ -134,14 +126,31 @@ async function cmdSubmit(args) {
       pluginName: option(args, "--name"),
       allowDirty: args.includes("--allow-dirty"),
       offline: args.includes("--offline"),
+      chooser,
     })
   } catch (error) {
     spinner.done()
+    if (error?.code === "usage" && error.usage) {
+      const usage = error.usage
+      if (json) {
+        process.stdout.write(`${JSON.stringify({ usage }, null, 2)}\n`)
+        process.exit(2)
+      }
+      const flags = usage.missing.join(" and ")
+      fail("usage", `submit needs ${flags}: ${usage.missing.length === 1 ? "it is" : "they are"} an editorial choice nobody else can make, from the pinned form's own lists.`, 2,
+        `omakit submit ${target} --category <c> --tags <a,b>`,
+        (c) => [
+          ...labelled("categories", usage.categories.join(", "), c),
+          ...labelled(`tags, 1 to ${usage.maximumTags}`, usage.tags.join(", "), c),
+        ])
+    }
     failFrom(error)
   }
   spinner.done()
   emit(args, args.includes("--json") ? `${JSON.stringify(result, null, 2)}\n` : renderSubmit(result))
-  process.exit(result.ready ? 0 : 1)
+  // Three outcomes, two exit codes: `ready` and `listed` are both healthy
+  // states, and only a refusal is a 1.
+  process.exit(result.outcome === "refused" ? 1 : 0)
 }
 
 async function cmdWatch(args) {
@@ -207,7 +216,7 @@ async function cmdVerify(args) {
     fail(error?.code === "marketplace-unavailable" ? error.code : "baseline-unavailable", error.message)
   }
   spinner.done()
-  emit(args, `${JSON.stringify({
+  const document = {
     subject: {
       repository: subject.repository,
       commit: subject.commit,
@@ -215,7 +224,18 @@ async function cmdVerify(args) {
       mode: subject.mode,
     },
     marketplaceBaseline: section,
-  }, null, 2)}\n`)
+  }
+  // The JSON is the document itself, byte for byte what verify always
+  // printed, for --json and for --out; a person at the terminal gets the
+  // report, in the register submit uses for its checks.
+  if (args.includes("--json") || option(args, "--out")) {
+    emit(args, `${JSON.stringify(document, null, 2)}\n`)
+    return
+  }
+  const blockingRules = section.invoked && section.official && !section.official.error
+    ? (await consequence(requirePin(ROOT).dir, section.official)).selectivelyBlockingRules
+    : []
+  emit(args, renderVerify(document, { blockingRules }))
 }
 
 async function cmdParity(args) {

package/tools/marketplace/form.mjs

@@ -27,6 +27,8 @@ import { requirePin } from "./pin.mjs"
 
 export const SUBMIT_FORM_PATH = ".github/ISSUE_TEMPLATE/submit-plugin.yml"
 export const OFFICIAL_SUBMISSION_MODULE = "scripts/submission.mjs"
+export const VERIFY_FORM_PATH = ".github/ISSUE_TEMPLATE/verify-plugin.yml"
+export const OFFICIAL_VERIFICATION_MODULE = "scripts/plugin-verification-request.mjs"
 
 export class ContractError extends Error {
   constructor(code, message) {
@@ -50,8 +52,8 @@ function loadOfficial(pinDir) {
   return import(pathToFileURL(join(pinDir, OFFICIAL_SUBMISSION_MODULE)).href)
 }
 
-function fieldsOf(form) {
-  if (!Array.isArray(form?.body)) throw new ContractError("form-unreadable", `${SUBMIT_FORM_PATH} has no body`)
+function fieldsOf(form, formPath = SUBMIT_FORM_PATH) {
+  if (!Array.isArray(form?.body)) throw new ContractError("form-unreadable", `${formPath} has no body`)
   return form.body
     .filter((item) => item && item.type !== "markdown")
     .map((item) => ({
@@ -65,12 +67,12 @@ function fieldsOf(form) {
     }))
 }
 
-function only(fields, predicate, what) {
+function only(fields, predicate, what, formPath = SUBMIT_FORM_PATH) {
   const found = fields.filter(predicate)
   if (found.length !== 1) {
     throw new ContractError(
       "form-shape-changed",
-      `${SUBMIT_FORM_PATH} no longer has exactly one ${what} (found ${found.length}); the pin changed shape and the submission contract must be re-read before anything is generated`,
+      `${formPath} no longer has exactly one ${what} (found ${found.length}); the pin changed shape and the submission contract must be re-read before anything is generated`,
     )
   }
   return found[0]
@@ -135,6 +137,36 @@ export async function submissionContract(options = {}) {
   return contract
 }
 
+/**
+ * The route for a plugin that is already listed: the marketplace's other
+ * form, and the one choice on it that lists a newer commit. Both read from
+ * the pin. The choice text is the option as the form spells it, found by the
+ * name the marketplace's own verification module gives that action; the two
+ * must agree, the way the submission form and `scripts/submission.mjs` must,
+ * because a choice retyped here would drift by a word and send a person to
+ * pick something the form no longer offers.
+ *
+ * @param {{ repoRoot?: string, pinDir?: string }} [options]
+ * @returns {Promise<{ formPath: string, name: string, choice: string }>}
+ */
+export async function newerCommitChoice(options = {}) {
+  const pinDir = options.pinDir || requirePin(options.repoRoot).dir
+  const form = parseYaml(readFileSync(join(pinDir, VERIFY_FORM_PATH), "utf8"))
+  const fields = fieldsOf(form, VERIFY_FORM_PATH)
+  const action = only(fields, (f) => f.type === "dropdown" && !f.multiple && f.required, "required single-select dropdown (verification action)", VERIFY_FORM_PATH)
+  const official = await import(pathToFileURL(join(pinDir, OFFICIAL_VERIFICATION_MODULE)).href)
+  const choice = (action.options || []).find((option) => option === official.upstreamUpdateVerificationAction)
+  if (!choice) {
+    throw new ContractError(
+      "form-shape-changed",
+      `${VERIFY_FORM_PATH} offers no "${official.upstreamUpdateVerificationAction}" under ${action.label}; the form and ${OFFICIAL_VERIFICATION_MODULE} at the pin disagree, and nobody is sent to a choice that is not there`,
+    )
+  }
+  const name = typeof form.name === "string" ? form.name.trim() : ""
+  if (!name) throw new ContractError("form-shape-changed", `${VERIFY_FORM_PATH} has no name`)
+  return { formPath: VERIFY_FORM_PATH, name, choice }
+}
+
 /**
  * The form and the marketplace's own constants must describe the same
  * submission. Anything else means the pin is internally inconsistent, and

package/tools/marketplace/registry.mjs

@@ -71,12 +71,68 @@ export function reservedNamespace(pinDir) {
   return match[1].endsWith(".") ? match[1] : `${match[1]}.`
 }
 
+/**
+ * How the marketplace itself presents a plugin it lists, read out of the
+ * pinned `build-catalog.mjs` rather than copied: `categoryFor(kinds)` maps the
+ * manifest's kinds to a category in order of its `if` lines, with a fallback,
+ * and the tags are the first three kinds lowercased. `omakit submit` offers
+ * these as the default answer when it has to ask for a category and tags, so
+ * the default is the marketplace's own choice; a mapping that cannot be read
+ * offers no default. tests/unit/registry-figures.test.mjs pins what the
+ * mapping is at this commit, so a marketplace that changes it fails the suite
+ * until the docs follow.
+ *
+ * @returns {{ rules: Array<{ kinds: string[], category: string }>, fallback: string|null, tagsFromKinds: boolean }}
+ */
+export function catalogPresentation(pinDir) {
+  const source = readFileSync(join(pinDir, CATALOG_BUILDER_PATH), "utf8")
+  const body = source.match(/function categoryFor\([^)]*\)\s*\{([\s\S]*?)\n\}/)?.[1] || ""
+  const rules = [...body.matchAll(/if \(((?:kinds\.includes\("[^"]+"\)(?:\s*\|\|\s*)?)+)\) return "([^"]+)";/g)]
+    .map((match) => ({ kinds: [...match[1].matchAll(/"([^"]+)"/g)].map((kind) => kind[1]), category: match[2] }))
+  const fallback = body.match(/\n\s*return "([^"]+)";\s*$/)?.[1] || null
+  const tagsFromKinds = /tags:\s*kinds\.slice\(0,\s*3\)\.map\(\(kind\) => kind\.toLowerCase\(\)\)/.test(source)
+  return { rules, fallback, tagsFromKinds }
+}
+
+/**
+ * The marketplace's own presentation for a manifest's kinds: the category its
+ * rules pick and the tags it would derive. Null where the mapping was not
+ * readable, so nothing is offered rather than something guessed.
+ */
+export function defaultPresentation(presentation, kinds = []) {
+  const list = Array.isArray(kinds) ? kinds.filter((kind) => typeof kind === "string") : []
+  const rule = presentation.rules.find((candidate) => candidate.kinds.some((kind) => list.includes(kind)))
+  const category = presentation.rules.length && presentation.fallback ? (rule ? rule.category : presentation.fallback) : null
+  const tags = presentation.tagsFromKinds ? list.slice(0, 3).map((kind) => kind.toLowerCase()) : null
+  return { category, tags }
+}
+
+/**
+ * "https://github.com/Owner/Name.git" and "owner/name" both become
+ * "owner/name": the path, without surrounding slashes, without a trailing
+ * .git, lowercased. Anything else is "", which matches nothing.
+ */
 function repositorySlug(value) {
+  const text = String(value ?? "").trim()
+  let path
   try {
-    return new URL(String(value)).pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/i, "").toLowerCase()
+    path = new URL(text).pathname
   } catch {
-    return ""
+    path = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(text) ? text : ""
   }
+  return path.replace(/^\/+|\/+$/g, "").replace(/\.git$/i, "").toLowerCase()
+}
+
+/**
+ * The one rule for "the same repository": owner and name, compared
+ * case-insensitively, with a trailing .git ignored. Measured on 0.1.6: the
+ * author's own listed plugin was rendered as a failed check because the
+ * listing and the subject were compared as two strings, so this is the rule
+ * and its test, not a comparison typed where it is needed.
+ */
+export function sameRepository(a, b) {
+  const slug = repositorySlug(a)
+  return Boolean(slug) && slug === repositorySlug(b)
 }
 
 /**
@@ -364,11 +420,14 @@ export function figure(n) {
 
 /**
  * @param {{ id: string, repositoryUrl?: string|null }} subject
- * @returns {{ ok: boolean, problems: Array<{ code: string, detail: string, repository?: string|null, sameRepository?: boolean }> }}
+ * @returns {{ ok: boolean, own: boolean, problems: Array<{ code: string, detail: string, repository?: string|null, sameRepository?: boolean }> }}
  *   A `plugin-id-listed` problem names the repository that lists the id
  *   (`repository`, a slug, or null when the registry does not say) and
  *   whether that is the subject's own (`sameRepository`), because the two
- *   have different remedies: another id, or nothing to submit at all.
+ *   are different states: another id is needed, or the plugin is listed and
+ *   there is nothing to submit. `own` is the second state on its own: the id
+ *   is listed by this repository and no other code fired, so `ok` is false
+ *   and nothing is wrong.
  */
 export function checkIdentity(universe, subject) {
   const problems = []
@@ -389,18 +448,64 @@ export function checkIdentity(universe, subject) {
   }
   if (universe.listedIds.has(id)) {
     const repository = universe.listedBy?.get(id) || null
-    const sameRepository = Boolean(repository && slug && repository === slug)
     problems.push({
       code: "plugin-id-listed",
       detail: `"${id}" is already listed${repository ? ` by ${repository}` : ""}`,
       repository,
-      sameRepository,
+      sameRepository: sameRepository(repository, slug),
     })
   }
   if (slug && universe.listedRepositories.has(slug)) {
     problems.push({ code: "submission-repository-listed", detail: `${slug} is already listed`, repository: slug, sameRepository: true })
   }
-  return { ok: problems.length === 0, problems }
+  // The subject's own listing: the id is listed, by this repository, and
+  // nothing else is wrong with the id. That is not a problem with the
+  // submission, it is the absence of one; the caller reports it as a state.
+  const own = problems.length > 0
+    && problems.some((problem) => problem.code === "plugin-id-listed" && problem.sameRepository)
+    && problems.every((problem) => problem.sameRepository)
+  return { ok: problems.length === 0, own, problems }
+}
+
+/**
+ * What the marketplace records about one listing, for the plugin that is
+ * already listed by its own repository: read from the catalog first, which
+ * carries the verification fields, and from the registry source when the
+ * catalog has no entry. Every field is null when nothing records it; nothing
+ * is guessed.
+ *
+ * @param {{ registry: object, catalog: object }} live
+ * @param {string} id
+ * @returns {{ repository: string|null, id: string, addedAt: string|null, verificationCommit: string|null,
+ *             verificationStatus: string|null, verificationCheckedAt: string|null }|null}
+ */
+export function listingOf(live, id) {
+  const text = (value) => (typeof value === "string" && value ? value : null)
+  const plugin = (Array.isArray(live.catalog?.plugins) ? live.catalog.plugins : []).find((entry) => entry?.id === id)
+  if (plugin) {
+    return {
+      repository: text(plugin.repo),
+      id,
+      addedAt: text(plugin.addedAt) || text(plugin.listedAt),
+      verificationCommit: text(plugin.verificationCommit)?.toLowerCase() || text(plugin.listingValidatedCommit)?.toLowerCase() || null,
+      verificationStatus: text(plugin.verificationStatus),
+      verificationCheckedAt: text(plugin.verificationCheckedAt) || text(plugin.listingValidatedAt),
+    }
+  }
+  const sources = Array.isArray(live.registry?.sources) ? live.registry.sources : Object.values(live.registry?.sources || {})
+  const source = sources.find((entry) => {
+    const ids = entry?.plugins && typeof entry.plugins === "object" && !Array.isArray(entry.plugins) ? Object.keys(entry.plugins) : []
+    return ids.includes(id) || (entry?.automatedSecurityBaseline?.pluginIds || []).includes(id)
+  })
+  if (!source) return null
+  return {
+    repository: text(source.repo),
+    id,
+    addedAt: text(source.addedAt) || text(source.listedAt),
+    verificationCommit: text(source.listingValidatedCommit)?.toLowerCase() || null,
+    verificationStatus: text(source.automatedSecurityBaseline?.outcome),
+    verificationCheckedAt: text(source.listingValidatedAt),
+  }
 }
 
 export { repositorySlug }

package/tools/marketplace/report.mjs

@@ -48,12 +48,7 @@ function checkBlock(check, c) {
   if (check.detail) out.push(...wrap(check.detail, { indent: GUTTER }, c))
   if (check.verdict === "fail") {
     // A path is the thing at fault, so it is yellow; its reason wraps under it.
-    for (const path of check.paths) {
-      out.push(...wrap(`- ${path}`, { indent: GUTTER + STEP, first: GUTTER })
-        .map((line, index) => (index === 0
-          ? `${body}${c("fail", "-")} ${c("placeholder", line.trimStart().slice(2))}`
-          : `${" ".repeat(GUTTER + STEP)}${c("placeholder", line.trimStart())}`)))
-    }
+    out.push(...pathLines(check.paths, c))
     for (const remedy of [].concat(check.remedy || [])) out.push(...action(remedy, c))
     // The measured reason is the point of the check, so it is not dimmed: only
     // its label is grey, and on a low-contrast theme the number still reads.
@@ -62,6 +57,42 @@ function checkBlock(check, c) {
   return out
 }
 
+/**
+ * A shell command as an arrow, broken before a flag when it would not fit:
+ * a command is not prose, and a line break inside it is only valid with a
+ * backslash, the way the issue-creating example at the end of the report
+ * is printed.
+ */
+function commandLines(command, c) {
+  // A flag and its value travel together; a quoted value is one word.
+  const words = String(command).match(/"(?:[^"\\]|\\.)*"|\S+/g) || []
+  const units = []
+  for (const word of words) {
+    if (units.length && units[units.length - 1].startsWith("--") && !units[units.length - 1].includes(" ") && !word.startsWith("--")) {
+      units[units.length - 1] += ` ${word}`
+    } else {
+      units.push(word)
+    }
+  }
+  const room = COLUMNS - STEP - " \\".length
+  const lines = []
+  let line = ""
+  for (const unit of units) {
+    const next = line ? `${line} ${unit}` : unit
+    if (line && next.length > room) {
+      lines.push(line)
+      line = unit
+    } else {
+      line = next
+    }
+  }
+  lines.push(line)
+  const step = " ".repeat(STEP)
+  return lines.flatMap((text, index) => (index === 0
+    ? action(`${text}${lines.length > 1 ? " \\" : ""}`, c, { indent: 0 })
+    : [`${step}${c("typeable", `${text}${index < lines.length - 1 ? " \\" : ""}`)}`]))
+}
+
 export function renderSubmit(result, { colour = colourEnabled() } = {}) {
   const c = styler(colour)
   const out = []
@@ -91,7 +122,26 @@ export function renderSubmit(result, { colour = colourEnabled() } = {}) {
     out.push("")
   }
 
-  if (!result.ready) {
+  if (result.outcome === "listed") {
+    // The third outcome. Nothing was refused and nothing is wrong: the plugin
+    // is listed by this repository, so there is no body and no reproduce
+    // line, and the route to a newer commit is the marketplace's other form.
+    // Measured on 0.1.6: this state was drawn as FAIL and REFUSED, and closed
+    // with "Fix it, then run submit again" under a remedy that said there was
+    // nothing to submit.
+    const listing = result.listing
+    out.push(...verdict("pass", "LISTED", `${listing.id} is already listed by this repository, so the submission form is not the route.`, c))
+    out.push("")
+    out.push(...field("listed", listing.verificationCommit ? c("name", listing.verificationCommit) : "no verification commit recorded", c, { wrapValue: false }))
+    out.push(...continuation(`${listing.verificationStatus || "status unrecorded"}, checked ${listing.verificationCheckedAt || "at an unrecorded time"}, read from the ${listing.source === "head" ? "marketplace's current HEAD" : "pin"}`, c))
+    out.push(...field("local HEAD", c("name", listing.localCommit), c, { wrapValue: false }))
+    out.push(...continuation(listing.sameCommit ? "the same commit" : "not the listed commit", c))
+    out.push("")
+    out.push(...wrap(`${listing.sameCommit ? "To get a newer commit listed later" : "To get it listed"}, open the marketplace's "${listing.updateRoute.form}" form and choose "${listing.updateRoute.choice}". \`omakit watch <the submission issue>\` shows which commit is listed now.`, {}, c))
+    return out.join("\n")
+  }
+
+  if (result.outcome === "refused") {
     // Root causes only: a check that waited on a failed one is not listed,
     // and the count says how many waited.
     const failed = result.checks.filter((check) => result.blocking.includes(check.id))
@@ -106,7 +156,12 @@ export function renderSubmit(result, { colour = colourEnabled() } = {}) {
       else out.push(...wrap(check.detail, { indent: GUTTER }, c))
       out.push("")
     }
-    out.push(failed.length === 1 ? "Fix it, then run submit again." : "Fix them, then run submit again.")
+    if (result.reproduce) {
+      out.push(failed.length === 1 ? "Fix it, then run submit again:" : "Fix them, then run submit again:")
+      out.push(...commandLines(result.reproduce, c))
+    } else {
+      out.push(failed.length === 1 ? "Fix it, then run submit again." : "Fix them, then run submit again.")
+    }
     return out.join("\n")
   }
 
@@ -131,6 +186,11 @@ export function renderSubmit(result, { colour = colourEnabled() } = {}) {
   out.push(`${step}${c("typeable", "--body-file <the body above>")}`)
   out.push("")
   out.push(...wrap(`After it is created: ${result.afterSubmitting}`, {}, c))
+  if (result.reproduce) {
+    out.push("")
+    out.push("The same run, without prompting:")
+    out.push(...commandLines(result.reproduce, c))
+  }
   return out.join("\n")
 }
 
@@ -176,6 +236,79 @@ export function renderWatch(result, { colour = colourEnabled() } = {}) {
   return out.join("\n")
 }
 
+/** A list of paths at fault, the way a failing check prints them: a tinted dash, the path in the placeholder tint. */
+function pathLines(paths, c, dash = "fail") {
+  return paths.flatMap((path) => wrap(`- ${path}`, { indent: GUTTER + STEP, first: GUTTER })
+    .map((line, index) => (index === 0
+      ? `${body}${c(dash, "-")} ${c("placeholder", line.trimStart().slice(2))}`
+      : `${" ".repeat(GUTTER + STEP)}${c("placeholder", line.trimStart())}`)))
+}
+
+/**
+ * `omakit verify` for a person: the subject, the pin, the transport and its
+ * assumptions, then the official result in the register submit uses for its
+ * checks, and the statement last. Nothing here is Omakit's judgement: the
+ * outcome, the disposition, each finding's title, reason and actions, and a
+ * refusal's message are the marketplace's own text verbatim; the one thing
+ * added is the tag on each finding, blocks publication or review-required,
+ * which is read from the pinned policy's selectively blocking rules
+ * (`blockingRules`). `--json` prints the document itself.
+ */
+export function renderVerify(document, { colour = colourEnabled(), blockingRules = [] } = {}) {
+  const c = styler(colour)
+  const out = []
+  const { subject, marketplaceBaseline: section } = document
+  const tree = subject.cleanTree?.clean
+    ? `clean tree, proof ${subject.cleanTree.proof}`
+    : c("advisory", "dirty worktree")
+  out.push(...field("subject", subject.repository?.url || "no declared GitHub repository URL", c, { wrapValue: false }))
+  out.push(...field("commit", subject.commit, c, { wrapValue: false }))
+  out.push(...continuation(`${tree}, ${subject.mode} mode`, c))
+  out.push(...field("marketplace", `${section.pin.commit}, baseline ${section.pin.baselineVersion}, ${section.pin.enforcementMode}`, c))
+  out.push(...field("transport", section.transport, c))
+  if (section.assumedByAdapter?.length) out.push(...field("assumed", section.assumedByAdapter.join(", "), c))
+  out.push("")
+
+  const official = section.official
+  if (!section.invoked) {
+    out.push(`${head("unknown", "not run", "marketplace-pin", c)}`)
+    out.push(...wrap(section.skipReason || "the official baseline was not invoked", { indent: GUTTER }, c))
+  } else if (official?.error) {
+    // The official code refused the snapshot: that refusal is the result.
+    out.push(`${head("fail", official.error.code, "marketplace-pin", c)}`)
+    out.push(...wrap(official.error.message, { indent: GUTTER }, c))
+    for (const [key, value] of Object.entries(official.error)) {
+      if (key === "code" || key === "message") continue
+      out.push(...wrap(`- ${key}: ${typeof value === "string" ? value : JSON.stringify(value)}`, { indent: GUTTER + STEP, first: GUTTER }, c))
+    }
+  } else {
+    const findings = official.findings || []
+    const capabilities = official.capabilities || []
+    const state = official.outcome === "passed" ? "pass" : official.blocksApproval ? "fail" : "advisory"
+    out.push(`${head(state, official.outcome, "marketplace-pin", c)}`)
+    out.push(...wrap(official.outcome === "passed"
+      ? "no findings and no capabilities"
+      : `disposition ${official.disposition}, enforcement ${official.enforcementMode}, blocksApproval ${official.blocksApproval}`, { indent: GUTTER }, c))
+    for (const finding of findings) {
+      const blocks = blockingRules.includes(finding.ruleId)
+      out.push("")
+      out.push(head(blocks ? "fail" : "advisory", finding.ruleId, blocks ? "blocks publication" : "review-required", c))
+      out.push(...wrap([finding.title, finding.why].filter(Boolean).join(". ").replace(/\.\.\s/g, ". "), { indent: GUTTER }, c))
+      out.push(...pathLines((finding.evidence || []).map((entry) => `${entry.path}:${entry.line}`), c, blocks ? "fail" : "advisory"))
+      for (const remedy of finding.actions || []) out.push(...action(remedy, c))
+    }
+    for (const capability of capabilities) {
+      out.push("")
+      out.push(head("info", capability.id, "capability", c))
+      out.push(...wrap([capability.title, capability.why].filter(Boolean).join(". ").replace(/\.\.\s/g, ". "), { indent: GUTTER }, c))
+      out.push(...pathLines((capability.evidence || []).map((entry) => `${entry.path}:${entry.line}`), c, "info"))
+    }
+  }
+  out.push("")
+  out.push(...wrap(section.statement, {}, c))
+  return out.join("\n")
+}
+
 const DOCTOR_STATE = { ok: "pass", advice: "advisory", problem: "fail", info: "info", unknown: "unknown" }
 
 export function renderDoctor(result, { colour = colourEnabled() } = {}) {

package/tools/marketplace/submit.mjs

@@ -13,8 +13,8 @@
 
 import { resolveSubject, SubjectError } from "../subject/resolve.mjs"
 import { requirePin } from "./pin.mjs"
-import { submissionContract, resolveCategory, resolveTags } from "./form.mjs"
-import { idUniverse, checkIdentity, baselineFigures, figure, liveRegistry, registrySourceDetail } from "./registry.mjs"
+import { submissionContract, newerCommitChoice, resolveCategory, resolveTags, tagSlug } from "./form.mjs"
+import { idUniverse, checkIdentity, listingOf, baselineFigures, figure, liveRegistry, registrySourceDetail, catalogPresentation, defaultPresentation } from "./registry.mjs"
 import { readTree } from "./tree.mjs"
 import { inspectTree } from "./plugin.mjs"
 import { findAgentControl, REMEDY as AGENT_CONTROL_REMEDY } from "./agent-control.mjs"
@@ -23,26 +23,16 @@ import { renderIssue, verifyAgainstOfficialParser } from "./issue.mjs"
 import { defaultBranchHead } from "./github.mjs"
 import { REFRESH_ACTION } from "./watch.mjs"
 import { omakitCacheDir } from "./paths.mjs"
-import { join } from "node:path"
-import { pathToFileURL } from "node:url"
-
-/**
- * The marketplace's own name for the verification action that lists a newer
- * commit of an already listed plugin, read from the pin rather than typed:
- * a form option retyped here would drift by a word, and a person would be
- * sent to choose something the form no longer offers.
- */
-async function newerCommitAction(pinDir) {
-  const verification = await import(pathToFileURL(join(pinDir, "scripts/plugin-verification-request.mjs")).href)
-  return verification.upstreamUpdateVerificationAction
-}
 
 /**
  * One arrow per cause, in this order, so a person fixes the thing that is
  * actually wrong. Measured before this: an id listed by its own repository
  * was told to "choose an unused plugin id outside the reserved namespace",
  * which is the remedy for a different failure, and an author who followed
- * it would have renamed a plugin the marketplace already lists.
+ * it would have renamed a plugin the marketplace already lists. The last
+ * arrow is for a listed repository whose manifest carries another id, or
+ * one with a second cause beside it; a plugin listed by its own repository
+ * with nothing else wrong is not a failure at all (see `listing` below).
  */
 function identityRemedies(identity, universe, newerCommit) {
   const remedies = []
@@ -108,13 +98,42 @@ export function missingSubmitFlags(contract, { category, tags } = {}) {
   return { missing, categories: [...contract.categories], tags: [...contract.tagLabels], maximumTags: contract.maximumTags }
 }
 
+/** A shell word: quoted when it holds anything a shell would read. */
+function shellWord(value) {
+  const text = String(value)
+  return /^[A-Za-z0-9_@%+=:,./~-]+$/.test(text) ? text : `"${text.replace(/(["\\$`])/g, "\\$1")}"`
+}
+
+/**
+ * The command line that repeats this run without asking anything: the target
+ * as given, the category and tags the run used wherever they came from, and
+ * every other flag that was given. Printed at the end of the report and
+ * carried in --json as `reproduce`, so the next run needs no prompt.
+ */
+export function reproduceCommand({ target, category, tags, pluginName, notes, suggestedTag, allowDirty, offline }) {
+  const parts = ["omakit", "submit", shellWord(target)]
+  if (category) parts.push("--category", shellWord(category))
+  if (tags?.length) parts.push("--tags", shellWord(tags.map(tagSlug).join(",")))
+  if (pluginName) parts.push("--name", shellWord(pluginName))
+  if (notes) parts.push("--notes", shellWord(notes))
+  if (suggestedTag) parts.push("--suggest-tag", shellWord(suggestedTag))
+  if (allowDirty) parts.push("--allow-dirty")
+  if (offline) parts.push("--offline")
+  return parts.join(" ")
+}
+
 /**
  * @param {{ repoRoot: string, target: string, category?: string, tags?: string|string[],
  *           notes?: string, suggestedTag?: string, pluginName?: string,
  *           allowDirty?: boolean, offline?: boolean,
- *           readRegistry?: typeof liveRegistry }} options
+ *           readRegistry?: typeof liveRegistry,
+ *           chooser?: (question: { contract: object, defaults: object, missing: string[] }) => Promise<{ category?: string, tags?: string[] }> }} options
  *   `readRegistry` is injectable for tests; the default reads the marketplace's
- *   current HEAD, or the pin with `offline`.
+ *   current HEAD, or the pin with `offline`. `chooser` answers for a missing
+ *   --category or --tags on an unlisted plugin; without one, that is a usage
+ *   error (SubmitError "usage", with the form's lists under `usage`), decided
+ *   after the registry so a listed plugin is never asked for a choice that
+ *   does not matter.
  */
 export async function submitPreflight(options) {
   const { repoRoot } = options
@@ -212,22 +231,72 @@ export async function submitPreflight(options) {
   // --- identity -------------------------------------------------------------
 
   const identity = checkIdentity(universe, { id: tree.pluginId, repositoryUrl: subject.repository.url })
-  const identityRemedy = identity.ok ? null : identityRemedies(identity, universe, await newerCommitAction(pinDir))
+  const update = await newerCommitChoice({ pinDir })
+  const identityRemedy = identity.ok || identity.own ? null : identityRemedies(identity, universe, update.choice)
+  const listed = identity.problems.some((problem) => problem.code === "plugin-id-listed" || problem.code === "submission-repository-listed")
+
+  // The subject's own listing is the third outcome of a run, not a failed
+  // check. Measured on 0.1.6: `omakit submit` on the author's own listed
+  // plugin printed FAIL identity.available and REFUSED, closed with "Fix it,
+  // then run submit again", and the remedy under it said there was nothing to
+  // submit. A healthy state was drawn as a failure and the closing line
+  // contradicted the remedy. Now the check passes with what the marketplace
+  // records about the listing, and the run ends in LISTED.
+  const listing = identity.own
+    ? (() => {
+      const record = listingOf(live, tree.pluginId) || { repository: subject.repository.url, id: tree.pluginId, addedAt: null, verificationCommit: null, verificationStatus: null, verificationCheckedAt: null }
+      return {
+        ...record,
+        localCommit: subject.commit,
+        sameCommit: Boolean(record.verificationCommit) && record.verificationCommit === subject.commit.toLowerCase(),
+        source: live.source,
+        updateRoute: { form: update.name, choice: update.choice },
+      }
+    })()
+    : null
+
+  // The category and the tags are decided here, after the registry. Measured
+  // before this: a listed plugin was asked for both and then told there was
+  // nothing to submit. A listed plugin needs neither; an unlisted plugin with
+  // either missing is asked through `chooser` when there is one, and is a
+  // usage error otherwise. The default offered is the marketplace's own
+  // presentation for the manifest's kinds, read from the pinned catalog
+  // builder.
+  let chosenCategory = options.category
+  let chosenTags = options.tags
+  const missing = missingSubmitFlags(contract, { category: chosenCategory, tags: chosenTags })
+  const moot = Boolean(missing) && listed
+  if (missing && !listed) {
+    if (!options.chooser) {
+      const error = new SubmitError("usage", `submit needs ${missing.missing.join(" and ")}`)
+      error.usage = missing
+      throw error
+    }
+    const defaults = defaultPresentation(catalogPresentation(pinDir), tree.manifest?.kinds)
+    const answers = await options.chooser({ contract, defaults, missing: missing.missing })
+    if (answers?.category) chosenCategory = answers.category
+    if (answers?.tags) chosenTags = answers.tags
+  }
   checks.push(check("identity.available", {
     source: "marketplace-pin",
-    why: `The marketplace refuses \`plugin-id-listed\`, \`plugin-id-retired\`, \`reserved-plugin-id\` and \`submission-repository-listed\`. Checked here against ${figure(universe.counts.listedIds)} listed ids, ${figure(universe.counts.retiredIds)} retired ids and ${figure(universe.counts.listedRepositories)} listed repositories from the registry and catalog at the commit the detail names, and the reserved namespace from the pinned catalog builder. The registry is read from the marketplace's current HEAD when the network is there because the pin's copy is stale within hours: registry.json changed in 4,201 of the marketplace's 4,293 commits in the 30 days to 2026-09-13, about 140 a day (docs/MEASUREMENTS.md M7). Code and the form are only ever read from the pin.`,
-    verdict: identity.ok,
+    why: `The marketplace refuses \`plugin-id-listed\`, \`plugin-id-retired\`, \`reserved-plugin-id\` and \`submission-repository-listed\`. Checked here against ${figure(universe.counts.listedIds)} listed ids, ${figure(universe.counts.retiredIds)} retired ids and ${figure(universe.counts.listedRepositories)} listed repositories from the registry and catalog at the commit the detail names, and the reserved namespace from the pinned catalog builder. The registry is read from the marketplace's current HEAD when the network is there because the pin's copy is stale within hours: registry.json changed in 4,201 of the marketplace's 4,293 commits in the 30 days to 2026-09-13, about 140 a day (docs/MEASUREMENTS.md M7). Code and the form are only ever read from the pin. A plugin listed by its own repository (owner and name, case-insensitively, a trailing .git ignored) is not refused: it is listed, and this check says since when and at which commit.`,
+    verdict: identity.ok || identity.own,
     detail: `${identity.ok
       ? `id "${tree.pluginId}" is unused, outside the reserved ${universe.reservedPrefix}* namespace, and the repository is not listed`
-      : identity.problems.map((problem) => `${problem.code}: ${problem.detail}`).join("; ")}; ${registrySourceDetail(live)}`,
+      : listing
+        ? `listed by this repository since ${listing.addedAt || "an unrecorded date"}, verification commit ${listing.verificationCommit || "unrecorded"} (${listing.verificationStatus || "status unrecorded"}, checked ${listing.verificationCheckedAt || "at an unrecorded time"})`
+        : identity.problems.map((problem) => `${problem.code}: ${problem.detail}`).join("; ")}; ${registrySourceDetail(live)}`,
     remedy: identityRemedy,
   }))
 
   // --- the submission itself ------------------------------------------------
 
   const pluginName = String(options.pluginName || tree.pluginName || "").trim()
-  const category = resolveCategory(contract, options.category)
-  const tags = resolveTags(contract, options.tags)
+  const category = resolveCategory(contract, chosenCategory)
+  const tags = resolveTags(contract, chosenTags)
+  // For a listed plugin the editorial choice is moot: these wait on the
+  // identity check rather than failing for a flag nobody needed to give.
+  const mootWaitsOn = moot ? ["identity.available"] : []
 
   checks.push(check("submission.title", {
     source: "marketplace-pin",
@@ -239,25 +308,31 @@ export async function submitPreflight(options) {
     remedy: "Give the plugin a name in manifest.json, or pass --name.",
   }))
 
-  checks.push(check("submission.category", {
+  // On the subject's own listing no body is rendered, on purpose: the
+  // submission form is not the route. The five checks that exist only for the
+  // body are omitted rather than drawn as questions waiting on identity,
+  // because identity did not fail.
+  if (!listing) checks.push(check("submission.category", {
     source: "marketplace-pin",
     why: `Exactly one category from the form's controlled list; the marketplace refuses \`submission-category-invalid\` otherwise. The list (${contract.categories.length} options) is read from ${contract.formPath} at the pin.`,
     verdict: category.ok,
     detail: category.ok ? `category: ${category.value}` : `${category.reason}. Choose one of: ${contract.categories.join(", ")}`,
     remedy: category.ok ? null : "Pass --category with one of the listed values.",
+    waitedOn: mootWaitsOn,
   }))
 
-  checks.push(check("submission.tags", {
+  if (!listing) checks.push(check("submission.tags", {
     source: "marketplace-pin",
     why: `1 to ${contract.maximumTags} tags from the form's controlled list; the marketplace refuses \`submission-tag-count-invalid\` and \`submission-tags-invalid\` otherwise. The list (${contract.tagLabels.length} options) and the maximum are read from the pin.`,
     verdict: tags.ok,
     detail: tags.ok ? `tags: ${tags.value.join(", ")}` : `${tags.reason}. Choose from: ${contract.tagLabels.join(", ")}`,
     remedy: tags.ok ? null : "Pass --tags with 1 to 3 comma-separated values from the list.",
+    waitedOn: mootWaitsOn,
   }))
 
   // The body needs every field above and the repository URL below; the three
   // checks that read it wait on whichever of those failed.
-  const bodyWaitsOn = [
+  const bodyWaitsOn = moot ? mootWaitsOn : [
     !pluginName && "submission.title",
     !category.ok && "submission.category",
     !tags.ok && "submission.tags",
@@ -265,7 +340,7 @@ export async function submitPreflight(options) {
   ].filter(Boolean)
   let issue = null
   let parsed = null
-  if (!bodyWaitsOn.length) {
+  if (!bodyWaitsOn.length && !listing) {
     issue = renderIssue(contract, {
       pluginName,
       repositoryUrl: subject.repository.url,
@@ -285,7 +360,7 @@ export async function submitPreflight(options) {
     remedy: subject.repository.url ? null : "Give the repository a github.com origin remote.",
   }))
 
-  checks.push(check("submission.headings", {
+  if (!listing) checks.push(check("submission.headings", {
     source: "marketplace-pin",
     why: `The six form headings must appear in exact order: ${contract.headings.join(", ")}. 11 open submissions are malformed in the body and receive "The validation result could not be published to the issue. A maintainer must review the workflow.", which blames the maintainer for the author's mistake; one of them differs from a valid submission by the single word "Suggested" instead of "Suggest". The headings are rendered from the form at the pin, never typed.`,
     verdict: Boolean(issue),
@@ -293,7 +368,7 @@ export async function submitPreflight(options) {
     waitedOn: bodyWaitsOn,
   }))
 
-  checks.push(check("submission.checklist", {
+  if (!listing) checks.push(check("submission.checklist", {
     source: "marketplace-pin",
     why: `All ${contract.checklist.length} checklist items must be present with their exact text and checked; the marketplace refuses \`submission-checklist-unconfirmed\` otherwise. The text is read from the form at the pin, character for character.`,
     verdict: Boolean(issue),
@@ -301,7 +376,7 @@ export async function submitPreflight(options) {
     waitedOn: bodyWaitsOn,
   }))
 
-  checks.push(check("submission.official-parser", {
+  if (!listing) checks.push(check("submission.official-parser", {
     source: "marketplace-pin",
     why: "The strongest available proof that the body is well formed: the marketplace's own `parseCurrentSubmission` from the pinned commit is run over the rendered title and body. If it accepts them here it accepts them there, and 0 of the marketplace's heading, tag and checklist rules are duplicated in Omakit, so none of them can drift. This is the check that closes all 50 measured title-and-body failures at once: 39 on the title prefix plus 11 malformed bodies.",
     verdict: Boolean(parsed?.ok),
@@ -379,7 +454,12 @@ export async function submitPreflight(options) {
   const blocking = checks.filter((entry) => entry.severity === "blocking" && entry.verdict === "fail")
   const advisory = checks.filter((entry) => entry.severity === "advisory" && entry.verdict === "fail")
   const unknown = checks.filter((entry) => entry.verdict === "unknown")
-  const ready = blocking.length === 0
+  // Three outcomes. `refused`: a blocking check failed and no body exists.
+  // `listed`: nothing failed and the plugin is already listed by this
+  // repository, so there is no body either, and nothing is wrong. `ready`:
+  // the body. `ready` the boolean stays what it was, true for the third only.
+  const outcome = blocking.length ? "refused" : listing ? "listed" : "ready"
+  const ready = outcome === "ready"
 
   return {
     pin: {
@@ -409,8 +489,20 @@ export async function submitPreflight(options) {
       note: "The marketplace validates the default-branch HEAD it resolves when the issue is opened or edited. After submitting, use `omakit watch <issue-url>` to see whether that validated commit has fallen behind.",
     },
     plugin: { id: tree.pluginId, name: pluginName },
+    reproduce: reproduceCommand({
+      target: options.target,
+      category: category.ok ? category.value : null,
+      tags: tags.ok ? tags.value : null,
+      pluginName: options.pluginName,
+      notes: options.notes,
+      suggestedTag: options.suggestedTag,
+      allowDirty: options.allowDirty === true,
+      offline: options.offline === true,
+    }),
     checks,
+    outcome,
     ready,
+    listing,
     blocking: blocking.map((entry) => entry.id),
     advisory: advisory.map((entry) => entry.id),
     unknown: unknown.map((entry) => entry.id),

package/tools/marketplace/usage.mjs

@@ -45,6 +45,13 @@ export const COMMANDS = Object.freeze([
     lines: [
       "Every check that is knowable before submitting, the resolved commit, and",
       "the exact issue title and body. Prints them. Never posts anything.",
+      "Three outcomes: READY (exit 0, the body), REFUSED (exit 1, no body), and",
+      "LISTED (exit 0): the plugin is already listed by its own repository, so",
+      "the submission form is not the route and nothing is asked. An id taken",
+      "by another repository is refused. An unlisted plugin without a category",
+      "and tags is asked at a terminal, with the form's lists numbered; in a",
+      "pipe or with --json that is a usage error, exit 2. A READY or REFUSED",
+      "report ends with the command line that repeats the run unasked.",
     ],
   },
   {
@@ -56,10 +63,11 @@ export const COMMANDS = Object.freeze([
     ],
   },
   {
-    signature: "omakit verify <target> [--allow-dirty] [--out <file>]",
+    signature: "omakit verify <target> [--allow-dirty] [--json] [--out <file>]",
     lines: [
       "The official marketplace security baseline over the local Git transport,",
-      "reported verbatim beside the pin identity.",
+      "reported verbatim beside the pin identity. A report for a person; --json",
+      "prints the document itself, and --out writes it to a file.",
     ],
   },
   {