omakit 0.1.6 → 0.1.7

package/README.md

@@ -134,16 +134,32 @@ 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. A plugin that is
-already listed is refused there and asked for nothing (measured on 0.1.5: it
-exited 2 asking for `--category` and `--tags`, then would have said there was
-nothing to submit). An unlisted plugin needs both, and they are an editorial
+`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. Either way the report ends
-with the command line that repeats the run without asking, and `--json`
-carries it as `reproduce`.
+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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omakit",
-  "version": "0.1.6",
+  "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

@@ -46,9 +46,9 @@ 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 refused at `identity.available` and asked for nothing. Every report
-ends with the command line that repeats the run without asking, and `--json`
-carries it as `reproduce`.
+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:
 
@@ -72,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

@@ -44,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

@@ -13,13 +13,13 @@ local commit through the transport seam the marketplace tests itself
 | `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. Decides the category and tags after the registry: a listed plugin needs 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. |
+| `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. |
@@ -31,7 +31,7 @@ local commit through the transport seam the marketplace tests itself
 | `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

package/tools/marketplace/cli.mjs

@@ -148,7 +148,9 @@ async function cmdSubmit(args) {
   }
   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) {

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

@@ -107,12 +107,32 @@ export function defaultPresentation(presentation, kinds = []) {
   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)
 }
 
 /**
@@ -400,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 = []
@@ -425,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

@@ -122,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))

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, tagSlug } from "./form.mjs"
-import { idUniverse, checkIdentity, baselineFigures, figure, liveRegistry, registrySourceDetail, catalogPresentation, defaultPresentation } 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 = []
@@ -241,9 +231,30 @@ 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
@@ -268,11 +279,13 @@ export async function submitPreflight(options) {
   }
   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,
   }))
 
@@ -295,7 +308,11 @@ 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,
@@ -304,7 +321,7 @@ export async function submitPreflight(options) {
     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,
@@ -323,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,
@@ -343,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),
@@ -351,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),
@@ -359,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),
@@ -437,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: {
@@ -478,7 +500,9 @@ export async function submitPreflight(options) {
       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,10 +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.",
-      "A listed plugin is refused at identity and needs no category or tags.",
-      "An unlisted one without them is asked at a terminal, with the form's",
-      "lists numbered; in a pipe or with --json that is a usage error, exit 2.",
-      "The report ends with the command line that repeats the run unasked.",
+      "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.",
     ],
   },
   {