uniweb 1.21.0 → 1.21.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "1.21.0",
+  "version": "1.21.1",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -42,14 +42,14 @@
     "prompts": "^2.4.2",
     "tar": "^7.5.21",
     "@uniweb/content-writer": "~1.3.1",
-    "@uniweb/core": "~1.4.7",
     "@uniweb/schemas": "~1.6.5",
+    "@uniweb/core": "~1.4.7",
     "@uniweb/semantic-parser": "~1.13.0"
   },
   "peerDependencies": {
-    "@uniweb/build": "~1.10.2",
-    "@uniweb/content-reader": "~1.5.7",
-    "@uniweb/semantic-parser": "~1.13.0"
+    "@uniweb/build": "~1.10.3",
+    "@uniweb/semantic-parser": "~1.13.0",
+    "@uniweb/content-reader": "~1.5.7"
   },
   "peerDependenciesMeta": {
     "@uniweb/build": {

package/partials/agents.md

@@ -44,7 +44,7 @@ uniweb doctor                # diagnose project configuration (--fix to repair)
 
 `uniweb inspect` is the important one for content. Every parse rule in Part 3 is faster to *confirm* than to re-derive, and re-deriving from memory is where agents go wrong. Don't predict the shape — print it.
 
-`uniweb status` is the one for a project other people edit. A site in the Uniweb app can change there at any time, teammates push to git, and Uniweb releases often. Run it when you begin, before you push, and after a command refuses: it changes nothing, and ends with the commands to run, in order (`--json` for a script).
+`uniweb status` is the one for a project other people edit. A site in the Uniweb app can change there at any time, teammates push to git, and Uniweb releases often. Run it when you begin, when you come back to the project, before you push, publish or deploy, and after a command refuses: it changes nothing, opens with what the site is — synced where, live where — and ends with the commands to run, in order (`--json` for a script).
 
 ### The four silent failures
 
@@ -2864,6 +2864,14 @@ uniweb <command> --help           # Per-command flags — no side effects. Prefe
 
 Foundations have their own free path too: `uniweb add ci --target foundation` publishes to permanent versioned URLs on GitHub Pages.
 
+**Three facts about a site, and they are independent — `uniweb status` opens with all three:**
+
+- **Synced** — the project has a site on a backend, so authors can edit it in the Uniweb app. `sync.json` names it on each backend: `https://uniweb.app` by default, or a server of your own (`uniweb login --server <url>`).
+- **Published** — that backend serves it live: Uniweb Cloud, on `https://uniweb.app`. A published site is a synced site; a synced site need not be published — it can sit in the app as a draft.
+- **Deployed** — a build of it is on another host, such as GitHub Pages or S3: by CI on every push (`uniweb add ci`), or by hand (`uniweb deploy`). `deploy.yml` lists those hosts, and a bare `uniweb deploy` goes to its default target.
+
+A site can be in more than one place — usually while it moves from one host to another. Before you ship, read where it is: `publish` makes a change live on Uniweb Cloud, `git push` on a CI-deployed host, and `uniweb deploy --target <name>` on one deployed by hand — and each of these is the person's to decide. `uniweb status` also lists the services the live site has (`services:` in `site.yml` is the request, never proof of what the site has).
+
 ### Uniweb Cloud and the two-sided workflow
 
 `uniweb publish` ships to Uniweb Cloud, and it's worth understanding what that buys, because it isn't only hosting — it's how a team of technical and non-technical people works on one site.
@@ -2902,7 +2910,7 @@ Foundations have their own free path too: `uniweb add ci --target foundation` pu
 - **Git is the reviewed, durable record** — you `pull` content back, read it with `git diff`, and commit.
 - **Authors never push or pull.** For them, content simply updates, whether the change came from another author or from a developer's CLI.
 
-**Working on a site others edit — run `uniweb status` when you begin, before you push, and after any refusal.** It reads the backend without taking anything: what changed there since this copy last synced, file by file; what you hold that it lacks; whether the site is live; who has it open in the app right now, and on which file. Then it lists the commands to run, in an order that works from the top — `uniweb pull` before the push it would otherwise refuse. Three habits go with it: take what changed (`pull`, or `refresh`) before you edit; never `--force` past a refusal; and when someone has a page open in the app, tell the person before you change that page. A step marked *ask the person first* — going live, which may cost money — is theirs to decide.
+**Working on a site others edit — run `uniweb status` when you begin, when you come back to it, before you push, publish or deploy, and after any refusal.** It reads the backend without taking anything: what changed there since this copy last synced, file by file — as `uniweb pull` would write it, translations and records included; what you hold that it lacks; where the site is live, and what services it has; who has it open in the app right now, and on which file. Then it lists the commands to run, in an order that works from the top — `uniweb pull` before the push it would otherwise refuse. Three habits go with it: take what changed (`pull`, or `refresh`) before you edit; never `--force` past a refusal; and when someone has a page open in the app, tell the person before you change that page. A step marked *ask the person first* — going live, which may cost money — is theirs to decide.
 
 **Nobody's work is overwritten without asking.** `uniweb push` is refused if the site changed on the backend since your last pull — usually an author editing in the app — and reports what changed; nothing is written. Edits to different sections never collide. **In a git repository `uniweb pull` merges, like `git pull`:** it commits the backend's content (*"The site's content on …"*) and merges that commit into your branch, against the last state of the site your history shares with the backend. Your work, committed or not, and a teammate's arriving through git are kept; a file the backend never had is never deleted; changes to different parts of a file combine silently; and only a genuine overlap leaves conflict markers and a non-zero exit — so `uniweb pull && uniweb push` never ships markers. Settle a conflict as in any merge, then `git commit`; where your uncommitted changes overlap what the pull brought, the markers are theirs — settle them and `git add` each file, then `git stash drop` (git keeps them in the stash too). A push or publish is refused while a file under the site is in conflict. **In a git repository a push sends what you have committed:** with the site's content not committed it is refused before anything is sent, naming the files — commit them, or run `uniweb push --commit -m "…"` (it commits the site's content only, and leaves anything else staged as it is); `publish` and `sync` take `--commit` too. That commit is where the next pull merges from, which is how the pull tells your changes from the backend's. What the push writes back into the files — the ids the backend assigned — it commits itself, as `uniweb`. When the backend has nothing new, a pull says so and lists the files where yours hold changes it lacks. `uniweb refresh` runs `git pull` first, then the same pull. A push is also refused when your branch does not hold what this copy last took from the backend — after `git merge --abort`, or in a fresh clone that has not pulled — so pull, then push. Outside git — which includes a folder the repository around it ignores, such as a scratch directory — `uniweb pull` takes the backend's version over your files, asking first. `--force` is the deliberate overwrite (on `push` it replaces the backend's changes, on `pull` it discards yours); don't use it to get past a refusal. `uniweb sync` is `refresh` then `push`; neither publishes.
 

package/src/backend/app-changes.js

@@ -1,6 +1,12 @@
 /**
  * What changed on the backend since this copy last synced — READ, never taken.
  *
+ * ⚠️ THE SECOND ANSWER. In a repository `uniweb status` asks the pull itself
+ * (`commands/pull.js::probePull`), which names every file a pull would change. This answers
+ * where that cannot — outside git, or with no sync point to merge from — by units and
+ * records, not files: a section's translations, which a pull writes to `locales/*.json`,
+ * travel inside the section here (measured 2026-10-26: 8 units named, 11 files pulled).
+ *
  * `uniweb pull` takes the backend's content; `uniweb status` asks what there is to take.
  * The two must agree on what "changed" means, so this reads the backend as a pull does —
  * the same two lanes, the same conditional GET (`etagsHold`) — and compares the answer

package/src/backend/service-request.js

@@ -164,27 +164,43 @@ const names = (list) => list.map((n) => `\`${n}\``).join(', ')
  * @param {string[]|null} [p.supports] - from `foundationSupports`; null = unknown
  */
 export function announceServices({ siteYml, say, supports = null }) {
+  for (const note of serviceNotes({ siteYml, supports, warn: (m) => say.warn(m) })) say.warn(note)
+}
+
+/**
+ * Where `site.yml::services` and the foundation disagree — the notes `announceServices`
+ * says, as lines, for a caller that reports them (`uniweb status`).
+ *
+ * @param {object} p
+ * @param {object} p.siteYml - parsed
+ * @param {string[]|null} [p.supports] - from `foundationSupports`; null = unknown
+ * @param {(m: string) => void} [p.warn] - told what the file asks that will not be sent as written
+ * @returns {string[]}
+ */
+export function serviceNotes({ siteYml, supports = null, warn = () => {} }) {
   // An entry the push cannot read stops the package build next, which says what to write
   // (`refuseUnreadableServices`). Nothing to add before it — and what this would say, read
   // past that entry, is wrong: `search: yes` was "site.yml turns on `search`" (F14).
-  if (unreadableServices(siteYml?.services).length) return
-  const asks = readServicesRequest(siteYml?.services, { warn: (m) => say.warn(m) }) || []
-  if (!Array.isArray(supports)) return
+  if (unreadableServices(siteYml?.services).length) return []
+  const asks = readServicesRequest(siteYml?.services, { warn }) || []
+  if (!Array.isArray(supports)) return []
+  const notes = []
   const ignored = new Set(['tracking', 'records'])
   const has = (ask) => ask.enabled !== false || typeof ask.config?.endpoint === 'string'
   const unrendered = asks.filter((a) => has(a) && !ignored.has(a.name) && !supports.includes(a.name)).map((a) => a.name)
   if (unrendered.length) {
-    say.warn(`site.yml turns on ${names(unrendered)}, which your foundation does not say it renders (\`uniweb.supports\`).`)
+    notes.push(`site.yml turns on ${names(unrendered)}, which your foundation does not say it renders (\`uniweb.supports\`).`)
   }
   const mentioned = new Set(asks.map((a) => a.name))
   const unasked = supports.filter((n) => !ignored.has(n) && !mentioned.has(n))
   if (unasked.length) {
-    say.warn(
+    notes.push(
       `Your foundation renders ${names(unasked)}, which site.yml does not ask for — a service is off ` +
         `unless the site asks for it. Add ${unasked.length === 1 ? 'it' : 'them'} under \`services:\`, or set ` +
         `${unasked.length === 1 ? 'it' : 'each'} to \`false\` if that is what you mean.`
     )
   }
+  return notes
 }
 
 /**

package/src/commands/doctor.js

@@ -1993,6 +1993,54 @@ async function runDoctor(args = []) {
       }
     }
 
+    // ⛔ The keys retired on 2026-09-20 read as nothing, without a word: a deploy recorded
+    // under `lastDeploy:` is one `uniweb status` cannot see, and `autoSave: off` is ignored,
+    // so deploys are recorded after all. A renamed key returns empty; it does not fail.
+    const retired = ['lastDeploy', 'autoSave'].filter((k) => deployYml[k] !== undefined)
+    if (retired.length) {
+      const id = 'deploy-yml-retired-key'
+      const issue = {
+        id,
+        type: 'warn',
+        site: siteName,
+        message: `deploy.yml uses ${retired.map((k) => `\`${k}:\``).join(' and ')}, which the CLI no longer reads`
+      }
+      issues.push(issue)
+      warn(`[${id}] ${siteName}: deploy.yml uses ${retired.map((k) => `\`${k}:\``).join(' and ')}, which the CLI no longer reads.`)
+      const lost = []
+      if (deployYml.lastDeploy && typeof deployYml.lastDeploy === 'object') {
+        const names = Object.keys(deployYml.lastDeploy).filter((n) => !deployYml.deploys?.[n])
+        if (names.length) lost.push(`the last deploy of ${names.map((n) => `\`${n}\``).join(', ')} is recorded only there, where nothing sees it`)
+      }
+      if (String(deployYml.autoSave) === 'off') lost.push('`autoSave: off` is ignored, so deploys are recorded')
+      const renamed = { lastDeploy: 'deploys', autoSave: 'saveDeploys' }
+      log(
+        `    ${colors.dim}${retired.map((k) => `\`${k}:\` is \`${renamed[k]}:\``).join(' and ')} now${lost.length ? ` — ${lost.join('; ')}` : ''}.${colors.reset}`
+      )
+      if (shouldFix(id)) {
+        try {
+          const { retireDeployYmlKeys } = await import('@uniweb/build/site')
+          const done = await retireDeployYmlKeys(sitePath)
+          if (done) {
+            issue.fixed = true
+            fixed(
+              `${relative(workspaceDir, deployYmlPath)}: ${[
+                done.moved.length && `moved ${done.moved.join(', ')} to \`deploys:\``,
+                done.saveDeploys === false && 'wrote `saveDeploys: false`',
+                'removed the old keys'
+              ]
+                .filter(Boolean)
+                .join(', ')}`
+            )
+          }
+        } catch (err) {
+          warn(`[${id}] could not rewrite ${relative(workspaceDir, deployYmlPath)}: ${err.message}`)
+        }
+      } else {
+        log(`    ${colors.dim}Run \`uniweb doctor --fix ${id}\` to move them, keeping your comments.${colors.reset}`)
+      }
+    }
+
     // github-pages-specific: if a target has `domain`, `site/public/CNAME`
     // should exist with that value. Vite copies public/ into dist/, and
     // GH Pages reads dist/CNAME on each deploy to keep the custom domain

package/src/commands/pull.js

@@ -150,10 +150,12 @@ const colors = {
   green: '\x1b[32m',
   blue: '\x1b[36m'
 }
-// Looked up at each call, so a caller that captures the console captures these too.
-const log = (...a) => console.log(...a)
+// Looked up at each call, so a caller that captures the console captures these too — and
+// silent while a probe runs (`probePull`), which answers by what it returns.
+let quiet = false
+const log = (...a) => quiet || console.log(...a)
 const success = (m) => log(`${colors.green}✓${colors.reset} ${m}`)
-const error = (m) => console.error(`${colors.red}✗${colors.reset} ${m}`)
+const error = (m) => quiet || console.error(`${colors.red}✗${colors.reset} ${m}`)
 const info = (m) => log(`${colors.blue}→${colors.reset} ${m}`)
 const note = (m) => log(`  ${colors.dim}${m}${colors.reset}`)
 
@@ -568,6 +570,34 @@ const pulledFrom = (origin) => `The site's content on ${origin}`
 const mergedFrom = (origin) => `Merge the site's content from ${origin}`
 const takenFrom = (origin) => `Take the site's content from ${origin}`
 
+/**
+ * What a pull would change in the files, and nothing more — for `uniweb status`.
+ *
+ * ⭐ THE PULL ITSELF, STOPPED BEFORE IT TAKES ANYTHING. The same requests, the same base,
+ * the same projection onto it in a stand-in — so status and pull cannot disagree about
+ * which files the backend changed: a section's translations (`locales/*.json`) and a
+ * record's file are named as the pull would write them. It downloads no media, merges
+ * nothing, commits nothing and banks nothing — no ETag, version, hash or sync point —
+ * and prints nothing.
+ *
+ * Null when a probe cannot answer: outside git, where a pull writes into the files; in a
+ * repository with no commit or no sync point to merge from; when a lane failed or the
+ * workspace was refused. The caller then says what it can by other means.
+ *
+ * @param {string[]} [args] - the workspace flags only (`--org`, `--personal`)
+ * @param {object} [deps] - as for `pull`; `getToken` keeps it from ever asking for a login
+ * @returns {Promise<{ files: Array<[string, string]>, recordsNotPlaced: boolean } | null>}
+ *   `files` — `[status, path]`, status `A`, `M` or `D`, the path relative to the site
+ */
+export async function probePull(args = [], deps = {}) {
+  quiet = true
+  try {
+    return (await pull(args, { ...deps, probe: true }))?.probe ?? null
+  } finally {
+    quiet = false
+  }
+}
+
 export async function pull(args = [], deps = {}) {
   // See utils/flag-guard.js — an unrecognized flag is invisible to a literal scan, so
   // it silently keeps the default: a mistyped `--dry-run` would pull for real, and a
@@ -587,13 +617,20 @@ export async function pull(args = [], deps = {}) {
   const force = args.includes('--force')
 
   const siteDir = await resolveSiteDir(args, 'pull')
-  const fetchAssets = shouldFetchAssets(args, siteDir)
+  // ⛔ A probe (`probePull`) fetches no media: it says what changes, and takes nothing.
+  const probe = Boolean(deps.probe)
+  const fetchAssets = !probe && shouldFetchAssets(args, siteDir)
 
   // ⭐ IN A REPOSITORY A PULL MERGES; OUTSIDE ONE IT CHECKS OUT. A merge needs the state both
   // sides started from, and only a history holds one (`utils/sync-point.js`). Outside git
   // a pull rewrites the files, so work there that a pull did not write stops it.
   const repo = repoOf(siteDir)
-  if (repo && !dryRun) {
+  // A probe writes onto a commit in a stand-in, never into the files: with no repository,
+  // or no commit to write onto, it has nothing to say.
+  if (probe && !repo?.head) return { exitCode: 0, probe: null }
+  // …and touching nothing here, it is not stopped by what a merge would be: a conflict or a
+  // merge waiting is the caller's to report.
+  if (repo && !dryRun && !probe) {
     if (!repo.head) {
       error('This repository has no commits yet, so there is nothing for a pull to merge into.')
       note('Commit the project, then pull.')
@@ -631,7 +668,9 @@ export async function pull(args = [], deps = {}) {
     command: 'Pulling'
   })
   // One reader of Models for the whole pull, so a Model is read once whichever lane asks first.
-  const readModel = makeModelResolver({ client, siteDir })
+  // ⛔ A probe keeps none: a Model kept here is what a later offline emit resolves with, and a
+  // probe takes nothing (`probePull`).
+  const readModel = makeModelResolver({ client, siteDir: probe ? null : siteDir })
 
   // ⭐ No scope check any more — and none is needed. This project's identity on
   // `client.origin` is read from that origin's own section of sync.json, so a
@@ -703,6 +742,9 @@ export async function pull(args = [], deps = {}) {
   // body). `doRequest` is a thunk returning the client's Response promise. 404 / any
   // failure → null (the lane is skipped, not fatal) — except a workspace mismatch,
   // `{ refused: true }`, which stops the pull: the other lane would only say it again.
+  // A lane that answered 404 is named in `missing`, so a probe can tell a site with no
+  // records lane from a lane that did not answer.
+  const missing = new Set()
   const getDocs = async (label, doRequest) => {
     info(
       `Pulling ${colors.bright}${label}${colors.reset} from ${colors.dim}${client.origin}${colors.reset} …`
@@ -718,6 +760,7 @@ export async function pull(args = [], deps = {}) {
     }
     if (res.status === 404) {
       note(`${label}: not found (404) — it was deleted, or you lack access.`)
+      missing.add(label)
       return null
     }
     if (res.status === 304) {
@@ -820,6 +863,12 @@ export async function pull(args = [], deps = {}) {
       ? splitRecordsPull(folderLane.docs)
       : null
   const projected = Boolean(siteDoc) || Boolean(folderTaken)
+  if (probe) {
+    // A lane that did not answer is not knowing — a records lane the backend has none of
+    // (404) is no records; both unchanged is nothing to take.
+    if (!content || (!noRecords && !folderLane && !missing.has('records'))) return { exitCode: 1, probe: null }
+    if (!projected) return { exitCode: 0, probe: { files: [], recordsNotPlaced: false } }
+  }
 
   // ── What the project itself says, read before anything is written ──────────
   // The foundation, the Models and the scope come from the project as it is: in a
@@ -950,6 +999,9 @@ export async function pull(args = [], deps = {}) {
       origin: client.origin,
       siteUuid: siteContentUuid
     })
+    // A probe with no base has no way to tell the backend's changes from this copy's: onto
+    // HEAD, every difference would read as the backend's.
+    if (probe && !base) return { exitCode: 0, probe: null }
     onto = force || !base ? repo.head : base
     try {
       standIn = openStandIn(repo, { roots, rev: onto })
@@ -1071,7 +1123,7 @@ export async function pull(args = [], deps = {}) {
       // ⭐ A FILE RECORD'S BYTES (`@uniweb/file`, 2026-09-28): fetched to where `folder.yml` now
       // places each one, as media are fetched. A file that did not arrive is a record not taken —
       // reported, and the pull fails below as it does for any, so the next one fetches it again.
-      if (report.fileDownloads?.length) {
+      if (report.fileDownloads?.length && !probe) {
         const got = await downloadFileRecords({
           downloads: report.fileDownloads,
           siteDir: projDir,
@@ -1106,6 +1158,12 @@ export async function pull(args = [], deps = {}) {
       for (const w of report.warnings) note(`! ${w}`)
     }
 
+    // ⭐ A PROBE STOPS HERE, the stand-in holding what this pull would take: what differs
+    // from the base is what the backend changed. Nothing is banked; `finally` closes it.
+    if (probe) {
+      return { exitCode: 0, probe: { files: standIn.changes(), recordsNotPlaced: Boolean(recordsNotPlaced) } }
+    }
+
     // Outside git: what this pull wrote, so the next one can tell its own output from the
     // author's work. Config files are rewritten every pull whether or not they changed;
     // include the ones the projector owns so a pull-then-pull doesn't trip on them either.

package/src/commands/status.js

@@ -16,9 +16,11 @@
  *   dev      the dev server
  *
  * ⛔ READ-ONLY, AND IT NEVER PROMPTS. It signs nobody in — with no session it says how — and
- * writes nothing a later command reads as taken: no ETag, version or hash
- * (`backend/app-changes.js`). Its one write is the user-level npm cache `update` and
- * `--version` keep. A check it could not make is `unknown`, never `ok`.
+ * writes nothing a later command reads as taken: no ETag, version, hash or sync point
+ * (`probePull`, `backend/app-changes.js`). It writes the user-level npm cache `update` and
+ * `--version` keep, and — for a foundation named by catalog ref — the registered version's
+ * section types a pull keeps, which never change. A check it could not make is `unknown`,
+ * never `ok`.
  *
  * ⛔ THE GUARDS ARE THE VERBS' OWN. Where status says a push would be refused, it says so
  * from the function the push calls (`unsettledFiles`, `uncommittedContent`, `untakenBase`),
@@ -39,6 +41,7 @@
  * (`utils/flag-guard.js`).
  */
 
+import { execFileSync } from 'node:child_process'
 import { existsSync, readFileSync } from 'node:fs'
 import { join, relative, resolve } from 'node:path'
 import yaml from 'js-yaml'
@@ -56,7 +59,9 @@ import {
 import { describeWorkspace, resolveWorkspace, SOURCE_LABEL } from '../backend/workspace.js'
 import { BackendClient, resolveBackendOrigin } from '../backend/client.js'
 import { readAppChanges } from '../backend/app-changes.js'
-import { readBackendState } from '@uniweb/build/uwx'
+import { probePull } from './pull.js'
+import { readOrgFlag } from '../utils/args.js'
+import { listSyncedBackends, readBackendState } from '@uniweb/build/uwx'
 import { resolveLocalFoundation, foundationScopedName } from '../backend/foundation-bring-along.js'
 import { computeFoundationDigest } from '../utils/code-upload.js'
 import { compareSemverPrecedence } from '../utils/semver-precedence.js'
@@ -248,7 +253,7 @@ async function gitChecks(siteDir, { offline, origin }) {
         ? 'The git repository around this folder ignores it, so a pull here takes the backend\'s version over your files, asking first.'
         : 'Not a git repository, so a pull here takes the backend\'s version over your files, asking first.'
     })
-    return { checks, proposals, localFiles: null }
+    return { checks, proposals, localFiles: null, repo: false }
   }
   checks.push({ id: 'git.repo', state: 'ok', summary: `In the git repository at ${repo.top}.`, quiet: true })
 
@@ -334,7 +339,7 @@ async function gitChecks(siteDir, { offline, origin }) {
     if (moved) proposals.push({ step: 'refresh', command: 'npx uniweb refresh', why: "take your teammates' commits" })
     if (counts.ahead) proposals.push({ step: 'gitpush', command: 'git push', why: `share ${count(counts.ahead, 'commit')} with your team`, ask: true })
   }
-  return { checks, proposals, localFiles, uncommitted: Boolean(uncommitted), merging }
+  return { checks, proposals, localFiles, uncommitted: Boolean(uncommitted), merging, repo: Boolean(repo.head) }
 }
 
 /**
@@ -488,9 +493,24 @@ async function appChecks(siteDir, siteYml, { offline, args, git }) {
     summary: `Signed in to ${origin}${session.handle ? ` as @${String(session.handle).replace(/^@/, '')}` : ''}, working in ${describeWorkspace(ws.workspace)} (${SOURCE_LABEL[ws.source] || ws.source}).`
   })
 
+  // ⭐ WHAT CHANGED ON THE BACKEND, AS A PULL WOULD TAKE IT. In a repository, the pull itself,
+  // stopped before it takes anything (`probePull`): the files it would change, translations
+  // and records included. Where it cannot answer — outside git, no sync point to merge from —
+  // the backend's units against this copy's last sync (`backend/app-changes.js`).
+  const readChanges = async () => {
+    if (git.repo) {
+      const org = readOrgFlag(args)
+      const probed = await probePull([...(org ? ['--org', org] : []), ...(args.includes('--personal') ? ['--personal'] : [])], {
+        resolveSiteDir: async () => siteDir,
+        getToken: async () => session.token
+      })
+      if (probed) return { probe: probed }
+    }
+    return readAppChanges({ client, siteDir, siteUuid: uuid })
+  }
   const [state, changes, foundation] = await Promise.all([
     uuid ? client.siteState(uuid) : null,
-    uuid ? readAppChanges({ client, siteDir, siteUuid: uuid }).catch((err) => ({ error: err })) : null,
+    uuid ? readChanges().catch((err) => ({ error: err })) : null,
     foundationCheck(siteDir, siteYml, client).catch(() => null)
   ])
 
@@ -532,14 +552,35 @@ async function appChecks(siteDir, siteYml, { offline, args, git }) {
 
   const site = state?.site
   if (site) {
+    // ⭐ WHERE THE SITE IS LIVE IS THE BACKEND'S TO SAY, never deploy.yml's: a receipt is
+    // what this copy published, and a publish from the app or another copy does not move it.
+    // ⛔ `last_published_url` outlives an unpublish (`client.siteStatus`), so it is said as
+    // where the site WAS live when it is not live now — never as where it is.
+    const url = typeof site.last_published_url === 'string' && site.last_published_url ? site.last_published_url : null
+    const when = site.last_published_at ? sinceLabel(site.last_published_at, Date.now()) : null
+    const at = `${url ? ` at ${url}` : ''}${when ? `, published ${when}` : ''}`
+    const detail = {
+      published: Boolean(site.published),
+      url,
+      published_at: site.last_published_at ?? null,
+      draft_dirty: Boolean(site.draft_dirty),
+      foundation: site.last_published_foundation ?? null,
+      runtime: site.last_published_runtime ?? null
+    }
     if (!site.published) {
-      checks.push({ id: 'app.live', state: 'attention', summary: 'In the app, not live yet.' })
+      checks.push({
+        id: 'app.live',
+        state: 'attention',
+        summary: `On ${cloudName(origin)}, not live yet.`,
+        lines: url ? [`It was live at ${url} before.`] : [],
+        detail
+      })
       proposals.push({ step: 'publish', command: 'npx uniweb publish', why: 'take the site live — the person decides, and it may ask for payment', ask: true })
     } else if (site.draft_dirty) {
-      checks.push({ id: 'app.live', state: 'attention', summary: 'Live, with changes in the app that are not live yet.' })
+      checks.push({ id: 'app.live', state: 'attention', summary: `Live on ${cloudName(origin)}${at} — the app holds changes that are not live yet.`, detail })
       proposals.push({ step: 'publish', command: 'npx uniweb publish', why: 'make those changes live — the person decides', ask: true })
     } else {
-      checks.push({ id: 'app.live', state: 'ok', summary: 'Live, with the latest content.' })
+      checks.push({ id: 'app.live', state: 'ok', summary: `Live on ${cloudName(origin)}${at}, with the latest content.`, detail })
     }
     // An array is the backend's answer, `[]` included; no key is a backend that does not
     // say, and then neither do we.
@@ -561,14 +602,20 @@ async function appChecks(siteDir, siteYml, { offline, args, git }) {
     }
   }
   if (foundation) checks.push(foundation)
-  return { checks, proposals, backend }
+  return { checks, proposals, backend, site: site ?? null }
 }
 
+/** The name a backend's hosting goes by: Uniweb Cloud on the default backend, its origin elsewhere. */
+const cloudName = (origin) => (origin === DEFAULT_BACKEND_ORIGIN ? 'Uniweb Cloud' : origin)
+
+const CHANGE = { A: 'added', M: 'changed', D: 'removed' }
+
 /** `app.changes`: what moved on the backend, and where it meets what moved here. */
 function changeChecks(siteDir, changes, unpushedFiles, proposals) {
   if (changes.error) {
     return [{ id: 'app.changes', state: 'unknown', summary: `Could not read the site from the backend: ${changes.error.message}` }]
   }
+  if (changes.probe) return probedChanges(changes.probe, unpushedFiles, proposals)
   const { content, records } = changes
   const unknown = [content, records].filter((l) => l.state === 'unknown')
   const files = [
@@ -586,7 +633,7 @@ function changeChecks(siteDir, changes, unpushedFiles, proposals) {
     return [
       unknown.length
         ? { id: 'app.changes', state: 'unknown', summary: `Could not tell what changed on the backend: ${unknown.map((l) => l.detail).join('; ')}.` }
-        : { id: 'app.changes', state: 'ok', summary: 'Nothing changed on the backend since this copy last synced.' }
+        : { id: 'app.changes', state: 'ok', summary: 'Nothing changed on the backend since this copy last synced.', detail: { source: 'units' } }
     ]
   }
   // Where the backend's changes meet this copy's: a push of those is refused until a pull
@@ -605,6 +652,7 @@ function changeChecks(siteDir, changes, unpushedFiles, proposals) {
       lines,
       ...(overlap.length ? { blocks: ['push', 'publish'] } : {}),
       detail: {
+        source: 'units',
         content: { state: content.state, changed: content.changed, added: content.added, removed: content.removed, outsideUnits: content.outsideUnits },
         records: { state: records.state, changed: records.changed, added: records.added, removed: records.removed, folder: records.folder },
         ...(overlap.length ? { overlap } : {}),
@@ -614,6 +662,40 @@ function changeChecks(siteDir, changes, unpushedFiles, proposals) {
   ]
 }
 
+/**
+ * `app.changes` from the pull's own answer (`probePull`): the files it would change, each
+ * as the pull would write it.
+ */
+function probedChanges({ files: list, recordsNotPlaced }, unpushedFiles, proposals) {
+  if (!list.length) {
+    return [{ id: 'app.changes', state: 'ok', summary: 'Nothing changed on the backend since this copy last synced.', detail: { source: 'pull', files: [] } }]
+  }
+  const paths = list.map(([, p]) => p)
+  const files = list.map(([s, p]) => (s === 'A' ? `${p} (new)` : s === 'D' ? `${p} (removed)` : p))
+  // Where the backend's changes meet this copy's: the pull merges them, and a push of those
+  // before it is refused.
+  const overlap = unpushedFiles?.length ? paths.filter((p) => unpushedFiles.includes(p)) : []
+  const n = list.length
+  proposals.push({ step: 'pull', command: 'npx uniweb pull', why: `take the ${count(n, 'file')} changed on the backend` })
+  return [
+    {
+      id: 'app.changes',
+      state: overlap.length ? 'blocking' : 'attention',
+      summary:
+        `${count(n, 'file')} changed on the backend since this copy last synced — in the app, or pushed from another copy.` +
+        (overlap.length ? ` You changed ${count(overlap.length, 'of those files', 'of those files')} here too.` : ''),
+      files,
+      lines: recordsNotPlaced ? ['Some records could not be placed in files — `npx uniweb pull` says which, and why.'] : [],
+      ...(overlap.length ? { blocks: ['push', 'publish'] } : {}),
+      detail: {
+        source: 'pull',
+        files: list.map(([s, p]) => ({ path: p, change: CHANGE[s] || s })),
+        ...(overlap.length ? { overlap } : {})
+      }
+    }
+  ]
+}
+
 /**
  * `app.foundation`: the local foundation against its registered version — what the next
  * push or publish does with it (`backend/foundation-bring-along.js`).
@@ -722,16 +804,226 @@ async function devCheck(siteDir, { offline }) {
   }
 }
 
+// ─── where the site is hosted ───────────────────────────────────────────────
+
+/** A host adapter's name as people know it (`S3 + CloudFront`), or its id. */
+async function hostTitle(host) {
+  try {
+    const { getAdapter } = await import('@uniweb/build/hosts')
+    return getAdapter(host)?.display?.title || host
+  } catch {
+    return host
+  }
+}
+
+/**
+ * The CI workflow `uniweb add ci` writes for `host`, when it deploys this site: its file,
+ * and the branches whose pushes run it. A workspace with several sites deploys one per
+ * workflow, which names that site's build output.
+ */
+function ciWorkflow(repo, host) {
+  const rel = `.github/workflows/deploy-${host}.yml`
+  let text
+  try {
+    text = readFileSync(join(repo.top, rel), 'utf8')
+  } catch {
+    return null
+  }
+  if (repo.path !== '.' && !text.includes(`${repo.path}/dist`)) return null
+  let branches = []
+  try {
+    const doc = yaml.load(text)
+    branches = (doc?.on ?? doc?.[true])?.push?.branches ?? []
+  } catch {
+    // unreadable: the branches are not known
+  }
+  return { file: rel, branches: Array.isArray(branches) && branches.length ? branches.map(String) : [] }
+}
+
+/** The commits since `sha` that changed the site's files — null when this branch does not hold `sha`. */
+function siteCommitsSince(repo, sha, siteDir) {
+  try {
+    if (!isAncestor(repo, sha)) return null
+    const roots = sentRoots(siteDir).map((r) => `${repo.prefix}${r}`)
+    const out = execFileSync('git', ['rev-list', '--count', `${sha}..HEAD`, '--', ...roots], {
+      cwd: repo.top,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    })
+    return Number(out.trim())
+  } catch {
+    return null
+  }
+}
+
+/**
+ * `hosting.deploys`: where else the site is deployed — `deploy.yml`'s targets on hosts that
+ * are not a backend — each by CI on every push, or by hand, and how far behind a
+ * hand-deployed one is.
+ *
+ * ⛔ FROM THIS COPY'S FILES ONLY. A host's own state is not asked, and a receipt
+ * (`deploys:`) says what this copy deployed — never what another copy, or a CI run, did.
+ */
+async function deployChecks(siteDir) {
+  let deployYml
+  try {
+    const { loadDeployYml } = await import('@uniweb/build/site')
+    deployYml = await loadDeployYml(siteDir)
+  } catch (err) {
+    return { checks: [{ id: 'hosting.deploys', state: 'unknown', summary: `deploy.yml could not be read: ${err.message}` }], proposals: [], targets: [] }
+  }
+  const all = deployYml?.targets && typeof deployYml.targets === 'object' ? deployYml.targets : {}
+  const names = Object.keys(all)
+  const defaultName = deployYml?.default ?? (names.length === 1 ? names[0] : null)
+  const elsewhere = Object.entries(all).filter(([, t]) => t && typeof t === 'object' && t.host && t.host !== 'uniweb')
+  if (!elsewhere.length) {
+    return { checks: [{ id: 'hosting.deploys', state: 'skipped', summary: 'Deployed to no host but a backend.', quiet: true }], proposals: [], targets: [] }
+  }
+  const repo = repoOf(siteDir)
+  const proposals = []
+  const targets = []
+  const lines = []
+  let attention = false
+  for (const [name, t] of elsewhere) {
+    const title = await hostTitle(t.host)
+    const ci = repo?.head ? ciWorkflow(repo, t.host) : null
+    const receipt = deployYml.deploys?.[name] || null
+    const retired = !receipt && deployYml.lastDeploy?.[name] ? deployYml.lastDeploy[name] : null
+    const behind = receipt?.git?.sha && repo?.head ? siteCommitsSince(repo, receipt.git.sha, siteDir) : null
+    const when = receipt?.at ? sinceLabel(receipt.at, Date.now()) : null
+    let how
+    if (ci) {
+      how = `deployed by CI on every push${ci.branches.length ? ` to ${ci.branches.join(' or ')}` : ''} (${ci.file})`
+    } else if (receipt) {
+      how =
+        `deployed by hand, last ${when ?? 'at an unknown time'}${receipt.url ? ` to ${receipt.url}` : ''}` +
+        (behind > 0 ? ` — the site changed in ${count(behind, 'commit')} since` : behind === 0 ? ', and the site has not changed since' : '')
+      if (behind > 0) {
+        attention = true
+        proposals.push({ step: 'deploy', command: `npx uniweb deploy --target ${name}`, why: `update ${title}, ${count(behind, 'commit')} behind`, ask: true })
+      }
+    } else if (retired) {
+      attention = true
+      how = `its last deploy (${String(retired.at ?? '').slice(0, 10) || 'undated'}) is under \`lastDeploy:\`, which nothing reads — \`npx uniweb doctor --fix deploy-yml-retired-key\` moves it`
+    } else {
+      how = 'never deployed from this copy'
+    }
+    lines.push(`${title} — target \`${name}\`${name === defaultName ? ', the one a bare `uniweb deploy` uses' : ''}: ${how}`)
+    targets.push({
+      name,
+      host: t.host,
+      title,
+      default: name === defaultName,
+      ci: ci ? { file: ci.file, branches: ci.branches } : null,
+      last: receipt ? { at: receipt.at ?? null, sha: receipt.git?.sha ?? null, url: receipt.url ?? null } : null,
+      behind,
+      ...(retired ? { retired: true } : {})
+    })
+  }
+  return {
+    checks: [
+      {
+        id: 'hosting.deploys',
+        state: attention ? 'attention' : 'ok',
+        summary: `Also deployed to ${targets.map((t) => t.title).join(' and ')}.`,
+        lines,
+        detail: { targets }
+      }
+    ],
+    proposals,
+    targets
+  }
+}
+
+const list = (names) => names.map((n) => `\`${n}\``).join(', ')
+
+/**
+ * `app.services`: what `site.yml` asks for, beside what the backend holds — the request it
+ * stored, and what the last publish delivered (`last_published_services`). Comparing the
+ * file with those is how to tell it is stale, by the backend's own contract.
+ *
+ * ⛔ A request is never said as what the site has: what is live is the backend's to say.
+ */
+async function servicesCheck({ siteDir, siteYml, site }) {
+  const { readServicesRequest } = await import('@uniweb/build/uwx')
+  const { foundationSupports, serviceNotes } = await import('../backend/service-request.js')
+  // ⚠️ Two shapes, as the backend sends them (measured 2026-10-26 on uniweb.app): the stored
+  // request is rows (`{ name, enabled? }`), what the last publish delivered is names. A reader
+  // of rows alone reads every live service as none.
+  const on = (entries) =>
+    (Array.isArray(entries) ? entries : [])
+      .map((e) => (typeof e === 'string' ? e : e && typeof e.name === 'string' && e.enabled !== false ? e.name : null))
+      .filter(Boolean)
+  const asks = readServicesRequest(siteYml.services) || []
+  const asked = on(asks)
+  const lines = serviceNotes({ siteYml, supports: await foundationSupports(siteDir, siteYml) })
+  const proposals = []
+  if (!site) {
+    return {
+      checks: [
+        {
+          id: 'app.services',
+          state: lines.length ? 'attention' : 'ok',
+          summary: asked.length ? `site.yml asks for ${list(asked)}.` : 'site.yml asks for no services.',
+          lines,
+          detail: { asked, requested: null, live: null }
+        }
+      ],
+      proposals
+    }
+  }
+  const live = on(site.last_published_services)
+  const requested = on(site.services)
+  const waiting = requested.filter((n) => !live.includes(n))
+  if (waiting.length && site.published) {
+    lines.push(`Requested, not live yet: ${list(waiting)} — publishing makes ${waiting.length === 1 ? 'it' : 'them'} live, and may ask for payment.`)
+    proposals.push({ step: 'publish', command: 'npx uniweb publish', why: 'make those changes live — the person decides', ask: true })
+  }
+  const unsent = asked.filter((n) => !requested.includes(n))
+  if (unsent.length) lines.push(`site.yml asks for ${list(unsent)}, which the backend does not hold yet — the next push sends the request.`)
+  const offHere = asks.filter((a) => a.enabled === false && live.includes(a.name)).map((a) => a.name)
+  if (offHere.length) {
+    lines.push(`site.yml turns off ${list(offHere)}, which the live site has — a request the owner settles; a paid service stays on until its subscription changes.`)
+  }
+  return {
+    checks: [
+      {
+        id: 'app.services',
+        state: lines.length ? 'attention' : 'ok',
+        summary: live.length ? `Services on the live site: ${list(live)}.` : site.published ? 'No services on the live site.' : 'No services live — the site is not.',
+        lines,
+        detail: { asked, requested, live }
+      }
+    ],
+    proposals
+  }
+}
+
+/** What the site is, in one line: where it is synced, and where it is live. */
+function summaryLine({ name, synced, live, targets, origin }) {
+  const parts = [synced.length ? `synced with ${synced.join(' and ')}` : 'not synced with a backend']
+  if (live?.published) parts.push(`live on ${cloudName(origin)}${live.url ? ` at ${live.url}` : ''}`)
+  else if (live) parts.push(`not live on ${cloudName(origin)} yet`)
+  if (targets.length) parts.push(`${live?.published ? 'also deployed' : 'deployed'} to ${targets.map((t) => t.title).join(' and ')}`)
+  else if (!synced.length) parts.push('not hosted anywhere yet')
+  return `${name} — ${parts.join(' · ')}`
+}
+
 // ─── the command ────────────────────────────────────────────────────────────
 
 const GROUPS = [
   ['git', 'Git'],
   ['app', 'App'],
+  ['hosting', 'Hosting'],
   ['uniweb', 'Uniweb'],
   ['health', 'Health'],
   ['dev', 'Dev server']
 ]
 
+// Where a check is shown: where the site is live, and what it serves, are its hosting —
+// `app.live` and `app.services` kept their ids, which the document had before the group.
+const groupOf = (id) => (id === 'app.live' || id === 'app.services' || id.startsWith('hosting.') ? 'hosting' : id.split('.')[0])
+
 const ICON = {
   ok: `${c.green}✓${c.reset}`,
   attention: `${c.cyan}→${c.reset}`,
@@ -740,11 +1032,11 @@ const ICON = {
   skipped: `${c.dim}·${c.reset}`
 }
 
-function render({ siteLabel, backend, checks, next }) {
+function render({ summary, backend, checks, next }) {
   const out = ['']
-  out.push(`${c.bold}Status of ${siteLabel}${c.reset}`)
+  out.push(`${c.bold}${summary}${c.reset}`)
   for (const [prefix, title] of GROUPS) {
-    const group = checks.filter((k) => k.id.split('.')[0] === prefix && !(k.quiet && k.state === 'ok'))
+    const group = checks.filter((k) => groupOf(k.id) === prefix && !(k.quiet && (k.state === 'ok' || k.state === 'skipped')))
     if (!group.length) continue
     out.push('')
     out.push(prefix === 'app' ? `${c.bold}${title}${c.reset} ${c.dim}— ${backend.origin}${c.reset}` : `${c.bold}${title}${c.reset}`)
@@ -813,31 +1105,45 @@ export async function status(args = []) {
   // helpers say on the way goes to stderr.
   const saved = { log: console.log, info: console.info, warn: console.warn }
   if (json) console.log = console.info = console.warn = (...a) => console.error(...a)
-  let git, app, version, health, dev
+  let git, app, version, health, dev, deploys, services
   try {
     git = await gitChecks(siteDir, { offline, origin })
-    ;[app, version, health, dev] = await Promise.all([
+    ;[app, version, health, dev, deploys] = await Promise.all([
       appChecks(siteDir, siteYml, { offline, args, git }),
       versionCheck(siteDir, { offline }),
       doctorCheck(siteDir),
-      devCheck(siteDir, { offline })
+      devCheck(siteDir, { offline }),
+      deployChecks(siteDir)
     ])
+    services = await servicesCheck({ siteDir, siteYml, site: app.site })
   } finally {
     Object.assign(console, saved)
   }
-  const checks = [...git.checks, ...app.checks, ...version.checks, ...health.checks, dev]
-  const next = planNext([...git.proposals, ...app.proposals, ...version.proposals, ...health.proposals])
+  const checks = [...git.checks, ...app.checks, ...deploys.checks, ...services.checks, ...version.checks, ...health.checks, dev]
+  const next = planNext([...git.proposals, ...app.proposals, ...deploys.proposals, ...services.proposals, ...version.proposals, ...health.proposals])
 
   const root = findWorkspaceRoot(siteDir) || siteDir
   const site = relative(root, siteDir) || '.'
+  // What the site is, before what to do about it: the backends it is synced with — every one
+  // this copy holds a site on, custom servers included — and where it is live.
+  const synced = listSyncedBackends(siteDir).filter((o) => readBackendState(siteDir, o).site?.uuid)
+  const summary = summaryLine({
+    name: typeof siteYml.name === 'string' && siteYml.name ? siteYml.name : site === '.' ? 'This site' : site,
+    synced,
+    live: checks.find((k) => k.id === 'app.live')?.detail ?? null,
+    targets: deploys.targets,
+    origin: app.backend.origin
+  })
   if (json) {
     console.log(
       JSON.stringify({
         schema: STATUS_SCHEMA,
         uniweb: getCliVersion(),
+        summary,
         site,
         backend: app.backend.origin,
         workspace: app.backend.workspace,
+        synced,
         offline,
         checks: checks.map(({ quiet, id, state, summary, blocks = [], ...rest }) => ({ id, state, summary, blocks, ...rest })),
         next
@@ -845,7 +1151,7 @@ export async function status(args = []) {
     )
     return { exitCode: 0 }
   }
-  console.log(render({ siteLabel: site === '.' ? 'this site' : `${site}/`, backend: app.backend, checks, next }))
+  console.log(render({ summary, backend: app.backend, checks, next }))
   return { exitCode: 0 }
 }
 

package/src/framework-index.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-26T02:00:48.151Z",
+  "generatedAt": "2026-10-26T17:19:54.265Z",
   "packages": {
     "@uniweb/api": {
       "version": "1.6.4"
     },
     "@uniweb/build": {
-      "version": "1.10.2"
+      "version": "1.10.3"
     },
     "@uniweb/content-reader": {
       "version": "1.5.7"

package/src/index.js

@@ -1777,12 +1777,16 @@ ${colors.cyan}${colors.bright}uniweb status${colors.reset} ${colors.dim}— What
 ${colors.bright}Usage:${colors.reset}
   uniweb status [options]
 
-Run it when you begin, before you push, and after a command refuses. It checks:
+Run it when you begin, when you come back to the project, before you push, publish
+or deploy, and after a command refuses. It opens with what the site is — synced
+where, live where, deployed where — and checks:
 
   git      conflicts, a merge waiting, the site's files not committed, the git remote
-  app      the session, what changed on the backend since this copy last synced,
-           what is not pushed, whether the site is live, who has it open in the app,
-           the foundation
+  app      the session, what changed on the backend since this copy last synced —
+           the files a pull would change — what is not pushed, who has the site
+           open in the app, the foundation
+  hosting  where the site is live, the other hosts deploy.yml lists (by CI or by
+           hand, and how far behind), and the services the live site has
   uniweb   whether a newer release is out
   health   doctor's findings
   dev      the dev server

package/src/utils/status-next.js

@@ -7,13 +7,13 @@
  * then sends the reader back up. So the order is one table, not each check's own idea:
  *
  *   sign in → settle conflicts → finish a merge → take what others did (refresh, or pull)
- *   → push → push to git → go live → update Uniweb → read doctor's findings
+ *   → push → push to git → go live → deploy to another host → update Uniweb → read doctor's findings
  *
  * Each check proposes steps by name (`step`); this sorts them, folds the ones another step
  * already does, and drops duplicates.
  */
 
-const ORDER = ['login', 'conflicts', 'merge', 'refresh', 'pull', 'push', 'gitpush', 'publish', 'update', 'doctor']
+const ORDER = ['login', 'conflicts', 'merge', 'refresh', 'pull', 'push', 'gitpush', 'publish', 'deploy', 'update', 'doctor']
 
 /**
  * @param {Array<{ step: string, command: string|null, why: string, ask?: boolean }>} proposals

package/src/utils/sync-point.js

@@ -382,7 +382,7 @@ function differsIn(repo, a, b, roots) {
  * @param {string[]} opts.roots - the site's content roots, relative to the site
  * @param {string|null} opts.rev - the commit whose content the roots are filled from;
  *   null for none
- * @returns {{ siteDir: string, commit: Function, placeIgnored: Function, close: Function }}
+ * @returns {{ siteDir: string, commit: Function, changes: Function, placeIgnored: Function, close: Function }}
  */
 export function openStandIn(repo, { roots, rev }) {
   for (const r of roots) {
@@ -543,6 +543,24 @@ export function openStandIn(repo, { roots, rev }) {
       return placed
     }
 
+    /**
+     * What is written under the roots that `rev` does not hold so — each `[status, path]`,
+     * status `A`, `M` or `D`, the path relative to the site. Asked of the stand-in's own
+     * index, which holds `rev`: nothing is staged, committed or written to the repository.
+     * What the repository ignores is no change, as for `commit`.
+     * @returns {Array<[string, string]>}
+     */
+    const changes = () => {
+      const roots = full.filter((f) => present.includes(f) || existsSync(join(root, f)))
+      if (!roots.length) return []
+      const site = (p) => (sitePrefix && p.startsWith(sitePrefix) ? p.slice(sitePrefix.length) : p)
+      const out = []
+      const tracked = zlist(at(['diff', '--name-status', '-z', '--no-renames', '--', ...roots]))
+      for (let i = 0; i + 1 < tracked.length; i += 2) out.push([tracked[i], site(tracked[i + 1])])
+      for (const p of zlist(at(['ls-files', '--others', '--exclude-standard', '-z', '--', ...roots]))) out.push(['A', site(p)])
+      return out.sort((a, b) => (a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0))
+    }
+
     // The roots git can hold here. ⛔ One the repository ignores whole is not named to
     // `git add`, which refuses an ignored path; what is written under it is placed instead.
     const held = (paths) => {
@@ -556,7 +574,7 @@ export function openStandIn(repo, { roots, rev }) {
       return paths.filter((p) => !ignored.includes(p))
     }
 
-    return { siteDir, commit, placeIgnored, close }
+    return { siteDir, commit, changes, placeIgnored, close }
   } catch (err) {
     close()
     throw err