omakit 0.3.0 → 0.4.1

package/README.md

@@ -25,7 +25,7 @@ See [docs/INSTALL.md](docs/INSTALL.md) for the clone route, PATH, requirements a
 | --- | --- |
 | [`omakit setup`](docs/COMMANDS.md) | The environment, the pin, tab completion, and what to try first. |
 | [`omakit submit <plugin-repo>`](docs/SUBMIT.md) | Every check, the issue title and body; asks for a category and tags at a terminal. |
-| [`omakit watch <issue-url>`](docs/VALIDATION_WATCH.md) | The commit the marketplace validated, against the plugin's current HEAD. |
+| [`omakit watch [<issue-url>]`](docs/VALIDATION_WATCH.md) | Pick your marketplace issues, list them, or check all with `--all`. |
 | [`omakit verify <plugin-repo>`](docs/COMMANDS.md) | The official security baseline over the local transport; `--json` for the document. |
 | [`omakit parity`](docs/COMMANDS.md) | The baseline over GitHub versus the local transport, on real listings; writes the evidence. |
 | [`omakit audit [<plugin>]`](docs/AUDIT.md) | Installed third-party commits against the exact commits the marketplace validated. |
@@ -35,6 +35,15 @@ See [docs/INSTALL.md](docs/INSTALL.md) for the clone route, PATH, requirements a
 | [`omakit upgrade`](docs/COMMANDS.md) | Updates omakit through its own installer: npm, or a fast-forward. |
 | [`omakit help --agent`](docs/COMMANDS.md) | The operating instructions, for the agent running this. |
 
+Normal terminal use also checks for a newer npm release at most once daily
+and shows the upgrade command. It installs nothing automatically; scripts
+and JSON stay quiet. `DISABLE_UPDATE_NOTIFIER=1` disables the notice, and
+`omakit doctor` checks explicitly. [Update behaviour](docs/INSTALL.md#updating).
+
+Terminal help and reports adapt to the available width, up to 120 columns
+for readability. Narrow windows wrap sooner; pipes and text files keep the
+stable eighty-column layout. JSON and exact issue bodies remain intact.
+
 ### `submit`
 
 ```bash
@@ -51,10 +60,15 @@ Read more: [docs/SUBMIT.md](docs/SUBMIT.md).
 
 ```bash
 omakit watch <submission-issue-url>
+omakit watch --all
+omakit watch --list
+omakit watch                 # choose one or several issues at a terminal
 ```
 
 It decides whether the marketplace validated the plugin's current commit; [73% of parked submissions have a HEAD the marketplace never saw](docs/MEASUREMENTS.md).
 
+Account-wide discovery uses your signed-in `gh` account and reads your open marketplace issues. `--user <login>` reads another public account. Batch output includes baseline results, labels and the latest human discussion; `current` compares commits and does not imply approval or publication. Each command takes one snapshot and posts nothing.
+
 ![omakit watch reporting that a validated commit has fallen behind](docs/media/watch.gif)
 
 Read more: [docs/VALIDATION_WATCH.md](docs/VALIDATION_WATCH.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omakit",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "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 against the marketplace, posts nothing, zero dependencies.",
   "license": "MIT",
   "author": "Maarten Tolhuijs",

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

@@ -27,6 +27,8 @@ push came after a review comment had also commented: engaged, and stuck.
 
 ```bash
 omakit watch https://github.com/omacom/omarchy-plugin-marketplace/issues/<number>
+omakit watch --all --json
+omakit watch --list --json
 ```
 
 If `omakit` is not installed: `npm install --global omakit` (Omarchy ships Node
@@ -35,6 +37,10 @@ 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.
 
+Use `--all --json` to discover and check every open marketplace issue authored by the signed-in `gh` account. `--list --json` discovers issue URLs without reading every plugin; use an individual URL for focused follow-up. `--user <login>` selects an explicit public author. A bare `omakit watch` opens a numbered picker only at a terminal; an agent must pass a URL, `--all` or `--list` and never wait on keyboard input.
+
+Inspect every batch row, including read errors and unknown results; a successful row cannot stand in for a failed one. `current` only says the commit matches HEAD. Read the baseline outcome, labels and latest discussion to understand outstanding work; never equate it with approval, publication or restored catalog verification. A run is a single read-only snapshot, not a background monitor.
+
 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

package/tools/marketplace/README.md

@@ -26,6 +26,7 @@ local commit through the transport seam the marketplace tests itself
 | `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. Six states: `▁ ok`, `█ FAIL`, `▓ note`, `░ info`, `▒ ?` for a check that could not be made, and `▔ skip` for a check a flag said not to make, the floor's ink at the ceiling so it is never read as a pass. `docs/TUI.md` explains it. |
 | `report.mjs` | Text rendering of submit, watch, doctor and verify for the agent that runs this tool, and the person reading over its shoulder. |
+| `update-check.mjs` | A passive npm-release notice during normal terminal use, throttled to one check per day with a one-second network budget. Stores only installed/latest version metadata and time under XDG_STATE_HOME/omakit. Offline, JSON, pipes, help and CI skip it; DISABLE_UPDATE_NOTIFIER disables it. Version precedence and the registry GET are shared with doctor/upgrade. |
 | `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. |
 | `options.mjs` | Every option every command accepts, in one table, and the parser that reads a command line against it before anything runs; `tests/unit/options.test.mjs` holds the help signatures, and through them the completion scripts, to the table. |
@@ -80,7 +81,8 @@ side rather than the findings themselves. The GitHub side uses whatever
 credential `github.mjs` resolves (a `gh` login, and only that), read-only.
 
 Two rules about the output, stated as rules because each is an exception to
-a wider one. Everything omakit writes itself stays within 80 columns; text
+a wider one. Pipes use 80 columns; terminals use their available width up to
+120 columns. Text files compose at 80 columns without colour escapes. Text
 that will be posted verbatim, the marketplace's own baseline report and the
 issue body rendered from the pinned form, is never wrapped and may exceed 80,
 because a wrapped body would not be the body. And stdout is the whole result;
@@ -99,3 +101,5 @@ online, the subject's default-branch HEAD and the marketplace's current
 registry, and `--offline` turns both off; `verify` needs no network at all
 beyond fetching a reviewer-mode subject, and `tests/parity/offline.mjs` proves
 it.
+
+`watch --list` discovers the signed-in account's open marketplace issues through `github.mjs`; `--user` bypasses the account lookup. `watch --all` runs the existing single-issue watch with four workers and shared repository HEAD promises, preserving each read failure. A bare terminal invocation uses `ask.mjs` to choose one or several issues. `report.mjs` composes the list and batch views; all options remain in `options.mjs` and `usage.mjs`, which also generate completion. The batch JSON retains complete single-issue reports; `current` compares commits and never substitutes for review or publication.

package/tools/marketplace/ask.mjs

@@ -15,8 +15,9 @@
 // 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 { colourEnabled, outputColumns, STEP, action, styler, wrap } from "./style.mjs"
 import { resolveCategory, resolveTags } from "./form.mjs"
+import { watchIssueTitle } from "./watch.mjs"
 
 export class AskError extends Error {
   constructor(message) {
@@ -49,11 +50,13 @@ function reader(input) {
 }
 
 /** 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 }) {
+async function question(lines, output, c, { name, heading, options, defaultIndexes, parse, wrapOptions = false, eofRemedy }) {
   const step = " ".repeat(STEP)
-  output.write(`${wrap(heading, {}, c).join("\n")}\n`)
+  output.write(`${wrap(heading, { width: outputColumns(output) }, c).join("\n")}\n`)
   for (const [index, option] of options.entries()) {
-    output.write(`${step}${c("typeable", String(index + 1).padStart(2))}  ${option}\n`)
+    output.write(wrapOptions
+      ? `${wrap(`${String(index + 1).padStart(2)} ${option}`, { indent: STEP, width: outputColumns(output) }, c).join("\n")}\n`
+      : `${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]} `
@@ -62,12 +65,12 @@ async function question(lines, output, c, { name, heading, options, defaultIndex
     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`)
+      throw new AskError(`stdin ended before the ${name} was answered; ${eofRemedy || `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`)
+    output.write(`${wrap(parsed.reason, { width: outputColumns(output) }, c).join("\n")}\n`)
   }
 }
 
@@ -138,3 +141,30 @@ export async function askChoices({ contract, defaults, missing, input = process.
   }
   return answers
 }
+
+/** Select one or several discovered issues; nothing is written or opened. */
+export async function askWatchIssues({ issues, input = process.stdin, output = process.stderr, colour = colourEnabled(output) }) {
+  const c = styler(colour)
+  const lines = reader(input)
+  try {
+    return await question(lines, output, c, {
+      name: "issues",
+      heading: "Choose list numbers, comma-separated; all checks every issue, q cancels.",
+      options: issues.map((issue) => `#${issue.number} ${watchIssueTitle(issue.title)}`),
+      defaultIndexes: [],
+      wrapOptions: true,
+      eofRemedy: "pass an issue URL, --all or --list on the command line",
+      parse: (text) => {
+        if (text.toLowerCase() === "q") return { ok: true, value: [] }
+        if (text.toLowerCase() === "all") return { ok: true, value: issues }
+        const indexes = text.split(",").map((value) => value.trim())
+        if (indexes.some((value) => !/^\d+$/.test(value) || Number(value) < 1 || Number(value) > issues.length)) {
+          return { ok: false, reason: `Answer with list numbers from 1 to ${issues.length}, all, or q.` }
+        }
+        return { ok: true, value: [...new Set(indexes.map(Number))].map((index) => issues[index - 1]) }
+      },
+    })
+  } finally {
+    lines.close()
+  }
+}

package/tools/marketplace/banner.mjs

@@ -49,7 +49,7 @@
 // letters come from the small font below, so renaming the tool is a change to
 // one string and not a redrawing job.
 
-import { code, colourEnabled, DENSITY, motionEnabled, MOTION, rule as floorRule } from "./style.mjs"
+import { code, colourEnabled, DENSITY, motionEnabled, MOTION, outputColumns, rule as floorRule, wrap } from "./style.mjs"
 import { effectAvailable, playEffect } from "./effect.mjs"
 
 const ESC = "\u001b["
@@ -227,6 +227,15 @@ export async function banner(options = {}) {
   // and a piped run should differ from a watched one only in decoration.
   if (!enabled) return
 
+  // Never animate artwork across physical terminal rows: cursor-up would
+  // redraw the wrong row. A narrow terminal gets a compact wordmark instead.
+  if (stream.isTTY && Number.isFinite(stream.columns) && stream.columns > 0 && stream.columns < width) {
+    stream.write(`${c(code("name"), word.toUpperCase())}\n`)
+    if (options.tagline) stream.write(`${wrap(options.tagline, { width: outputColumns(stream) }, (name, text) => c(code(name), text)).join("\n")}\n`)
+    stream.write("\n")
+    return
+  }
+
   // A five-row animation redrawn with cursor-up needs five rows that stay put.
   // In a terminal with no room the screen scrolls under the animation, the
   // cursor-up lands a line off, and a row from an earlier frame is left stranded

package/tools/marketplace/cli.mjs

@@ -21,19 +21,20 @@ import { ensurePin, MARKETPLACE_PIN, requirePin } from "./pin.mjs"
 import { marketplaceBaselineSection } from "./verify.mjs"
 import { resolveSubject, SubjectError } from "../subject/resolve.mjs"
 import { submitPreflight } from "./submit.mjs"
-import { askChoices } from "./ask.mjs"
-import { validationWatch } from "./watch.mjs"
-import { renderSubmit, renderWatch, renderDoctor, renderVerify } from "./report.mjs"
+import { askChoices, askWatchIssues } from "./ask.mjs"
+import { validationWatch, discoverWatchIssues, validationWatchAll } from "./watch.mjs"
+import { renderSubmit, renderWatch, renderWatchList, renderWatchAll, renderDoctor, renderVerify } from "./report.mjs"
 import { consequence } from "./preflight.mjs"
 import { doctor } from "./doctor.mjs"
 import { completionStep, setup } from "./setup.mjs"
 import { staleCompletionNotice } from "./completion-check.mjs"
 import { ACCEPTED, acceptedWords, checkArgs } from "./options.mjs"
 import { upgrade } from "./upgrade.mjs"
+import { updateCheckEnabled, updateNotice } from "./update-check.mjs"
 import { progress } from "./progress.mjs"
 import { banner, bannerEnabled } from "./banner.mjs"
 import { COMMANDS, renderSummary, renderUsage, TAGLINE } from "./usage.mjs"
-import { action, AUDIT_VERDICTS, colourEnabled, GUTTER, labelled, mark, styler, verdict, wrap } from "./style.mjs"
+import { action, AUDIT_VERDICTS, colourEnabled, GUTTER, labelled, mark, outputColumns, styler, verdict, withOutputStream, wrap } from "./style.mjs"
 import { omakitCacheDir, withHomeAbbreviated } from "./paths.mjs"
 import { DEFAULTS as WEIGH_DEFAULTS, measureWeigh, planWeigh } from "../weigh/audit.mjs"
 import { confirmationQuestion, renderList, renderWeigh, renderPlan } from "../weigh/report.mjs"
@@ -62,6 +63,7 @@ const REMEDY = Object.freeze({
   "github-unavailable": "Wait for GitHub, then run it again. `gh auth login` raises the rate limit if that is what ran out.",
   "not-found": "Check the issue URL: it has to be an existing issue on the marketplace repository.",
   "head-unreadable": "Check that the plugin repository is public and its URL is right.",
+  "login-required": "gh auth login",
   "not-confirmed": "Run it again and answer y, or pass --yes when the person whose shell it is has agreed.",
   "interrupted": "shell.json was restored; run it again when the desktop is yours to restart.",
 })
@@ -74,8 +76,10 @@ const REMEDY = Object.freeze({
  */
 function fail(code, message, exit = 1, remedy = REMEDY[code], body = () => []) {
   const c = styler(colourEnabled(process.stderr))
-  const lines = [`${mark("fail", c)}${c("name", code)}`, ...wrap(message, { indent: GUTTER }, c), ...body(c)]
-  if (remedy) lines.push(...action(remedy, c))
+  const lines = withOutputStream(process.stderr, () => [
+    `${mark("fail", c)}${c("name", code)}`, ...wrap(message, { indent: GUTTER }, c), ...body(c),
+    ...(remedy ? action(remedy, c) : []),
+  ])
   process.stderr.write(`${lines.join("\n")}\n`)
   process.exit(exit)
 }
@@ -121,6 +125,12 @@ function emit(args, text) {
   }
 }
 
+function reportText(args, render, result, options = {}) {
+  const out = option(args, "--out")
+  return withOutputStream(out ? { isTTY: false } : process.stdout,
+    () => render(result, { ...options, ...(out ? { colour: false } : {}) }))
+}
+
 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)
@@ -172,7 +182,7 @@ async function cmdSubmit(args) {
     failFrom(error)
   }
   spinner.done()
-  emit(args, args.includes("--json") ? `${JSON.stringify(result, null, 2)}\n` : renderSubmit(result))
+  emit(args, args.includes("--json") ? `${JSON.stringify(result, null, 2)}\n` : reportText(args, renderSubmit, result))
   // 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)
@@ -180,18 +190,41 @@ async function cmdSubmit(args) {
 
 async function cmdWatch(args) {
   const issueUrl = positionals(args)[0]
-  if (!issueUrl) fail("usage", "watch needs an issue: `omakit watch <issue-url>`", 2)
+  const all = args.includes("--all")
+  const list = args.includes("--list")
+  const user = option(args, "--user")
+  const interactive = !args.includes("--json") && !option(args, "--out") && Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY)
+  if ((all && list) || (issueUrl && (all || list || user !== undefined))) {
+    fail("usage", "Use an issue URL, --all, or --list; --user belongs to account-wide discovery.", 2)
+  }
+  if (!issueUrl && !all && !list && !interactive) {
+    fail("usage", "watch needs an issue or a mode: `omakit watch <issue-url>`, `omakit watch --all`, or `omakit watch --list`. A terminal can pick issues with `omakit watch`.", 2)
+  }
   const spinner = spinnerFor(args)
   let result
   try {
-    result = await validationWatch({ repoRoot: ROOT, issueUrl, onPhase: spinner.phase })
+    if (issueUrl) {
+      result = await validationWatch({ repoRoot: ROOT, issueUrl, onPhase: spinner.phase })
+    } else {
+      const discovery = await discoverWatchIssues({ user, onPhase: spinner.phase })
+      if (list) {
+        result = discovery
+      } else {
+        if (!all && discovery.issues.length) {
+          spinner.done()
+          discovery.issues = await askWatchIssues({ issues: discovery.issues })
+        }
+        result = await validationWatchAll({ repoRoot: ROOT, discovery, onPhase: spinner.phase })
+      }
+    }
   } catch (error) {
     spinner.done()
     failFrom(error)
   }
   spinner.done()
-  emit(args, args.includes("--json") ? `${JSON.stringify(result, null, 2)}\n` : renderWatch(result))
-  process.exit(result.verdict.state === "unknown" ? 2 : 0)
+  const render = result.mode === "list" ? renderWatchList : result.mode === "all" ? renderWatchAll : renderWatch
+  emit(args, args.includes("--json") ? `${JSON.stringify(result, null, 2)}\n` : reportText(args, render, result))
+  process.exit(result.verdict?.state === "unknown" || result.summary?.unknown > 0 ? 2 : 0)
 }
 
 async function cmdFrontDoor() {
@@ -225,7 +258,7 @@ async function cmdDoctor(args) {
   const spinner = spinnerFor(args)
   const result = await doctor({ repoRoot: ROOT, offline: args.includes("--offline"), onPhase: spinner.phase })
   spinner.done()
-  emit(args, args.includes("--json") ? `${JSON.stringify(result, null, 2)}\n` : renderDoctor(result))
+  emit(args, args.includes("--json") ? `${JSON.stringify(result, null, 2)}\n` : reportText(args, renderDoctor, result))
   process.exit(result.problems ? 1 : 0)
 }
 
@@ -268,7 +301,7 @@ async function cmdVerify(args) {
   const blockingRules = section.invoked && section.official && !section.official.error
     ? (await consequence(requirePin(ROOT).dir, section.official)).selectivelyBlockingRules
     : []
-  emit(args, renderVerify(document, { blockingRules }))
+  emit(args, reportText(args, renderVerify, document, { blockingRules }))
 }
 
 async function cmdParity(args) {
@@ -395,7 +428,7 @@ async function cmdWeigh(args) {
   // The confirmation. The plan is printed either way, so the record says
   // what was agreed to; the question is asked only at a terminal on both
   // ends, and --yes is the only other way past it.
-  narrate.write(`${renderPlan(plan, { colour: colourEnabled(narrate) }).join("\n")}\n`)
+  narrate.write(`${withOutputStream(narrate, () => renderPlan(plan, { colour: colourEnabled(narrate) })).join("\n")}\n`)
   if (!parsed.options.has("--yes")) {
     const interactive = !json && Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY)
     if (!interactive) notWeighed("not-confirmed", `this restarts the shell ${plan.restarts} times and edits shell.json for the duration; a pipe, an agent or --json cannot answer for the person whose shell it is.`, REMEDY["not-confirmed"], 2)
@@ -460,9 +493,17 @@ const [command, ...rest] = process.argv.slice(2)
 // completion script names another omakit, so `omakit we<TAB>` may not know
 // `weigh`. One stat and one short read; never under a pipe, whose stderr
 // stays empty on success, and never for setup, which is the fix.
+if (updateCheckEnabled({ command, args: rest, stdinTTY: process.stdin.isTTY, stdoutTTY: process.stdout.isTTY, stderrTTY: process.stderr.isTTY })) {
+  const notice = await updateNotice({ repoRoot: ROOT, version: VERSION })
+  if (notice) process.stderr.write(`${wrap(notice, { width: outputColumns(process.stderr) }, styler(colourEnabled(process.stderr))).join("\n")}\n`)
+}
+
 if (command !== "setup" && process.stderr.isTTY) {
   const notice = staleCompletionNotice({ version: VERSION })
-  if (notice) process.stderr.write(`${styler(colourEnabled(process.stderr))("label", notice)}\n`)
+  if (notice) {
+    const c = styler(colourEnabled(process.stderr))
+    process.stderr.write(`${wrap(notice, { width: outputColumns(process.stderr) }).map((line) => c("label", line)).join("\n")}\n`)
+  }
 }
 
 if (command === "setup") {
@@ -526,12 +567,12 @@ if (command === "setup") {
   // The short list on a typo, not 53 lines of reference, in the same register
   // as every other failure: what happened, what it means, what to run.
   const c = styler(colourEnabled(process.stderr))
-  process.stderr.write([
+  process.stderr.write(withOutputStream(process.stderr, () => [
     `${mark("fail", c)}${c("name", "unknown command")}`,
     ...wrap(`\`${command}\` is not something omakit does. The commands it has are listed below.`, { indent: GUTTER }, c),
     ...action("omakit help", c),
     "",
-    renderSummary({ colour: colourEnabled(process.stderr), heading: false }),
-  ].join("\n"))
+    renderSummary({ stream: process.stderr, colour: colourEnabled(process.stderr), heading: false }),
+  ].join("\n")))
   process.exit(2)
 }

package/tools/marketplace/doctor.mjs

@@ -42,7 +42,7 @@ import { join } from "node:path"
 import { MARKETPLACE_PIN, PIN_PATHS, marketplacePinDir, pinDiskUsage, pinIsSparse, requirePin } from "./pin.mjs"
 import { LIVE_PATHS } from "./registry.mjs"
 import { credential, defaultBranchHead, getJson, UNAUTHENTICATED_LIMIT, GitHubError } from "./github.mjs"
-import { NPM_REGISTRY, registryLatest, upgradeCommand } from "./upgrade.mjs"
+import { compareVersions, NPM_REGISTRY, registryLatest, upgradeCommand } from "./upgrade.mjs"
 import { pathHint } from "./path-hint.mjs"
 import { completionStatus } from "./completion-check.mjs"
 
@@ -205,11 +205,17 @@ export async function doctor({ repoRoot, offline = false, onPhase, env = process
     phase("asking the npm registry for the newest published version")
     const published = await latestVersion(self.name)
     if (published.version) {
-      const current = published.version === self.version
-      versionCheck(current ? "ok" : "advice",
-        current ? `${self.version}, the newest published version` : `${self.version}; ${published.version} is published`,
-        current ? null : `run \`${upgradeCommand(repoRoot, self.name)}\``,
-        published.version, NPM_REGISTRY)
+      const comparison = compareVersions(published.version, self.version)
+      if (comparison === null) {
+        versionCheck("unknown", `${self.version}; the installed or published version is invalid`)
+      } else {
+        versionCheck(comparison > 0 ? "advice" : "ok",
+          comparison === 0 ? `${self.version}, the newest published version`
+            : comparison < 0 ? `${self.version}; ahead of the newest published version ${published.version}`
+              : `${self.version}; ${published.version} is published`,
+          comparison > 0 ? `run \`${upgradeCommand(repoRoot, self.name)}\`` : null,
+          published.version, NPM_REGISTRY)
+      }
     } else {
       versionCheck("unknown", `${self.version}; could not read the npm registry (${published.error?.code || "error"})`)
     }

package/tools/marketplace/github.mjs

@@ -109,7 +109,7 @@ export function token() {
 /** The one host the borrowed gh credential may be sent to. */
 export const CREDENTIAL_HOST = "api.github.com"
 
-async function get(url, { accept } = {}) {
+async function get(url, { accept, signal } = {}) {
   const { host } = new URL(url)
   // The credential is GitHub's and goes to GitHub's API and nowhere else.
   // Measured before this held: `omakit upgrade` and `doctor` sent the gh
@@ -125,7 +125,7 @@ async function get(url, { accept } = {}) {
   if (auth) headers.authorization = `Bearer ${auth}`
   let response
   try {
-    response = await fetch(url, { method: "GET", headers, redirect: "follow" })
+    response = await fetch(url, { method: "GET", headers, redirect: "follow", ...(signal ? { signal } : {}) })
   } catch (error) {
     // Node reports every transport failure as "fetch failed" with the real
     // reason in `cause`. A person needs the reason, and the CLI keys its
@@ -150,8 +150,8 @@ async function get(url, { accept } = {}) {
   return response
 }
 
-export async function getJson(url) {
-  return (await get(url)).json()
+export async function getJson(url, options) {
+  return (await get(url, options)).json()
 }
 
 export async function getText(url, accept) {
@@ -171,17 +171,38 @@ export async function issue(owner, repository, number) {
   return getJson(`https://api.github.com/repos/${owner}/${repository}/issues/${number}`)
 }
 
-export async function issueComments(owner, repository, number, maxPages = 10) {
+/** Resolve the account whose credential gh lent us; never persist it. */
+export async function authenticatedUser() {
+  if (!token()) throw new GitHubError("login-required", "Account-wide watch needs your GitHub login. Run `gh auth login`, or pass --user <login> to read a public account.")
+  const user = await getJson("https://api.github.com/user")
+  if (!user?.login) throw new GitHubError("github-unavailable", "GitHub did not return the signed-in account's login")
+  return user.login
+}
+
+/** Repository issues by their creator. PRs are excluded; pagination never silently truncates. */
+export async function repositoryIssues(owner, repository, creator, { readJson = getJson, maxPages = 100 } = {}) {
+  const all = []
+  for (let page = 1; page <= maxPages; page += 1) {
+    const query = new URLSearchParams({ creator, state: "open", sort: "updated", direction: "desc", per_page: "100", page: String(page) })
+    const batch = await readJson(`https://api.github.com/repos/${owner}/${repository}/issues?${query}`)
+    if (!Array.isArray(batch)) throw new GitHubError("github-unavailable", "GitHub did not return an issue list")
+    all.push(...batch.filter((item) => !item.pull_request))
+    if (batch.length < 100) return all
+  }
+  throw new GitHubError("issue-list-incomplete", `The issue list exceeded ${maxPages} pages; no complete account-wide result is available`)
+}
+
+export async function issueComments(owner, repository, number, maxPages = 10, readJson = getJson) {
   const all = []
   for (let page = 1; page <= maxPages; page += 1) {
-    const batch = await getJson(
+    const batch = await readJson(
       `https://api.github.com/repos/${owner}/${repository}/issues/${number}/comments?per_page=100&page=${page}`,
     )
-    if (!Array.isArray(batch) || !batch.length) break
+    if (!Array.isArray(batch)) throw new GitHubError("github-unavailable", "GitHub did not return issue comments")
     all.push(...batch)
-    if (batch.length < 100) break
+    if (batch.length < 100) return all
   }
-  return all
+  throw new GitHubError("comments-incomplete", `Issue #${number} exceeded ${maxPages} comment pages; its latest baseline cannot be determined`)
 }
 
 /**

package/tools/marketplace/options.mjs

@@ -21,7 +21,7 @@ export const ACCEPTED = Object.freeze({
   setup: Object.freeze({ valued: [], flags: ["--yes", "--completion"], positionals: 0 }),
   pin: Object.freeze({ valued: [], flags: [], positionals: 0 }),
   submit: Object.freeze({ valued: ["--category", "--tags", "--notes", "--suggest-tag", "--name", "--out"], flags: ["--offline", "--allow-dirty", "--json"], positionals: 1 }),
-  watch: Object.freeze({ valued: ["--out"], flags: ["--json"], positionals: 1 }),
+  watch: Object.freeze({ valued: ["--out", "--user"], flags: ["--json", "--all", "--list"], positionals: 1 }),
   verify: Object.freeze({ valued: ["--out"], flags: ["--allow-dirty", "--json"], positionals: 1 }),
   help: Object.freeze({ valued: [], flags: ["--agent"], positionals: 0 }),
   upgrade: Object.freeze({ valued: [], flags: ["--dry-run"], positionals: 0 }),

package/tools/marketplace/report.mjs

@@ -18,9 +18,10 @@
 // screen, and the last screen is the one a person is looking at.
 
 import {
-  action, colourEnabled, COLUMNS, continuation, field, GUTTER, labelled, mark, section, STEP, styler, verdict, width, wrap,
+  action, colourEnabled, outputColumns, continuation, field, GUTTER, labelled, mark, section, STEP, styler, verdict, width, wrap,
 } from "./style.mjs"
 import { withHomeAbbreviated } from "./paths.mjs"
+import { watchIssueTitle } from "./watch.mjs"
 
 const body = " ".repeat(GUTTER)
 
@@ -41,7 +42,11 @@ function stateOf(check) {
 export function head(state, id, source, c) {
   const left = `${mark(state, c)}${c("name", id)}`
   const tag = c("punctuation", `[${source}]`)
-  const gap = Math.max(2, COLUMNS - width(left) - width(tag))
+  const columns = outputColumns()
+  if (width(left) + width(tag) + 2 > columns) {
+    return `${left}\n${wrap(`[${source}]`, { indent: GUTTER }).map((line) => c("punctuation", line)).join("\n")}`
+  }
+  const gap = columns - width(left) - width(tag)
   return `${left}${" ".repeat(gap)}${tag}`
 }
 
@@ -77,7 +82,7 @@ function commandLines(command, c) {
       units.push(word)
     }
   }
-  const room = COLUMNS - STEP - " \\".length
+  const room = outputColumns() - STEP - " \\".length
   const lines = []
   let line = ""
   for (const unit of units) {
@@ -244,6 +249,50 @@ export function renderWatch(result, { colour = colourEnabled() } = {}) {
   return out.join("\n")
 }
 
+/** Discovery is cheap: issue metadata and repeatable commands, no plugin HEAD reads. */
+export function renderWatchList(result, { colour = colourEnabled() } = {}) {
+  const c = styler(colour)
+  const out = [...field("account", result.account, c), ...field("issues", `${result.issues.length} open marketplace issue(s)`, c), ""]
+  for (const issue of result.issues) {
+    out.push(...wrap(`#${issue.number} ${watchIssueTitle(issue.title)}`, {}, c))
+    out.push(...field("state", `${issue.state}${issue.labels.length ? `; labels ${issue.labels.map(watchIssueTitle).join(", ")}` : ""}`, c))
+    out.push(...action(`omakit watch ${issue.url}`, c, { indent: 0 }), "")
+  }
+  if (!result.issues.length) out.push(...wrap("No open marketplace issues found for this account.", {}, c))
+  else out.push(...action(`omakit watch --all --user ${result.account}`, c, { indent: 0 }))
+  return out.join("\n")
+}
+
+/** Compact batch report; exact commits and full discussion remain in JSON. */
+export function renderWatchAll(result, { colour = colourEnabled() } = {}) {
+  const c = styler(colour)
+  const out = [...field("account", result.account, c), ...field("issues", `${result.summary.total} checked; ${result.summary.current} current, ${result.summary.stale} stale, ${result.summary.unknown} unknown`, c), ""]
+  for (const row of result.issues) {
+    const state = row.report?.verdict.state || "unknown"
+    const style = { current: "pass", stale: "fail", unknown: "unknown" }[state]
+    out.push(...verdict(style, state.toUpperCase(), `#${row.issue.number} ${watchIssueTitle(row.report?.read.title || row.issue.title)}`, c))
+    out.push(...field("issue", row.issue.url, c, { wrapValue: false }))
+    if (row.error) {
+      out.push(...field("read error", watchIssueTitle(`${row.error.code}: ${row.error.message}`), c))
+    } else {
+      const report = row.report
+      out.push(...field("baseline", report.validated ? `${report.validated.outcome}; ${report.validated.findings.length} finding(s); capabilities ${report.validated.capabilities.join(", ") || "none"}` : "no complete baseline", c))
+      out.push(...field("state", `${report.read.state}; labels ${report.read.labels.map(watchIssueTitle).join(", ") || "none"}`, c))
+      if (state !== "current") out.push(...field("comparison", report.verdict.summary, c))
+      if (report.discussion) {
+        const text = watchIssueTitle(report.discussion.body).replace(/\s+/g, " ").trim()
+        out.push(...field("discussion", text.length > 240 ? `${text.slice(0, 240)}…` : text, c))
+        if (report.discussion.url) out.push(...field("source", report.discussion.url, c, { wrapValue: false }))
+      }
+      if (report.verdict.action) out.push(...action(report.verdict.action, c, { indent: 0 }))
+    }
+    out.push("")
+  }
+  if (!result.issues.length) out.push(...wrap("No issues selected for checking.", {}, c))
+  out.push(...wrap("Current means the validated commit matches HEAD. It does not mean review, approval or publication is complete. Read-only; this run posts nothing.", {}, c))
+  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 })

package/tools/marketplace/style.mjs

@@ -115,9 +115,8 @@ export function code(role) {
 // --- geometry ---------------------------------------------------------------
 
 /**
- * The width everything is composed for. Eighty columns is the contract: a
- * check's why-paragraph, a remedy, a refusal and the help all wrap inside it,
- * and tests/unit/style.test.mjs renders every report and measures. The one
+ * The stable width for pipes and files. Terminals use their current column
+ * count, up to MAX_COLUMNS so wide windows still have readable prose. The one
  * thing exempt is the marketplace's own baseline report, which is printed
  * verbatim because rewrapping somebody else's attestation would be editing it.
  *
@@ -125,6 +124,23 @@ export function code(role) {
  * `overflows` below is the measurement, and it is the one both test files use.
  */
 export const COLUMNS = 80
+export const MAX_COLUMNS = 120
+
+let compositionStream = null
+
+/** Resolve at rendering time, so a resized terminal's next output uses its new width. */
+export function outputColumns(stream = compositionStream || process.stdout) {
+  return stream?.isTTY && Number.isFinite(stream.columns) && stream.columns >= 1
+    ? Math.min(MAX_COLUMNS, Math.floor(stream.columns))
+    : COLUMNS
+}
+
+/** Scope synchronous composition to its destination, including files and stderr. */
+export function withOutputStream(stream, render) {
+  const previous = compositionStream
+  compositionStream = stream
+  try { return render() } finally { compositionStream = previous }
+}
 
 /**
  * The indent scale, in columns. Three stops, and every line in the tool starts
@@ -327,7 +343,7 @@ export function overflows(line, total = COLUMNS) {
 // --- composition ------------------------------------------------------------
 
 /**
- * Wrap prose to the contract width, and paint it.
+ * Wrap prose to the destination width, and paint it.
  *
  * `indent` is the column the text starts in and is part of the width, which is
  * the bug the earlier version had: it wrapped at 78 and then indented by 7, and
@@ -346,7 +362,7 @@ export function overflows(line, total = COLUMNS) {
  * @param {(name: string, text: string) => string} [c]
  * @returns {string[]} lines, indented and painted
  */
-export function wrap(text, { indent = 0, width: total = COLUMNS, first = indent } = {}, c = styler(false)) {
+export function wrap(text, { indent = 0, width: total = outputColumns(), first = indent } = {}, c = styler(false)) {
   // A word is a run of non-spaces, or a backticked span with whatever
   // punctuation clings to it: "(`omakit pin`)." is one word.
   const words = String(text).match(/[^\s`]*`[^`]*`[^\s`]*|\S+/g) || []
@@ -422,7 +438,7 @@ export function continuation(value, c) {
  * under itself. There is exactly one of these under any failure, and it is the
  * only line in the tool that starts with an arrow, so it can be found by shape.
  */
-export function action(text, c, { indent = GUTTER, width: total = COLUMNS } = {}) {
+export function action(text, c, { indent = GUTTER, width: total = outputColumns() } = {}) {
   // Painted after wrapping, and all of it cyan: the whole line is the thing
   // to do, so a backticked word inside it has nothing to stand out from.
   const lines = wrap(text, { indent: indent + 2, width: total })
@@ -449,11 +465,11 @@ export function labelled(label, text, c, { indent = GUTTER } = {}) {
  * grey. It is the same shape the wordmark uses (the name, then its rule), so a
  * section of a report and the front door of the tool are drawn by one idea.
  */
-export function section(title, c, { width: total = COLUMNS } = {}) {
+export function section(title, c, { width: total = outputColumns() } = {}) {
   return [c("heading", title), c("punctuation", DENSITY.floor.repeat(total))]
 }
 
 /** A rule with no heading, the same floor, for a wordmark or a block that names itself. */
-export function rule(c, { width: total = COLUMNS, tint = "punctuation" } = {}) {
+export function rule(c, { width: total = outputColumns(), tint = "punctuation" } = {}) {
   return c(tint, DENSITY.floor.repeat(total))
 }

package/tools/marketplace/update-check.mjs

@@ -0,0 +1,48 @@
+// A passive npm-version notice. Only metadata and a throttle stamp are stored;
+// nothing is installed or executed. Explicit doctor checks bypass this throttle.
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { homedir } from "node:os"
+import { compareVersions, registryLatest, upgradeCommand } from "./upgrade.mjs"
+
+export const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000
+export const UPDATE_RETRY_INTERVAL_MS = 60 * 60 * 1000
+export const UPDATE_CHECK_TIMEOUT_MS = 1000
+
+export function updateCheckEnabled({ command, args = [], stdinTTY, stdoutTTY, stderrTTY, env = process.env }) {
+  return Boolean(stdinTTY && stdoutTTY && stderrTTY)
+    && !env.DISABLE_UPDATE_NOTIFIER && !env.CI
+    && !args.some((arg) => arg === "--offline" || arg === "--json" || arg === "--agent" || arg === "--out" || arg.startsWith("--out="))
+    && (command === undefined || ["watch", "submit", "verify", "audit", "weigh"].includes(command))
+    && !args.includes("--help") && !args.includes("-h")
+}
+
+/** At most one registry read and one notice per successful day (failure retries after an hour). */
+export async function updateNotice({ repoRoot, version, name = "omakit", env = process.env, now = Date.now(), latest = registryLatest, timeoutMs = UPDATE_CHECK_TIMEOUT_MS }) {
+  if (compareVersions(version, version) === null) return null
+  const updateFile = join(env.XDG_STATE_HOME || join(homedir(), ".local/state"), "omakit", "update-check.json")
+  try {
+    const cached = JSON.parse(readFileSync(updateFile, "utf8"))
+    const age = now - cached.checkedAt
+    const validMetadata = cached.latest === null || compareVersions(cached.latest, cached.latest) !== null
+    if (cached.installed === version && cached.name === name && validMetadata && Number.isFinite(age) && age >= 0
+      && age < (cached.latest ? UPDATE_CHECK_INTERVAL_MS : UPDATE_RETRY_INTERVAL_MS)) return null
+  } catch { /* Missing or malformed state triggers a fresh bounded read. */ }
+  const controller = new AbortController()
+  let timer
+  let published
+  try {
+    published = await Promise.race([
+      Promise.resolve().then(() => latest(name, { signal: controller.signal })).catch(() => ({ version: null })),
+      new Promise((resolve) => { timer = setTimeout(() => { controller.abort(); resolve({ version: null }) }, timeoutMs) }),
+    ])
+  } finally { clearTimeout(timer) }
+  const newest = compareVersions(published?.version, published?.version) === null ? null : published.version
+  try {
+    mkdirSync(dirname(updateFile), { recursive: true })
+    writeFileSync(updateFile, `${JSON.stringify({ name, installed: version, latest: newest, checkedAt: now })}\n`, { mode: 0o600 })
+  } catch { /* An unwritable state directory must not break the user's command. */ }
+  return newest && compareVersions(newest, version) > 0
+    ? `Omakit ${newest} is available (installed ${version}). Run \`${upgradeCommand(repoRoot, name)}\`.`
+    : null
+}

package/tools/marketplace/upgrade.mjs

@@ -74,9 +74,12 @@ export const NPM_REGISTRY = "https://registry.npmjs.org"
  *
  * @returns {Promise<{ version: string|null, error: { code: string, message: string }|null }>}
  */
-export async function registryLatest(name) {
+export async function registryLatest(name, { signal } = {}) {
   try {
-    const meta = await getJson(`${NPM_REGISTRY}/${encodeURIComponent(name)}/latest`)
+    const meta = await getJson(`${NPM_REGISTRY}/${encodeURIComponent(name)}/latest`, { signal })
+    if (meta?.version && compareVersions(meta.version, meta.version) === null) {
+      return { version: null, error: { code: "invalid-version", message: "the registry did not return a valid semantic version" } }
+    }
     return meta?.version
       ? { version: meta.version, error: null }
       : { version: null, error: { code: "unpublished", message: "the registry answered without a version" } }
@@ -85,6 +88,33 @@ export async function registryLatest(name) {
   }
 }
 
+/** Semantic precedence, including prereleases; invalid versions are never update targets. */
+export function compareVersions(left, right) {
+  const parse = (value) => {
+    const match = String(value || "").match(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/)
+    if (!match) return null
+    const pre = match[4]?.split(".") || []
+    if (pre.some((part) => /^\d+$/.test(part) && part.length > 1 && part.startsWith("0"))) return null
+    return { core: match.slice(1, 4).map(BigInt), pre }
+  }
+  const a = parse(left), b = parse(right)
+  if (!a || !b) return null
+  for (let index = 0; index < 3; index += 1) {
+    if (a.core[index] !== b.core[index]) return a.core[index] > b.core[index] ? 1 : -1
+  }
+  if (!a.pre.length || !b.pre.length) return a.pre.length === b.pre.length ? 0 : a.pre.length ? -1 : 1
+  for (let index = 0; index < Math.max(a.pre.length, b.pre.length); index += 1) {
+    const x = a.pre[index], y = b.pre[index]
+    if (x === undefined || y === undefined) return x === y ? 0 : x === undefined ? -1 : 1
+    if (x === y) continue
+    const xn = /^\d+$/.test(x), yn = /^\d+$/.test(y)
+    if (xn && yn) return BigInt(x) > BigInt(y) ? 1 : -1
+    if (xn !== yn) return xn ? -1 : 1
+    return x > y ? 1 : -1
+  }
+  return 0
+}
+
 function installedVersion(repoRoot) {
   try {
     return JSON.parse(readFileSync(join(repoRoot, "package.json"), "utf8")).version || null
@@ -300,8 +330,10 @@ async function upgradeNpm({ repoRoot, stream, dryRun, latest, npmRoot, name, ref
   if (!newest) {
     return refuse("the npm registry did not answer, so there is nothing to compare against.", "Connect to the network, then run `omakit upgrade` again.")
   }
-  if (newest === current) {
-    ok(`already current at ${current}, the newest published version`)
+  const compared = compareVersions(newest, current)
+  if (compared === null) return refuse("the installed or published version is invalid, so an exact newer release cannot be selected.")
+  if (compared <= 0) {
+    ok(compared === 0 ? `already current at ${current}, the newest published version` : `${current} is ahead of the newest published version ${newest}; no downgrade applied`)
     out()
     lines(wrap("The marketplace pin is a separate thing and is never touched here. `omakit doctor` says whether it is behind.", {}, c))
     return { ok: true, changed: false, version: current }

package/tools/marketplace/usage.mjs

@@ -7,7 +7,7 @@
 
 import { UNAUTHENTICATED_LIMIT } from "./github.mjs"
 import { MARKETPLACE_PIN } from "./pin.mjs"
-import { colourEnabled, paintProse, STEP, styler } from "./style.mjs"
+import { colourEnabled, paintProse, STEP, styler, withOutputStream, wrap } from "./style.mjs"
 
 /**
  * "Safe" means one thing, everywhere it appears: this runs on your own
@@ -69,11 +69,18 @@ export const COMMANDS = Object.freeze([
     ],
   },
   {
-    signature: "omakit watch <issue-url> [--json] [--out <file>]",
+    signature: [
+      "omakit watch <issue-url> [--json] [--out <file>]",
+      "omakit watch [--all | --list] [--user <login>] [--json] [--out <file>]",
+    ],
     lines: [
       "Compare the commit the marketplace validated on a submission issue with",
       "the plugin repository's current default-branch HEAD, and say what makes",
       "it validate a newer one. Read-only.",
+      "--all checks your open marketplace issues; --list lists them first.",
+      "Without a URL or either flag, a terminal asks which issues to check.",
+      "Uses your gh account, or --user to read another public account. JSON",
+      "and pipes never prompt: use --all or --list. Each run is one snapshot.",
     ],
   },
   {
@@ -104,6 +111,8 @@ export const COMMANDS = Object.freeze([
     lines: [
       "What is installed, what is pinned, and what has moved since. Reads and",
       "prints; it installs nothing and never moves the pin.",
+      "Checks the newest npm release explicitly. Normal terminal use also",
+      "checks at most once daily; DISABLE_UPDATE_NOTIFIER=1 disables notices.",
     ],
   },
   {
@@ -199,16 +208,40 @@ export function paintSignature(signature, c) {
  *
  * @param {{ colour?: boolean, heading?: boolean }} [options]
  */
-export function renderSummary({ colour = colourEnabled(), heading = true } = {}) {
-  const c = styler(colour)
-  const out = heading ? [`${c("typeable.bold", "omakit")}${c("punctuation", ":")} ${TAGLINE}`, ""] : []
-  for (const command of COMMANDS) {
-    out.push(`${INDENT}${paintSignature([].concat(command.signature)[0], c)}`)
+function commandSignatures(command) {
+  const signatures = []
+  for (const line of [].concat(command.signature)) {
+    if (line.startsWith("omakit ")) signatures.push(line)
+    else signatures[signatures.length - 1] += ` ${line}`
   }
-  out.push("")
-  out.push(`${INDENT}${paintProse("`omakit help` is the same list with what each command does, and", c)}`)
-  out.push(`${INDENT}${paintProse("what it reads. `omakit setup` is the one to run first.", c)}`)
-  return `${out.join("\n")}\n`
+  return signatures
+}
+
+function signatureLines(signature, c) {
+  // A placeholder or bracketed optional argument stays whole, like the
+  // backticked typeable spans used by the shared wrapper.
+  const grouped = signature.replace(/\[[^\]]+\]|<[^>]+>(?:@<[^>]+>)?/g, (part) => `\`${part}\``)
+  return wrap(grouped, { indent: STEP * 3, first: STEP }).map((line) => paintSignature(line, c))
+}
+
+export function renderSummary({ stream = process.stdout, colour = colourEnabled(stream), heading = true } = {}) {
+  return withOutputStream(stream, () => {
+    const c = styler(colour)
+    const out = heading ? [`${c("typeable.bold", "omakit")}${c("punctuation", ":")} ${TAGLINE}`, ""] : []
+    if (stream.isTTY && heading) out.splice(0, 1, ...wrap(out[0]))
+    for (const command of COMMANDS) {
+      if (stream.isTTY) out.push(...signatureLines([].concat(command.signature)[0], c))
+      else out.push(`${INDENT}${paintSignature([].concat(command.signature)[0], c)}`)
+    }
+    out.push("")
+    if (stream.isTTY) {
+      out.push(...wrap("`omakit help` is the same list with what each command does, and what it reads. `omakit setup` is the one to run first.", { indent: STEP }, c))
+    } else {
+      out.push(`${INDENT}${paintProse("`omakit help` is the same list with what each command does, and", c)}`)
+      out.push(`${INDENT}${paintProse("what it reads. `omakit setup` is the one to run first.", c)}`)
+    }
+    return `${out.join("\n")}\n`
+  })
 }
 
 /**
@@ -216,23 +249,29 @@ export function renderSummary({ colour = colourEnabled(), heading = true } = {})
  *   when the line above has already named the tool, as under an unknown
  *   command, so the same sentence is not printed twice.
  */
-export function renderUsage({ colour = colourEnabled(), heading = true } = {}) {
-  const c = styler(colour)
-  const out = heading ? [`${c("typeable.bold", "omakit")}${c("punctuation", ":")} ${TAGLINE}`, ""] : []
+export function renderUsage({ stream = process.stdout, colour = colourEnabled(stream), heading = true } = {}) {
+  return withOutputStream(stream, () => {
+    const c = styler(colour)
+    const out = heading ? [`${c("typeable.bold", "omakit")}${c("punctuation", ":")} ${TAGLINE}`, ""] : []
+    if (stream.isTTY && heading) out.splice(0, 1, ...wrap(out[0]))
 
-  for (const command of COMMANDS) {
-    for (const line of [].concat(command.signature)) {
-      out.push(`${INDENT}${paintSignature(line, c)}`)
+    for (const command of COMMANDS) {
+      if (stream.isTTY) {
+        for (const signature of commandSignatures(command)) out.push(...signatureLines(signature, c))
+        out.push(...wrap(command.lines.join(" "), { indent: STEP * 3 }, c))
+      } else {
+        for (const line of [].concat(command.signature)) out.push(`${INDENT}${paintSignature(line, c)}`)
+        for (const line of command.lines) out.push(`${DESCRIPTION}${paintProse(line, c)}`)
+      }
+      out.push("")
     }
-    for (const line of command.lines) {
-      out.push(`${DESCRIPTION}${paintProse(line, c)}`)
-    }
-    out.push("")
-  }
 
-  out.push(`${INDENT}${paintSignature(TARGET_NOTE, c)}`)
-  out.push("")
-  out.push(c("heading", "GitHub access:"))
-  for (const line of AUTHENTICATION) out.push(`${INDENT}${paintProse(line, c)}`)
-  return `${out.join("\n")}\n`
+    if (stream.isTTY) out.push(...signatureLines(TARGET_NOTE, c))
+    else out.push(`${INDENT}${paintSignature(TARGET_NOTE, c)}`)
+    out.push("")
+    out.push(c("heading", "GitHub access:"))
+    if (stream.isTTY) out.push(...wrap(AUTHENTICATION.join(" "), { indent: STEP }, c))
+    else for (const line of AUTHENTICATION) out.push(`${INDENT}${paintProse(line, c)}`)
+    return `${out.join("\n")}\n`
+  })
 }

package/tools/marketplace/watch.mjs

@@ -29,7 +29,7 @@
 import { join } from "node:path"
 import { pathToFileURL } from "node:url"
 import { MARKETPLACE_PIN, requirePin } from "./pin.mjs"
-import { defaultBranchHead, issue, issueComments, parseIssueUrl, token, GitHubError } from "./github.mjs"
+import { authenticatedUser, repositoryIssues, defaultBranchHead, issue, issueComments, parseIssueUrl, token, GitHubError } from "./github.mjs"
 
 export class WatchError extends Error {
   constructor(code, message) {
@@ -41,6 +41,70 @@ export class WatchError extends Error {
 
 const MARKETPLACE_SLUG = MARKETPLACE_PIN.repository.replace(/^https:\/\/github\.com\//, "").toLowerCase()
 
+/** Text from an issue remains data, including at a terminal. JSON retains the original title. */
+export function watchIssueTitle(value) {
+  return String(value || "").replace(/[\p{Cc}\p{Cf}]/gu, " ")
+}
+
+/** Discover the account's open marketplace issues, without reading every plugin. */
+export async function discoverWatchIssues({ user, github = {}, onPhase = () => {} } = {}) {
+  const read = { authenticatedUser, repositoryIssues, ...github }
+  if (user !== undefined && !/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})$/.test(user)) {
+    throw new WatchError("usage", "--user needs a GitHub login, not a URL or search query")
+  }
+  onPhase("reading the GitHub account")
+  const account = user || await read.authenticatedUser()
+  const [owner, repository] = MARKETPLACE_SLUG.split("/")
+  onPhase(`reading open marketplace issues for ${account}`)
+  const subjects = await read.repositoryIssues(owner, repository, account)
+  // Check the response as well as the server-side creator filter. Never turn
+  // another author's issue, or a PR, into an account-wide watch target.
+  const seen = new Set()
+  const issues = subjects.filter((subject) => {
+    if (subject.pull_request || subject.state !== "open" || subject.user?.login?.toLowerCase() !== account.toLowerCase()) return false
+    if (!Number.isSafeInteger(subject.number) || subject.number < 1 || seen.has(subject.number)) return false
+    seen.add(subject.number)
+    return true
+  }).map((subject) => ({
+    number: subject.number,
+    url: `${MARKETPLACE_PIN.repository}/issues/${subject.number}`,
+    title: subject.title,
+    state: subject.state,
+    labels: (subject.labels || []).map((label) => typeof label === "string" ? label : label?.name).filter(Boolean),
+    updatedAt: subject.updated_at || null,
+  }))
+  return { mode: "list", account, marketplace: MARKETPLACE_PIN.repository, issues }
+}
+
+/** A batch keeps independent read failures visible and shares repository HEAD reads. */
+export async function validationWatchAll({ repoRoot, discovery, github = {}, onPhase = () => {} }) {
+  if (discovery.issues.length) requirePin(repoRoot)
+  const heads = new Map()
+  const readHead = github.defaultBranchHead || defaultBranchHead
+  const shared = { ...github, defaultBranchHead: (url) => {
+    if (!heads.has(url)) heads.set(url, Promise.resolve().then(() => readHead(url)))
+    return heads.get(url)
+  } }
+  const results = new Array(discovery.issues.length)
+  let next = 0
+  async function worker() {
+    while (next < discovery.issues.length) {
+      const index = next++
+      const target = discovery.issues[index]
+      onPhase(`checking issue #${target.number} (${index + 1}/${discovery.issues.length})`)
+      try {
+        results[index] = { issue: target, report: await validationWatch({ repoRoot, issueUrl: target.url, github: shared }), error: null }
+      } catch (error) {
+        results[index] = { issue: target, report: null, error: { code: error.code || "watch-unavailable", message: error.message } }
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(4, discovery.issues.length) }, worker))
+  const summary = { total: results.length, current: 0, stale: 0, unknown: 0 }
+  for (const result of results) summary[result.report?.verdict.state || "unknown"] += 1
+  return { mode: "all", account: discovery.account, marketplace: discovery.marketplace, summary, issues: results }
+}
+
 // The one action that re-runs validation, in the register the marketplace itself
 // uses in its own failure feedback.
 export const REFRESH_ACTION =
@@ -207,6 +271,12 @@ export async function validationWatch({ repoRoot, issueUrl, onPhase, github = {}
     baselineError,
     head,
     headError,
+    discussion: maintainerComments.length ? {
+      body: maintainerComments.at(-1).body || "",
+      url: maintainerComments.at(-1).html_url || null,
+      createdAt: maintainerComments.at(-1).created_at || null,
+      authorAssociation: maintainerComments.at(-1).author_association || null,
+    } : null,
     verdict: validationVerdict({ comparable, stale, validated, head, fallback, baselineError, headError, pushedAfterReview, repositoryUrl }),
   }
 }

package/tools/weigh/confirm.mjs

@@ -5,7 +5,7 @@
 // typed here is written anywhere.
 
 import { createInterface } from "node:readline"
-import { action, colourEnabled, COLUMNS, styler } from "../marketplace/style.mjs"
+import { action, colourEnabled, outputColumns, styler } from "../marketplace/style.mjs"
 
 /**
  * The question as it is written to the terminal: the arrow line, wrapped
@@ -20,7 +20,7 @@ import { action, colourEnabled, COLUMNS, styler } from "../marketplace/style.mjs
  * @param {{ width?: number }} [options]
  * @returns {string} every line, joined, ending in `[y/N]: `
  */
-export function renderQuestion(question, c, { width = COLUMNS } = {}) {
+export function renderQuestion(question, c, { width = outputColumns() } = {}) {
   return `${action(`${question} [y/N]:`, c, { indent: 0, width }).join("\n")} `
 }
 
@@ -28,7 +28,7 @@ export function renderQuestion(question, c, { width = COLUMNS } = {}) {
  * @param {{ input?: NodeJS.ReadStream, output?: NodeJS.WriteStream, colour?: boolean, question: string, width?: number }} options
  * @returns {Promise<boolean>} true only for `y` or `yes`, in any case; an empty line and the end of stdin are no
  */
-export function askYes({ input = process.stdin, output = process.stderr, colour = colourEnabled(output), question, width = COLUMNS }) {
+export function askYes({ input = process.stdin, output = process.stderr, colour = colourEnabled(output), question, width = outputColumns(output) }) {
   const c = styler(colour)
   return new Promise((resolve) => {
     const rl = createInterface({ input, terminal: false })