bastion 0.58.0

CHANGELOG.md

@@ -23,6 +23,188 @@ From 0.39.1 on, a heading marks a version *not published* or *held* once
 that is settled. The newest entries may not be published yet; the manifest
 says which version is. Older entries are not marked.
 
+## 0.58.0
+
+- **A Host answers four common questions about a machine itself, instead of
+  handing the person a command to run.** Each is a read-only observe op,
+  granted under `observe` like the rest of the family and listed in the ops
+  the machine advertises, so a grant can name it. Each value is checked
+  against a written rule before anything is read or run, and a refusal says
+  which rule it broke without repeating the value. Off Linux each answers
+  `unsupported`.
+  - `observe:folders <path> [depth]`: the 25 largest folders under an
+    absolute path, 1 to 3 levels down (2 when not given), and the total, on
+    that path's own filesystem only, counted the way `du -x` counts (disk
+    blocks, a file with several links once). Only folders are named, never a
+    file. What could not be read, and filesystems mounted under the path, are
+    listed against the folder that holds them, with a reason and a count.
+    `/proc`, `/sys`, `/dev`, a relative path, a path containing `..` and a
+    link that leads into those are refused. A walk that runs out of the
+    20-second budget answers with what it measured and says every size is at
+    least that. The walk follows no link: a folder swapped for one while it
+    reads, or reached through one put above it, is listed as changed and not
+    counted. A read that never returns (a network mount that stopped
+    answering) is answered without at the budget, and while four such reads
+    are still waiting no new walk starts.
+  - `observe:journal <unit> [minutes]`: one systemd unit's journal for the
+    last 1 to 60 minutes (15 when not given), up to 5000 lines and 200 KB,
+    newest kept. A name with no type is a service, as with `systemctl`. The
+    name must be in systemd's unit-name alphabet and one this machine has,
+    loaded now or installed; otherwise it is refused, with the units whose
+    names come close. Until now a Host could read logs only from a Loki,
+    which most machines do not run, so it asked the person to run
+    `journalctl` instead.
+  - `observe:logins [hours]`: sshd's failed and accepted logins over the last
+    1 to 168 hours (24 when not given). Failed attempts are counted and ranked
+    by source address and by user name, 20 of each; the last 20 accepted
+    logins come with user, source, method and time. A user name the other
+    side sent is cut to 32 characters, and anything outside the characters
+    account names use reads `?`. No raw line, key fingerprint or password is
+    returned. Only lines written by sshd running as root are read, so another
+    account on the machine cannot add login lines or bury the real ones under
+    its own.
+  - `observe:cert <port> [server name]`: the certificate this machine's own
+    listener on a TCP port serves: subject, names, issuer, dates, days left,
+    and whether the chain verifies against this machine's roots for that
+    name. The port must be one `ss` shows listening here. The handshake goes
+    to loopback first and otherwise only to an address of this machine the
+    listener is bound to, never to one another machine could hold.
+- **A journal the bastion cannot read is said, not shown as empty.**
+  `journalctl` run by an account outside the journal's groups shows only that
+  account's own lines, which would look like a quiet machine. `observe:journal`
+  and `observe:logins` first check that the bastion can read the system
+  journal (as root, which is how the networked install runs it, or as a member
+  of `systemd-journal`) and otherwise answer with the reason;
+  `observe:logins` then reports its counts as -1, never 0.
+- **A grant from now on can be held to a window and a rate, by the
+  machine.** An op grant's bounds may now carry `_window` (days, from, to and
+  a zone, read on the machine's own clock; a window may wrap midnight) and
+  `_rate` (at most so many applies in any 24 hours, and so many seconds
+  between two). An apply outside them does not run, spends no use and is no
+  strike toward the quarantine: the answer is `not_now`, exit 75, with the
+  bound that held it and when it next could run. A dry run is never held, and
+  an apply with arguments outside the op is still refused as before. The
+  zone database is in the binary, so a zone reads the same on every machine.
+  An older bastion refuses both keys as naming no param, so a grant carrying
+  them fails closed there; the enforcing report says `grant_run_bounds` on a
+  bastion that holds them.
+- **The machine keeps the runs, and who approved.** Each grant's record in
+  `ops.json` now holds the times of the applies that spent a use, the key
+  that approved it (the approval device's key, or the factor enrolled at this
+  console) and the machine's own seal over the record. The rate is counted
+  from that log, so it holds across a restart. A record edited outside the
+  bastion holds no grant until it is dropped and approved again, and so does
+  a grant installed by an older bastion (none was held when this shipped). A
+  grant whose approving key is no longer pinned is refused; `unpin-device`
+  drops every grant that key approved, so pinning it again brings none back.
+- **`op_grant_drop <grant | all>` takes a grant back from the Host.** It is
+  a tighten: no quarantine holds it and no approval is asked. A grant not
+  held here is already gone and is answered as dropped. At the machine,
+  `ops drop --all` takes back every op grant a Host holds, beside `ops drop
+  <grant>`.
+- **An action op may have no program.** With `interpreter: none` and no
+  `run` file, an action op's verbs are its whole work. Nothing the Host wrote
+  executes, so it needs no sandbox and runs on a machine with no overlay. Its
+  dry run is the verbs' own read of what each would move, and its apply the
+  verbs and the log checks. Such an op that ships a `run` file is refused,
+  as is one that names destinations, a builder, reads, or a credential no
+  verb uses. An op with a program is still refused where the sandbox is not.
+  A verb whose tool the machine lacks refuses the run as the machine's own
+  state, never a strike, and the enforcing report now says, for each verb,
+  whether this machine can run it (`verbs`).
+- **On your own machine, an action op reaches the internet, never your
+  network.** On a machine no fleet has anchored, an action op's destination
+  is never a private, ULA, CGNAT or reserved address (also inside NAT64 or
+  6to4): one written as an address is refused when the op arrives, and a
+  name is refused at apply if any address it resolves to is one. Another
+  computer of yours is reached through a bastion on that computer. An
+  anchored machine keeps private destinations, since a fleet's ship steps
+  reach its own private control planes. A verb's fetch is held the same way
+  (`tree.checkout` fetching its tree's repository, `k8s.set_image` fetching
+  its source to check ancestry): the repository's host is checked once and
+  git is held to that address, so an op with no program reaches no more than
+  one with a program. On an anchored machine too a verb's fetch is held to
+  its checked address and is never this machine, its loopback, a link-local
+  address or a cloud's metadata service. An image `k8s.set_image` would put
+  live, which the machine's container runtime pulls by name, is refused on
+  your own machine when its registry is on your network or this machine,
+  both when a program reports it and when the verb would set it.
+  `k8s.set_image` now says it needs git as well as kubectl, so a machine
+  without git is told before a run. What stops working: a ship step on your
+  own unanchored bastion that deploys to another computer on your LAN,
+  fetches from a forge on it or rolls an image from a registry on it; and a
+  verb's fetch needs git 2.37 or newer, which holds a fetch to one address.
+
+## 0.57.0
+
+- **Pairing with a Cloud Host is one pasted line.** A Host's "Set up a
+  bastion" card now gives a pairing code, `skp_…`, that carries the token,
+  the Host's enroll address and the SHA-256 of the Host's CA. `pair <code>`
+  (or the code on standard input after `pair -`) takes the CA from the enroll
+  port's own TLS chain, keeps it only under that fingerprint and only when the
+  port's certificate verifies under it for `host.cseries.internal`, then pairs
+  exactly as `--redeem-url` with `--host-ca` does. There is no certificate
+  file to save, so the step people skipped ("open host-ca.pem: The system
+  cannot find the file specified") is gone. `--host-ca` still works as before.
+- **The installers pair and start in one go.** `install.sh` with
+  `PRIVATAE_PAIR_CODE='<code>'` in its environment (the card's line is
+  `curl -fsSL https://privatae.ai/bastion/install.sh | PRIVATAE_PAIR_CODE='skp_…' sh`)
+  and `install.ps1 -Pair '<code>'` install or update the bastion as before,
+  hand the code to `pair -` on standard input, then start the bastion, or restart it when it
+  was running, and end with one plain sentence and `status`. On Windows that
+  is the logon task (every running copy is stopped first, so the new one gets
+  its control port), or the service on a networked machine; on a machine whose
+  bastion is already the Windows service, `-Pair` pairs that service from an
+  Administrator PowerShell instead of installing a second bastion. On Linux as
+  yourself it is a systemd user unit, with lingering asked for and the outcome
+  said; on macOS a LaunchAgent; as root, the system service. Without the code
+  both installers behave as they did.
+- **The code is in no process's arguments.** On macOS and Linux it comes
+  only from the environment: an argument would sit in the installer shell's
+  command line for the whole install, where any user of the machine can read
+  it with `ps`, and one at the same address could redeem it first. A
+  process's environment is readable only by its owner and root. `install.sh`
+  reads the variable before it starts any program and unsets it, so nothing
+  it starts inherits it. An empty or partial code is refused before the
+  download. `install.sh` now names no argument it refuses, so a code given in
+  the wrong place is never printed back. On Windows the code stays a
+  parameter of the script, inside the person's own PowerShell.
+- **On Linux, as yourself, the copy that serves is the one the installer
+  started.** Before the user unit starts, every copy of your bastion running
+  outside it (left in a terminal, or from another path) is stopped, as
+  install.ps1 does on Windows. Otherwise the unit's copy only waits behind the
+  old one's run lock, and the old copy never reads the new pairing. The
+  installer then checks for a few seconds that the unit is running and keeps
+  the same process. A unit that keeps restarting is reported as not running,
+  with its log command, and the install fails.
+- **A local bastion can serve a second Host, when you say so at the machine.**
+  A local bastion used to serve one Host and refuse any other, so a person
+  with two Hosts of their own (a Cloud machine beside a platform Host) could
+  not pair the second at all. `pair` now asks on this machine's terminal,
+  `/dev/tty` or the Windows console, never standard input, so a code piped
+  in by an installer still needs a person to answer: "This computer already
+  serves your Host … Add … as well? [y/N]". Only y or yes adds it; the first
+  pairing is untouched; with no terminal it is refused. Other callers
+  (`claim-anchor`, the pairing op) keep the refusal. On a local machine that
+  serves two Hosts, each changes only the servers it built and stops only the
+  coder runs it started. The name in the question is the token's, so anything
+  in it but a plain host name is shown quoted and escaped.
+- **`pair` exits 3 when the Host is already paired here.** Nothing changes, and
+  the installers report it as already connected. Over TCP, with a pairing
+  code or `--host-ca`, a Host of the same name under another CA (Cloud names
+  repeat) is a plain refusal, not exit 3, before the redeem and after it. A
+  pairing code that names a field twice is refused.
+- **An enroll port that does not answer says why within 10 seconds.** A Cloud
+  Host opens its pairing port only to the address the browser used when the
+  card was opened, for 15 minutes; from anywhere else the port does not
+  answer, and `pair` used to wait for the system's connect timeout. It now
+  stops after 10 seconds with that reason and what to do.
+- **The local-mode refusal names this system's way to a networked bastion**
+  (`install.ps1 -Networked` from an Administrator PowerShell on Windows,
+  `install.sh --networked` as root elsewhere) and says that the Host already
+  paired would have to be paired again with it. It used to name the Linux
+  script on Windows.
+
 ## 0.56.0
 
 - **New: a Host with no platform can use the model servers on this

README.md

@@ -49,6 +49,11 @@ privatae-bastion run
 A Windows server installs from an Administrator PowerShell with `-Networked`.
 See [Install](#install).
 
+A Cloud Host's **Set up a bastion** card gives one line that installs the
+bastion, pairs it and starts it, so it runs now and after a restart:
+`curl -fsSL https://privatae.ai/bastion/install.sh | PRIVATAE_PAIR_CODE='skp_…' sh`, or
+on Windows `& ([scriptblock]::Create((irm https://privatae.ai/bastion/install.ps1))) -Pair 'skp_…'`.
+
 **AI readers and reviewers:** [docs/README.md](docs/README.md) lists every reference page, one line each, and [docs/claims.md](docs/claims.md) is the full table of security claims and the test behind each.
 
 **Contents:** [Why a bastion](#why-a-bastion) · [Install](#install) ·
@@ -106,7 +111,8 @@ privatae-bastion stepup-enroll
 ```
 
 **On your own computer** (run the installer as yourself). The bastion runs
-as your user in **local** mode and serves one host. The pairing's
+as your user in **local** mode and serves the host you pair it with, and
+another only when you answer yes on this computer. The pairing's
 capabilities are the authorization, and approvals work once you enrol a
 second factor.
 
@@ -166,7 +172,7 @@ share on the host with your code.
 | Runs as | your user is fine | the system's service: root under systemd or launchd, LocalSystem on Windows |
 | A terminal the host opens | opens on the pairing's capabilities | waits for your approval, for that one session |
 | A write (an op, a ship step) | runs on the pairing's capabilities | waits for your approval, bound to that op and its arguments |
-| Second pairing | refused | waits for the **anchor** host's approval |
+| Second pairing | asked on this computer's terminal, added only on a yes | waits for the **anchor** host's approval |
 | The anchor | none | the first host paired, or `claim-anchor` |
 
 In networked mode one host is the **anchor**: the one host that approves every

client-go/anchor.go

@@ -574,9 +574,10 @@ var allCaps = []string{"dcn", "egress", "harness", "inference", "models", "obser
 // writes a pairing PENDING when an anchor exists (pair.go), and state "" reads
 // active (config.go), so B comes straight up with full lanes.
 //
-// LOCAL is exempt and must stay so: a local bastion serves one host and cannot
+// LOCAL is exempt and must stay so: a local bastion serves the one host it was
-// be anchored at all (cmdClaimAnchor refuses outside networked mode), so the
+// paired with, and a second only on a yes typed at the machine (pair_terminal.go),
-// pairing IS the authorization there. Most bastions are local.
+// and it cannot be anchored at all (cmdClaimAnchor refuses outside networked
+// mode), so the pairing IS the authorization there. Most bastions are local.
 //
 // self-update is deliberately INSIDE the refusal. Directing a binary swap is the
 // most dangerous thing on the list, and an unanchored networked box cannot say
@@ -1033,7 +1034,7 @@ func cmdClaimAnchor(token string, rotate bool, owner, host string) error {
 		return err
 	}
 	if boxMode() != modeNetworked {
-		return fmt.Errorf("claim-anchor needs networked mode — a local bastion serves one host and needs no anchor (%s, then `privatae-bastion set-mode networked`)", adminHowTo())
+		return fmt.Errorf("claim-anchor needs networked mode — a local bastion serves only the Hosts its person said yes to and needs no anchor (%s, then `privatae-bastion set-mode networked`)", adminHowTo())
 	}
 	cfgs, err := loadPairings()
 	if err != nil {

client-go/claims_static_test.go

@@ -1179,8 +1179,8 @@ func TestObserveOpsWriteNothing(t *testing.T) {
 			roots = append(roots, fn)
 		}
 	}
-	if len(roots) != 14 {
+	if len(roots) != 18 {
-		t.Fatalf("expected the 11 observe and 3 computer handlers, found %d", len(roots))
+		t.Fatalf("expected the 15 observe and 3 computer handlers, found %d", len(roots))
 	}
 	stop := map[string]bool{"sendMgmt": true, "sendMgmtExit": true, "refuseMgmt": true,
 		"storeRecordObserve": true}
@@ -1256,6 +1256,10 @@ func TestObserveOpsWriteNothing(t *testing.T) {
 		"dmesg -T",
 		"iptables -S",
 		"journalctl -n1 -o short-unix --no-pager",
+		// observe:logins: sshd's lines over a window of whole hours.
+		"journalctl <sinceArg> -o short-iso --no-pager -q --lines=50000 _COMM=sshd _COMM=sshd-session _COMM=sshd-auth _UID=0 + _SYSTEMD_UNIT=ssh.service _SYSTEMD_UNIT=sshd.service _UID=0",
+		// observe:journal: one unit this machine's own lists name, over minutes.
+		"journalctl <unitArg> <sinceArg> -o short-iso --no-pager -q --lines=5000",
 		"kubectl --kubeconfig <observeKubeconfig> get nodes -o json",
 		"kubectl --kubeconfig <observeKubeconfig> get pods -A -o json",
 		"nft list chain inet pubwall input",
@@ -1270,6 +1274,8 @@ func TestObserveOpsWriteNothing(t *testing.T) {
 		"system_profiler SPApplicationsDataType -json",
 		"systemctl is-active fail2ban",
 		"systemctl list-timers --all --no-legend --plain",
+		"systemctl list-unit-files --no-legend --plain", // observe:journal's unit check
+		"systemctl list-units --all --no-legend --plain",
 		"systemctl list-units --failed --no-legend --plain",
 		"ufw status",
 		"ufw status verbose",

client-go/coders.go

@@ -1229,10 +1229,17 @@ func coderContainerGone(rt, cname string) bool {
 // anchor pairing on an anchored box (serviceOwnerRefusal's rule).
 // An unknown owner proves nothing about self, so it gets the anchor-only rule
 // too: every run this bastion starts records and labels its owner.
+//
+// A local machine has no anchor, so anchorOnly lets every pairing through
+// there; once it serves several Hosts (localServesSeveralHosts), each stops
+// only the runs it started, as with the servers each built.
 func coderOwnerRefusal(self, owner string) string {
 	if owner != "" && owner == self {
 		return ""
 	}
+	if localServesSeveralHosts() {
+		return "refused: that run was started by " + orUnknown(owner) + "; on a local machine that serves several Hosts each stops only the runs it started"
+	}
 	if why := anchorOnly(self, "stopping a run another host started"); why != "" {
 		return "refused: that run was started by " + orUnknown(owner) + "; " + why
 	}

client-go/config.go

@@ -615,7 +615,7 @@ func removeStalePairingFile(hostName string) error {
 func checkPairConflict(cfgs []*Config, handle string, replace bool) (*Config, error) {
 	existing := pairingFor(cfgs, handle)
 	if existing != nil && !replace {
-		return nil, fmt.Errorf("already paired with %s — this daemon serves multiple hosts, so pairing never overwrites; to rotate that host's credentials run `privatae-bastion pair --replace <token>`", existing.HostName)
+		return nil, &alreadyPairedError{host: existing.HostName, msg: fmt.Sprintf("already paired with %s — this daemon serves multiple hosts, so pairing never overwrites; to rotate that host's credentials run `privatae-bastion pair --replace <token>`", existing.HostName)}
 	}
 	if existing == nil && replace {
 		return nil, fmt.Errorf("pair --replace: no existing pairing matches '%s' — pair it normally first", handle)

client-go/console_hostops.go

@@ -142,6 +142,14 @@ func cmdOpsDrop(host, prefix string) error {
 	}
 	dir := cfg.dcnDir()
 	prefix = strings.TrimSpace(prefix)
+	if prefix == "--all" {
+		dropped, err := opsDropWhere(dir, "dropped at this machine's console", func(string, *opGrantRec) bool { return true })
+		if err != nil {
+			return err
+		}
+		fmt.Printf("%d op grant(s) dropped — the host cannot run under any of them again\n", len(dropped))
+		return nil
+	}
 	var hits []string
 	for nonce, rec := range opsLoad(dir).Grants {
 		if rec.Dropped == "" && strings.HasPrefix(nonce, prefix) {

client-go/device.go

@@ -995,6 +995,11 @@ func cmdPinDevice(key string, unpin bool) error {
 			return err
 		}
 		fmt.Println("device key unpinned; approvals signed by it are refused from now on")
+		// Every op grant it approved dies with it (ops_bounds.go), dropped
+		// now so pinning the key again does not bring one back.
+		if n := opsDropApprovedBy("device:" + strings.TrimSpace(key)); n > 0 {
+			fmt.Printf("%d op grant(s) it approved dropped\n", n)
+		}
 		return nil
 	}
 	if err := pinDeviceKey(key); err != nil {

client-go/enforcing.go

@@ -193,6 +193,14 @@ func buildEnforcingReport(dir string, allowed []string) map[string]any {
 		if !aok {
 			rep["action_ops_reason"] = awhy
 		}
+		// Each verb, and whether this machine has the tool it runs: an op
+		// with no program (interpreter: none) runs here when its verbs do,
+		// with or without the sandbox above.
+		rep["verbs"] = opVerbsReport()
+		// An op grant's bounds may hold its runs to a window and a rate
+		// (ops_bounds.go). Said by the box, so the host sends neither to one
+		// that would refuse them as naming no param.
+		rep["grant_run_bounds"] = true
 	}
 	// This machine's encryption key, signed by its own key: what the host
 	// seals an action op's credentials to (ops_seal.go).

client-go/fuzz_grants_test.go

@@ -345,3 +345,51 @@ func FuzzADeviceApprovalIsReadOneWayOnly(f *testing.F) {
 		}
 	})
 }
+
+// FuzzAGrantsRunBoundsHoldWhateverTheHostSends: whatever bounds text a host
+// sends, a run bound the machine accepts is one it can hold — a window has a
+// length, a zone and a day, a rate names a limit inside the ceilings — and
+// judging a run against it at any moment answers, never panics, and never
+// lets a run inside an interval or past a day's count.
+func FuzzAGrantsRunBoundsHoldWhateverTheHostSends(f *testing.F) {
+	m := &opManifest{Params: map[string]opParam{"count": {Type: "integer", Min: ptr64(1), Max: ptr64(5)}}}
+	for _, s := range []string{
+		`{"_window":{"days":["mon"],"from":"22:00","to":"06:00","tz":"Europe/Berlin"}}`,
+		`{"_rate":{"per_day":2,"min_interval_s":600},"count":{"max":2}}`,
+		`{"_window":null,"_rate":null}`, `{"_x":1}`, `{"_window":{"from":"02:00","to":"02:00"}}`,
+	} {
+		f.Add(s, int64(1761739200), int64(300))
+	}
+	f.Fuzz(func(t *testing.T, raw string, at, gap int64) {
+		b, err := parseGrantBounds(m, raw)
+		if err != nil {
+			return
+		}
+		if w := b.Window; w != nil {
+			if w.from == w.to || w.loc == nil || w.day == [7]bool{} {
+				t.Fatalf("accepted a window that is no window: %s", raw)
+			}
+		}
+		if r := b.Rate; r != nil {
+			if (r.PerDay == nil && r.MinInterval == nil) || (r.PerDay != nil && (*r.PerDay < 1 || *r.PerDay > opGrantUsesMax)) ||
+				(r.MinInterval != nil && (*r.MinInterval < 1 || *r.MinInterval > opRateMinInterval)) {
+				t.Fatalf("accepted a rate outside the ceilings: %s", raw)
+			}
+		}
+		now := time.Unix(at%(1<<40), 0)
+		last := now.Add(-time.Duration(gap%(1<<30)) * time.Second)
+		if last.After(now) {
+			last = now
+		}
+		why, _, _ := opNotNowWhy(b, []time.Time{last}, now)
+		if b.Window == nil && b.Rate != nil && b.Rate.MinInterval != nil &&
+			now.Sub(last) < time.Duration(*b.Rate.MinInterval)*time.Second && why == "" {
+			t.Fatalf("a run inside the interval was let through: %s", raw)
+		}
+		if b.Window == nil && b.Rate != nil && b.Rate.PerDay != nil && *b.Rate.PerDay == 1 && now.Sub(last) < 24*time.Hour && why == "" {
+			t.Fatalf("a second run in a day was let through: %s", raw)
+		}
+	})
+}
+
+func ptr64(v int64) *int64 { return &v }

client-go/fuzz_observe_test.go

@@ -0,0 +1,123 @@
+package main
+
+// Fuzz the walls a host's value meets in observe:folders, observe:journal,
+// observe:cert and observe:logins. Whatever the input, a path that passes is
+// absolute, clean and outside the kernel's trees; a unit that passes is in
+// systemd's alphabet and shaped like no flag; a server name that passes is a
+// DNS name; and the sshd parser names only addresses as sources and bounded
+// names as users, whatever a remote side put in a user name.
+
+import (
+	"net/netip"
+	"path"
+	"strings"
+	"testing"
+)
+
+func FuzzFolderPathIsAbsoluteCleanAndOffTheKernelTrees(f *testing.F) {
+	for _, s := range []string{"/", "/var/lib", "/var//lib/", "/proc", "//proc/1", "/a/../proc", "/a..b",
+		"rel", "/dev/shm", "/x\x00y", "/\xff", "/srv/./data", "/sys/", "/devices"} {
+		f.Add(s)
+	}
+	f.Fuzz(func(t *testing.T, in string) {
+		p, err := checkFolderPath(in)
+		if err != nil {
+			return
+		}
+		if !strings.HasPrefix(p, "/") || path.Clean(p) != p || strings.Contains(p, "..") {
+			t.Fatalf("%q passed as %q", in, p)
+		}
+		for _, r := range p {
+			if r < 0x20 || r == 0x7f {
+				t.Fatalf("%q passed with a control character", in)
+			}
+		}
+		for _, root := range folderRefusedRoots {
+			if p == root || strings.HasPrefix(p, root+"/") {
+				t.Fatalf("%q passed into %s", in, root)
+			}
+		}
+	})
+}
+
+func FuzzUnitNameIsSystemdsAlphabet(f *testing.F) {
+	for _, s := range []string{"example", "getty@tty1", `dev-disk-by\x2dlabel-data.device`, "-.mount", "--unit=x",
+		"worker@.service", "a@b@c", "x;id", "data.mount", ".service", "@x"} {
+		f.Add(s)
+	}
+	f.Fuzz(func(t *testing.T, in string) {
+		u, err := normalizeUnitName(in)
+		if err != nil {
+			return
+		}
+		if !unitNameRe.MatchString(u) || len(u) > unitNameMax || !hasUnitSuffix(u) {
+			t.Fatalf("%q passed as %q", in, u)
+		}
+		if strings.HasPrefix(u, "-") || strings.HasPrefix(u, ".") || strings.HasPrefix(u, "@") {
+			t.Fatalf("%q passed as a flag-shaped %q", in, u)
+		}
+		if u != in && u != in+".service" {
+			t.Fatalf("%q became %q: the name is kept or given .service, nothing else", in, u)
+		}
+	})
+}
+
+func FuzzCertArgsAreAPortAndADNSName(f *testing.F) {
+	for _, s := range [][2]string{{"443", "box-a.example"}, {"0", ""}, {"65536", "x"}, {"443", "-x"},
+		{"443", "a..b"}, {"8443", "192.0.2.10"}, {" 443 ", "A.EXAMPLE"}, {"443", "a_b"}} {
+		f.Add(s[0], s[1])
+	}
+	f.Fuzz(func(t *testing.T, port, name string) {
+		p, n, err := parseCertArgs([]string{port, name})
+		if err != nil {
+			return
+		}
+		if p < 1 || p > 65535 || !serverNameRe.MatchString(n) || n != strings.ToLower(n) ||
+			strings.HasPrefix(n, "-") || strings.HasPrefix(n, ".") || strings.Contains(n, "..") {
+			t.Fatalf("(%q, %q) passed as (%d, %q)", port, name, p, n)
+		}
+	})
+}
+
+func FuzzSSHLoginsNameOnlyAddressesAndBoundedNames(f *testing.F) {
+	f.Add(fxSSHD)
+	f.Add("2026-10-29T10:00:01+00:00 h sshd[1]: Invalid user a from 1.2.3.4 port 1 from 203.0.113.5 port 2\n")
+	f.Add("2026-10-29T10:00:01+00:00 h sshd[1]: Failed password for x from evil/host port 1 ssh2\n")
+	f.Add("x y z: Accepted publickey for \x00 from ::1 port 9 ssh2: K\n")
+	f.Fuzz(func(t *testing.T, text string) {
+		tally := parseSSHLogins(text)
+		var rep loginsReport
+		tally.fill(&rep)
+		sum := 0
+		for src, n := range tally.bySource {
+			sum += n
+			if _, err := netip.ParseAddr(src); err != nil && !loginHostRe.MatchString(src) {
+				t.Fatalf("source %q is not an address or a host name", src)
+			}
+		}
+		if sum != rep.FailedTotal {
+			t.Fatalf("sources count %d, total %d", sum, rep.FailedTotal)
+		}
+		users := 0
+		for name, u := range tally.byUser {
+			users += u.Count
+			if len(name) > loginNameMax || loginName(name) != name {
+				t.Fatalf("user %q is not a bounded name", name)
+			}
+		}
+		if users != rep.FailedTotal {
+			t.Fatalf("users count %d, total %d", users, rep.FailedTotal)
+		}
+		if len(rep.Accepted) > loginsTopN || rep.AcceptedTotal < len(rep.Accepted) {
+			t.Fatalf("accepted %d of %d", len(rep.Accepted), rep.AcceptedTotal)
+		}
+		for _, a := range rep.Accepted {
+			if _, err := netip.ParseAddr(a.Source); err != nil && !loginHostRe.MatchString(a.Source) {
+				t.Fatalf("accepted source %q", a.Source)
+			}
+			if loginName(a.User) != a.User || loginMethod(a.Method) != a.Method {
+				t.Fatalf("accepted %+v", a)
+			}
+		}
+	})
+}

client-go/install_ps1_test.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// install.ps1 has no Windows runner here, so its -Pair shape is read from the
+// file: the code is checked before anything is downloaded, reaches `pair -`
+// on standard input and never an argument, exit 3 is success, and the
+// install with no flag still ends the way it did.
+func TestInstallPs1PairShape(t *testing.T) {
+	raw, err := os.ReadFile(filepath.Join("..", "deploy", "install.ps1"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(raw)
+	for _, want := range []string{
+		"param([switch]$Networked, [string]$Pair)",
+		"$Pair | & $exe pair -",
+		"elseif ($rc -eq 3)",
+		"Start-ScheduledTask -TaskName 'PrivataeBastion'",
+		"Restart-Service -Name 'PrivataeBastion'",
+		`Write-Host "Open a NEW terminal, then:  privatae-bastion pair <token>"`,
+	} {
+		if !strings.Contains(s, want) {
+			t.Errorf("install.ps1 lacks %q", want)
+		}
+	}
+	for _, bad := range []string{"pair $Pair", "pair -- $Pair", "-ArgumentList $Pair", "Write-Host $Pair", "$Pair\"", "'$Pair'"} {
+		if strings.Contains(s, bad) {
+			t.Errorf("install.ps1 must never put the code in an argument or the output: %q", bad)
+		}
+	}
+	check, fetch := strings.Index(s, "StartsWith('skp_')"), strings.Index(s, `Write-Host "Fetching manifest..."`)
+	if check < 0 || fetch < 0 || check > fetch {
+		t.Error("the pairing code must be checked before the manifest is fetched")
+	}
+}
+
+// The -Pair block itself, run by pwsh against a stand-in bastion
+// (testdata/install_ps1_pair.ps1). Skipped where pwsh is not installed.
+func TestInstallPs1PairBlockRunsUnderPwsh(t *testing.T) {
+	pwsh, err := exec.LookPath("pwsh")
+	if err != nil {
+		t.Skip("pwsh is not installed: install.ps1's -Pair block is checked only by TestInstallPs1PairShape here")
+	}
+	out, err := exec.Command(pwsh, "-NoProfile", "-NonInteractive", "-File",
+		filepath.Join("testdata", "install_ps1_pair.ps1"), filepath.Join("..", "deploy", "install.ps1")).CombinedOutput()
+	if err != nil || !strings.HasPrefix(strings.TrimSpace(string(out)), "ok:") {
+		t.Fatalf("%v\n%s", err, out)
+	}
+}

client-go/install_sh_test.go

@@ -3,10 +3,13 @@
 package main
 
 import (
+	"crypto/sha256"
+	"encoding/hex"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"regexp"
+	"strings"
 	"testing"
 )
 
@@ -74,3 +77,358 @@ func TestInstallShKeepsAPairedLocalMachineLocal(t *testing.T) {
 		t.Fatal("a machine with no pairing gets the networked default")
 	}
 }
+
+// installShPrivatePIDs is what a test that reaches install.sh's
+// start_bastion runs under. start_bastion stops every copy of this user's
+// bastion it can see in /proc, and on a machine that runs a real bastion as
+// this user (root on a server) that would be the real one. So the test must
+// see only its own processes: nil when it already runs in a PID namespace of
+// its own (CI's container), the unshare prefix that makes one when it can,
+// and a skip otherwise.
+//
+// The machine's own PID namespace is the kernel's initial one, whose number
+// is fixed (PROC_PID_INIT_INO, 0xEFFFFFFC); any other is a namespace of its
+// own. NSpid in /proc/self/status cannot tell: inside a container /proc is
+// the container's, so it shows one level there too.
+func installShPrivatePIDs(t *testing.T) []string {
+	t.Helper()
+	ns, err := os.Readlink("/proc/self/ns/pid")
+	if err == nil && ns != "pid:[4026531836]" {
+		return nil
+	}
+	if err == nil && os.Geteuid() == 0 {
+		if u, err := exec.LookPath("unshare"); err == nil {
+			wrap := []string{u, "--pid", "--fork", "--mount-proc"}
+			if exec.Command(wrap[0], append(wrap[1:], "true")...).Run() == nil {
+				return wrap
+			}
+		}
+	}
+	t.Skip("install.sh's start_bastion stops every copy of this user's bastion; run this test in a PID namespace of its own (unshare --pid --fork --mount-proc, as root)")
+	return nil
+}
+
+// pairShSetup is a stand-in machine for install.sh: a log directory, a
+// home, and a PATH directory of stand-ins for systemctl, loginctl and sleep,
+// each logging what it was given. unit is how the stand-in systemd reports
+// the user unit: "steady" (one process, running) or "flapping" (a new
+// process on every look, auto-restarting).
+type pairShSetup struct {
+	dir, logs, bin, path, home string
+}
+
+func newPairShSetup(t *testing.T) *pairShSetup {
+	t.Helper()
+	d := t.TempDir()
+	s := &pairShSetup{dir: d, logs: filepath.Join(d, "log"), bin: filepath.Join(d, "bin"), path: filepath.Join(d, "path"), home: filepath.Join(d, "home")}
+	for _, p := range []string{s.logs, s.bin, s.path, s.home} {
+		if err := os.MkdirAll(p, 0o700); err != nil {
+			t.Fatal(err)
+		}
+	}
+	s.write(t, filepath.Join(s.path, "systemctl"), `#!/bin/sh
+echo "$*" >> "$LOGS/systemctl"
+case "$*" in
+  *"show -p MainPID --value"*)
+    if [ "$UNIT" = flapping ]; then n=$(cat "$LOGS/n" 2>/dev/null || echo 100); n=$((n + 1)); echo "$n" > "$LOGS/n"; echo "$n"; else echo 4242; fi ;;
+  *"show -p ActiveState --value"*) if [ "$UNIT" = flapping ]; then echo activating; else echo active; fi ;;
+  *"show -p SubState --value"*) if [ "$UNIT" = flapping ]; then echo auto-restart; else echo running; fi ;;
+esac
+exit 0
+`)
+	s.write(t, filepath.Join(s.path, "loginctl"), "#!/bin/sh\necho \"$*\" >> \"$LOGS/loginctl\"\nexit \"$LINGER_RC\"\n")
+	s.write(t, filepath.Join(s.path, "sleep"), "#!/bin/sh\nexit 0\n")
+	return s
+}
+
+func (s *pairShSetup) write(t *testing.T, p, body string) {
+	t.Helper()
+	if err := os.WriteFile(p, []byte(body), 0o700); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func (s *pairShSetup) env(extra ...string) []string {
+	return append([]string{"PATH=" + s.path + ":/usr/bin:/bin", "HOME=" + s.home, "XDG_CONFIG_HOME=" + filepath.Join(s.home, ".config"),
+		"LOGS=" + s.logs, "TMPDIR=" + s.dir}, extra...)
+}
+
+// standInCopy puts a copy of this test binary at dir/privatae-bastion: run
+// with installShStandInRun it is a bastion that waits to be stopped, under
+// the program name install.sh looks for.
+func standInCopy(t *testing.T, dir string) string {
+	t.Helper()
+	self, err := os.Executable()
+	if err != nil {
+		t.Fatal(err)
+	}
+	b, err := os.ReadFile(self)
+	if err != nil {
+		t.Fatal(err)
+	}
+	p := filepath.Join(dir, "privatae-bastion")
+	if err := os.WriteFile(p, b, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return p
+}
+
+// pairShHarness runs install.sh's pairing functions against a stand-in
+// bastion, systemctl and loginctl. It returns the run's output, the log
+// directory and its error. With copyRunning, a copy of the bastion from another
+// path is running when the functions start, and log/copy says whether it
+// still was when they ended.
+func pairShHarness(t *testing.T, root, pairRC, lingerRC string) (string, string, error) {
+	t.Helper()
+	return pairShHarnessWith(t, root, pairRC, lingerRC, "steady", false)
+}
+
+func pairShHarnessWith(t *testing.T, root, pairRC, lingerRC, unit string, copyRunning bool) (string, string, error) {
+	t.Helper()
+	wrap := installShPrivatePIDs(t)
+	s := newPairShSetup(t)
+	fake := filepath.Join(s.bin, "privatae-bastion")
+	s.write(t, fake, `#!/bin/sh
+echo "HOME=$HOME $*" >> "$LOGS/argv"
+case "$1" in
+  pair) cat > "$LOGS/stdin"; exit "$PAIR_RC" ;;
+  status) echo "status: paired" ;;
+esac
+exit 0
+`)
+	copyPath := ""
+	if copyRunning {
+		other := filepath.Join(s.dir, "other-install")
+		if err := os.MkdirAll(other, 0o700); err != nil {
+			t.Fatal(err)
+		}
+		copyPath = standInCopy(t, other)
+	}
+	fns := installShFunc(t, "pair_as") + installShFunc(t, "bastion_copy") + installShFunc(t, "stop_user_copies") +
+		installShFunc(t, "user_unit_stays_up") + installShFunc(t, "start_bastion") + installShFunc(t, "pair_and_start")
+	script := fns + `
+if [ -n "$COPY" ]; then
+  "$COPY" ` + installShStandInRun + ` >/dev/null 2>&1 &
+  copy=$!
+  i=0
+  while ! bastion_copy "$copy" && [ "$i" -lt 100 ]; do i=$((i + 1)); /bin/sleep 0.05; done
+  bastion_copy "$copy" || { echo "the stand-in copy never started" >&2; exit 97; }
+fi
+rc=0
+pair_and_start "$1" "$2" "$3" linux || rc=$?
+if [ -n "$COPY" ]; then
+  if bastion_copy "$copy"; then echo alive > "$LOGS/copy"; kill -9 "$copy"; else echo gone > "$LOGS/copy"; fi
+fi
+exit "$rc"
+`
+	args := append(append([]string{}, wrap...), "sh", "-c", script, "sh", fake, "skp_INVENTEDCODE", root)
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Env = s.env("PAIR_RC="+pairRC, "LINGER_RC="+lingerRC, "UNIT="+unit, "COPY="+copyPath)
+	out, err := cmd.CombinedOutput()
+	return string(out), s.logs, err
+}
+
+func readPairShLog(t *testing.T, dir, name string) string {
+	t.Helper()
+	b, _ := os.ReadFile(filepath.Join(dir, name))
+	return string(b)
+}
+
+// The pairing functions hand the code to `pair -` on standard input, never
+// as an argument, then write and start a systemd user unit, ask for
+// lingering, and end with one plain sentence. Exit 3 (already paired with
+// this Host) is success.
+func TestInstallShPairsOverStdinAndStartsAUserUnit(t *testing.T) {
+	out, logs, err := pairShHarness(t, "0", "0", "0")
+	if err != nil {
+		t.Fatalf("%v\n%s", err, out)
+	}
+	argv := readPairShLog(t, logs, "argv")
+	if !strings.Contains(argv, " pair -\n") || strings.Contains(argv, "skp_") {
+		t.Fatalf("the code must reach `pair -` on stdin and never an argument: %q", argv)
+	}
+	if got := readPairShLog(t, logs, "stdin"); got != "skp_INVENTEDCODE\n" {
+		t.Fatalf("pair's standard input: %q", got)
+	}
+	home := strings.TrimPrefix(strings.Fields(argv)[0], "HOME=")
+	unit, err := os.ReadFile(filepath.Join(home, ".config", "systemd", "user", "privatae-bastion.service"))
+	if err != nil || !regexp.MustCompile(`(?m)^ExecStart=\S+/privatae-bastion run$`).Match(unit) || !strings.Contains(string(unit), "WantedBy=default.target") {
+		t.Fatalf("the user unit: %v\n%s", err, unit)
+	}
+	sc := readPairShLog(t, logs, "systemctl")
+	for _, want := range []string{"--user daemon-reload", "--user enable privatae-bastion", "--user restart privatae-bastion"} {
+		if !strings.Contains(sc, want+"\n") {
+			t.Fatalf("systemctl was not asked to %q: %q", want, sc)
+		}
+	}
+	if !strings.Contains(readPairShLog(t, logs, "loginctl"), "enable-linger ") {
+		t.Fatal("lingering was not asked for")
+	}
+	if !strings.Contains(out, "status: paired") || !strings.HasSuffix(strings.TrimSpace(out),
+		"This machine is paired. The bastion runs as your systemd user service privatae-bastion, and starts at boot.") {
+		t.Fatalf("the ending: %s", out)
+	}
+
+	out, _, err = pairShHarness(t, "0", "3", "1")
+	if err != nil || !strings.Contains(out, "already paired with this Host") || !strings.Contains(out, "sudo loginctl enable-linger") {
+		t.Fatalf("exit 3 is success, and a refused linger says how to get it: %v\n%s", err, out)
+	}
+
+	out, logs, err = pairShHarness(t, "0", "1", "0")
+	if err == nil || strings.Contains(readPairShLog(t, logs, "systemctl"), "restart") || !strings.Contains(out, "pairing did not finish") {
+		t.Fatalf("a failed pair must stop before starting anything: %v\n%s", err, out)
+	}
+
+	out, logs, err = pairShHarness(t, "1", "0", "0")
+	if err != nil || !strings.Contains(readPairShLog(t, logs, "argv"), "HOME=/root ") ||
+		readPairShLog(t, logs, "systemctl") != "restart privatae-bastion\n" || strings.Contains(out, "user service") {
+		t.Fatalf("as root it pairs as the service's state and restarts the system service: %v\n%s\n%s", err, out, readPairShLog(t, logs, "systemctl"))
+	}
+}
+
+// Linux, as yourself: a copy of the bastion already running outside the
+// user unit (from a terminal, or another path) is stopped before the unit
+// starts, so the unit's copy is the one that serves; and a unit that does not
+// stay up is said plainly, with a failure, never reported as running.
+func TestInstallShStopsAnOutsideCopyAndChecksTheUnitStaysUp(t *testing.T) {
+	out, logs, err := pairShHarnessWith(t, "0", "0", "0", "steady", true)
+	if err != nil {
+		t.Fatalf("%v\n%s", err, out)
+	}
+	if got := strings.TrimSpace(readPairShLog(t, logs, "copy")); got != "gone" {
+		t.Fatalf("the copy running outside the unit must be stopped, it is %q\n%s", got, out)
+	}
+	if !strings.Contains(out, "Stopped 1 copy(ies) of the bastion running outside its service") {
+		t.Fatalf("the stop is said: %s", out)
+	}
+	sc := readPairShLog(t, logs, "systemctl")
+	if i, j := strings.Index(sc, "--user stop privatae-bastion\n"), strings.Index(sc, "--user restart privatae-bastion\n"); i < 0 || j < i {
+		t.Fatalf("the unit is stopped before the copies and started after: %q", sc)
+	}
+	if !strings.HasSuffix(strings.TrimSpace(out), "This machine is paired. The bastion runs as your systemd user service privatae-bastion, and starts at boot.") {
+		t.Fatalf("the ending: %s", out)
+	}
+
+	out, _, err = pairShHarnessWith(t, "0", "0", "0", "flapping", false)
+	if err == nil || !strings.Contains(out, "is not staying up") || !strings.Contains(out, "activating/auto-restart") ||
+		!strings.Contains(out, "journalctl --user -u privatae-bastion") || strings.Contains(out, "The bastion runs as your systemd user service") {
+		t.Fatalf("a unit that restarts must be reported as not running, and fail: %v\n%s", err, out)
+	}
+}
+
+// The whole of install.sh, the card's way: the code in PRIVATAE_PAIR_CODE
+// and no argument. Every program it starts (stand-ins for uname, id, curl,
+// printf, systemctl, loginctl and sleep, and the downloaded bastion) records
+// its own arguments, the command line of the shell that started it, and
+// whether the code is in its environment. The code must reach `pair -` on
+// standard input and appear in none of those. Nothing leaves this machine:
+// curl is a stand-in serving a manifest and a stand-in bastion.
+func TestInstallShTakesTheCodeOnlyFromTheEnvironment(t *testing.T) {
+	wrap := installShPrivatePIDs(t)
+	s := newPairShSetup(t)
+	const code = "skp_eyJ2IjoxLCJ0IjoiSU5WRU5URUQtRU5WLUNPREUifQ"
+	record := `echo "$(basename "$0") argv=[$*] parent=[$(tr '\0' ' ' < /proc/$PPID/cmdline)] env=[${PRIVATAE_PAIR_CODE+set}] envcode=[$(env | grep -c "` + code + `")]" >> "$LOGS/procs"
+`
+	bastion := "#!/bin/sh\n" + record + `case "$1" in
+  pair) cat > "$LOGS/stdin" ;;
+  status) echo "status: paired" ;;
+esac
+exit 0
+`
+	s.write(t, filepath.Join(s.dir, "bastion.bin"), bastion)
+	sum := sha256.Sum256([]byte(bastion))
+	s.write(t, filepath.Join(s.dir, "version.json"), "{\n  \"linux-amd64\": {\n    \"url\": \"https://dl.privatae.ai/dl/privatae-bastion-linux-amd64?v=0.0.0\",\n    \"sha256\": \""+hex.EncodeToString(sum[:])+"\"\n  }\n}\n")
+	stand := map[string]string{
+		"uname":  `case "$1" in -s) echo Linux ;; -m) echo x86_64 ;; *) echo Linux ;; esac`,
+		"id":     `case "$1" in -u) echo 1000 ;; -un) echo tester ;; *) echo "uid=1000(tester)" ;; esac`,
+		"curl":   `for a; do o=$a; done; case "$2" in */version.json) cp "$STAND/version.json" "$o" ;; *) cp "$STAND/bastion.bin" "$o" ;; esac`,
+		"printf": `exec /usr/bin/printf "$@"`,
+	}
+	for name, body := range stand {
+		s.write(t, filepath.Join(s.path, name), "#!/bin/sh\n"+record+body+"\n")
+	}
+	for _, name := range []string{"systemctl", "loginctl", "sleep"} {
+		p := filepath.Join(s.path, name)
+		b, _ := os.ReadFile(p)
+		s.write(t, p, strings.Replace(string(b), "#!/bin/sh\n", "#!/bin/sh\n"+record, 1))
+	}
+	sh, err := filepath.Abs(filepath.Join("..", "deploy", "install.sh"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	args := append(append([]string{}, wrap...), "sh", sh)
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Env = s.env("PRIVATAE_PAIR_CODE="+code, "STAND="+s.dir, "LINGER_RC=0", "UNIT=steady")
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("%v\n%s", err, out)
+	}
+	if got := readPairShLog(t, s.logs, "stdin"); got != code+"\n" {
+		t.Fatalf("pair's standard input: %q\n%s", got, out)
+	}
+	procs := readPairShLog(t, s.logs, "procs")
+	for _, who := range []string{"uname argv=[-s]", "curl argv=[", "privatae-bastion argv=[pair -]", "privatae-bastion argv=[status]", "systemctl argv=[--user restart privatae-bastion]"} {
+		if !strings.Contains(procs, who) {
+			t.Fatalf("no record of %q: the stand-ins did not run as expected\n%s\n%s", who, procs, out)
+		}
+	}
+	if strings.Contains(procs, code) || strings.Contains(procs, "INVENTED-ENV-CODE") {
+		t.Fatalf("the code is in a program's arguments or its shell's command line:\n%s", procs)
+	}
+	if strings.Contains(procs, "env=[set]") || !strings.Contains(procs, "envcode=[0]") || strings.Contains(procs, "envcode=[1]") {
+		t.Fatalf("a program the installer started inherited the code in its environment:\n%s", procs)
+	}
+	if strings.Contains(string(out), code) {
+		t.Fatalf("the installer printed the code:\n%s", out)
+	}
+	if !strings.HasSuffix(strings.TrimSpace(string(out)), "https://privatae.ai/bastion/LICENSE.txt") || !strings.Contains(string(out), "This machine is paired.") {
+		t.Fatalf("the ending: %s", out)
+	}
+}
+
+// A PRIVATAE_PAIR_CODE that is empty or not a whole pairing code is refused
+// before anything is downloaded, and never echoed; so is any argument, a
+// code given as one (the removed --pair, or the code alone) included.
+//
+// The script runs with stand-ins for id (not root) and curl (records that it
+// was reached, fetches nothing), so an installer whose refusal broke can
+// neither reach the network nor install anything as root on the machine
+// running the test: it fails here instead.
+func TestInstallShRefusesABadPairCodeBeforeDownloading(t *testing.T) {
+	const code = "skp_eyJ2IjoxfQ"
+	stand := t.TempDir()
+	for name, body := range map[string]string{
+		"id":   `case "$1" in -u) echo 1000 ;; -un) echo tester ;; *) echo "uid=1000(tester)" ;; esac`,
+		"curl": `echo "REACHED-THE-DOWNLOAD" >&2; exit 1`,
+	} {
+		if err := os.WriteFile(filepath.Join(stand, name), []byte("#!/bin/sh\n"+body+"\n"), 0o700); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, c := range []struct {
+		env  []string
+		args []string
+	}{
+		{[]string{"PRIVATAE_PAIR_CODE="}, nil},
+		{[]string{"PRIVATAE_PAIR_CODE=skp_"}, nil},
+		{[]string{"PRIVATAE_PAIR_CODE=skb_aG9tZS5zZWNyZXQteA"}, nil},
+		{[]string{"PRIVATAE_PAIR_CODE=" + code + " trailing"}, nil},
+		{[]string{"PRIVATAE_PAIR_CODE=" + code + "%3D"}, nil},
+		{nil, []string{"--pair", code}},
+		{nil, []string{"--pair=" + code}},
+		{nil, []string{code}},
+		{nil, []string{"--networkd"}},
+	} {
+		home := t.TempDir()
+		cmd := exec.Command("sh", append([]string{filepath.Join("..", "deploy", "install.sh")}, c.args...)...)
+		cmd.Env = append([]string{"PATH=" + stand + ":/usr/bin:/bin", "HOME=" + home, "TMPDIR=" + home}, c.env...)
+		out, err := cmd.CombinedOutput()
+		ee, ok := err.(*exec.ExitError)
+		if !ok || ee.ExitCode() != 2 || strings.Contains(string(out), "Fetching manifest") || strings.Contains(string(out), "REACHED-THE-DOWNLOAD") {
+			t.Fatalf("%v %v: want exit 2 before the download, got %v\n%s", c.env, c.args, err, out)
+		}
+		if strings.Contains(string(out), code) || strings.Contains(string(out), "skb_") || strings.Contains(string(out), "networkd") {
+			t.Fatalf("%v %v: the refusal echoes what it was given: %s", c.env, c.args, out)
+		}
+	}
+}

client-go/machinestore.go

@@ -1018,19 +1018,27 @@ var observeArgsRecorded = map[string]int{
 	"observe:net":     1, // host[:port], charset-checked before use
 	"observe:metrics": 1, // a name from a fixed query table
 	"observe:logs":    2, // a name, and an optional minutes window (a whole number)
+	"observe:folders": 2, // an absolute path, and an optional depth
+	"observe:journal": 2, // a unit name, and an optional minutes window
+	"observe:logins":  1, // an optional window in hours
+	"observe:cert":    2, // a local port, and an optional server name
 }
 
 // storeObserveLine is one line of observe/<op>/<date>.jsonl.
 //
-// WHAT COMES TO REST HERE. Eight of the eleven ops return fixed schemas the
+// WHAT COMES TO REST HERE. Most of the ops return fixed schemas the beat
-// beat already summarises (posture ints, unit names, sockets, a probe's TLS
+// already summarises (posture ints, unit names, sockets, a probe's TLS
-// subject). observe:alerts and observe:metrics carry label maps that can name
+// subject, a served certificate's names). observe:alerts and observe:metrics
-// namespaces and tenants. observe:logs is the outlier: its result is raw
+// carry label maps that can name namespaces and tenants. observe:folders
-// production log text, up to the line bound, persisted for 30 days — the one
+// carries folder paths, which can carry a person's account or project name.
-// payload whose content this repo does not control, and so the one place a
+// observe:logins carries account names and the addresses they came from, the
+// failed ones as the other side sent them (bounded by loginName).
+// observe:logs and observe:journal are the outliers: their result is raw
+// production log text, up to the line bound, persisted for 30 days — the
+// payloads whose content this repo does not control, and so the places a
 // token or a user identifier can come to rest. Files are 0600 under a 0700
 // tree; the reader is the machine's own OS account and the anchor's approved
-// store. Named here so the next person choosing what to log through this op
+// store. Named here so the next person choosing what to log through these ops
 // knows it stays.
 type storeObserveLine struct {
 	At      string   `json:"at"`
@@ -1097,8 +1105,8 @@ func storeObserveDroppedReset() {
 // (`observe:k8s`, `observe-k8s` and `observe_k8s` all reduce to
 // `observe-k8s`) and, since the lowercasing below, case folding
 // (`observe:K8s` and `observe:k8s`). Neither can bite today — the op reaches
-// this writer only from the eleven names registered in handlerOps, all
+// this writer only from the observe names registered in handlerOps, all
-// lowercase, which reduce to eleven distinct directories
+// lowercase, which reduce to as many distinct directories
 // (TestEveryRegisteredOpSanitisesToTheHostsShelfRule walks them) — but a
 // future pair like `observe:k8s-nodes` / `observe:k8s_nodes` would interleave
 // into one day-file. Whoever adds such a pair renames one of them.

client-go/machinestore_test.go

@@ -15,6 +15,7 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"strconv"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -1696,9 +1697,12 @@ func TestObserveArgsRecordedMatchesTheHandlers(t *testing.T) {
 	}
 	// Arities, from the handlers' own checks (observe_ops.go handleObserveNet
 	// len(args) != 1; observe_pull.go handleObserveMetrics len(args) != 1;
-	// handleObserveLogs len(args) > 2).
+	// handleObserveLogs len(args) > 2; observe_reads.go folders, journal and
+	// cert len(args) > 2, logins len(args) > 1).
 	if observeArgsRecorded["observe:net"] != 1 || observeArgsRecorded["observe:metrics"] != 1 ||
-		observeArgsRecorded["observe:logs"] != 2 {
+		observeArgsRecorded["observe:logs"] != 2 || observeArgsRecorded["observe:folders"] != 2 ||
+		observeArgsRecorded["observe:journal"] != 2 || observeArgsRecorded["observe:logins"] != 1 ||
+		observeArgsRecorded["observe:cert"] != 2 {
 		t.Fatalf("arities drifted from the handlers: %v", observeArgsRecorded)
 	}
 }
@@ -1785,10 +1789,38 @@ func TestRecordedArgCountsMatchWhatTheHandlersAccept(t *testing.T) {
 	// And every ACCEPTED position must hold a value the handler accepts —
 	// observe:logs's second argument is a minutes window, and "x" there is
 	// refused for its shape, which is not an arity refusal either.
+	//
+	// The four in observe_reads.go answer through their drivers on Linux, so
+	// what they read is put in front of them here and nothing on the box that
+	// runs the suite is: one unit this machine "has", one TLS listener ss
+	// "reports", an empty journal, and a folder of the test's own.
+	cert := observeTestCert(t, "box-a.example", []string{"box-a.example"}, nil, time.Now().Add(24*time.Hour))
+	port := strconv.Itoa(observeTLSListener(t, cert))
+	origExec, origHave, origAccess := observeExec, observeHave, observeJournalAccess
+	observeExec = func(_ context.Context, name string, args ...string) ([]byte, error) {
+		switch name + " " + args[0] {
+		case "systemctl list-units":
+			return []byte("example.service loaded active running Example\n"), nil
+		case "ss -tlnpH":
+			return []byte("LISTEN 0 4096 127.0.0.1:" + port + " 0.0.0.0:*\n"), nil
+		}
+		return nil, nil
+	}
+	observeHave = func(string) bool { return true }
+	observeJournalAccess = func() string { return "" }
+	defer func() { observeExec, observeHave, observeJournalAccess = origExec, origHave, origAccess }()
+	folder := "/"
+	if observeHostSupported {
+		folder = t.TempDir()
+	}
 	accepted := map[string][]string{
 		"observe:net":     {"203.0.113.9:443"},
 		"observe:metrics": {"up"},
 		"observe:logs":    {"kernel", "5"},
+		"observe:folders": {folder, "1"},
+		"observe:journal": {"example", "5"},
+		"observe:logins":  {"24"},
+		"observe:cert":    {port, "box-a.example"},
 	}
 	for op, n := range observeArgsRecorded {
 		if len(accepted[op]) != n {
@@ -1828,7 +1860,7 @@ func TestEveryRegisteredOpSanitisesToTheHostsShelfRule(t *testing.T) {
 			t.Fatalf("%s sanitises to %q, which the host rejects as unreadable", op, got)
 		}
 	}
-	if n < 11 {
+	if n < 15 {
 		t.Fatalf("only %d observe ops walked — the registry moved and this test is not covering it", n)
 	}
 }

client-go/main.go

@@ -37,6 +37,13 @@ Usage:
                                that CA alone (name host.cseries.internal), the lanes go to
                                the lane port the Host names, and the CA is pinned for life.
                                No coder runs over this pairing
+  privatae-bastion pair <pairing code skp_…>
+                               the same pairing from the one code a Cloud Host's card gives:
+                               it carries the enroll address and the CA's fingerprint, and
+                               the CA is taken from the enroll port only under that
+                               fingerprint. On a local machine that already serves a Host,
+                               it asks here whether to add this one as well. Exit 3: already
+                               paired with this Host, nothing changed
   privatae-bastion run            bring up the tunnel + lanes for EVERY paired host
                                (a loopback control port per host for the verbs below:
                                127.0.0.1:7878, then 7879, …)
@@ -188,7 +195,9 @@ func takeHostFlag(args []string) (string, []string) {
 }
 
 const pairUsage = "usage: privatae-bastion pair [--replace] [--redeem-url unix:///<socket> | --redeem-url https://<host>:<port>/<path> --host-ca <pem file>] <token> | -\n" +
-	"  - reads the token from standard input, so it stays out of the process list and shell history"
+	"       privatae-bastion pair <pairing code skp_…> | -\n" +
+	"  - reads the token or pairing code from standard input, so it stays out of the process list and shell history\n" +
+	"  exit status: 0 paired, 3 already paired with this Host (nothing changed), anything else a failure"
 
 // parsePairArgs reads `pair`'s flags in any order: --replace, --redeem-url
 // for a Host with no platform (pair_unix.go, pair_tcp.go) and --host-ca for
@@ -258,6 +267,15 @@ func main() {
 			os.Exit(2)
 		}
 		err = cmdPair(token, redeemURL, hostCA, replace)
+		// Already paired with this Host, nothing changed: its own exit status,
+		// so the installers (install.ps1 -Pair, install.sh with
+		// PRIVATAE_PAIR_CODE) report "already connected".
+		var already *alreadyPairedError
+		if errors.As(err, &already) {
+			auditFlush(auditFlushOnExit)
+			fmt.Fprintln(os.Stderr, already)
+			os.Exit(pairExitAlreadyPaired)
+		}
 	case "run":
 		err = cmdRun()
 	case "observe:baseline":
@@ -589,6 +607,7 @@ func main() {
 	case "ops":
 		// ops [--host <host>]            what ops and op grants this machine holds
 		// ops drop <grant> [--host <host>]  take back a held op grant (the host is told)
+		// ops drop --all [--host <host>]    take back every op grant the host holds here
 		host, args := takeHostFlag(os.Args[2:])
 		if len(args) >= 2 && args[0] == "drop" {
 			err = cmdOpsDrop(host, args[1])

client-go/main_test.go

@@ -36,8 +36,13 @@ import (
 	"os"
 	"strings"
 	"testing"
+	"time"
 )
 
+// installShStandInRun is the argument that makes this test binary stand in
+// for a running bastion (TestMain).
+const installShStandInRun = "install-sh-stand-in-run"
+
 func TestMain(m *testing.M) {
 	// The op sandbox re-execs its own binary (ops_exec_linux.go); under
 	// `go test` that binary is this one, so the child must be answered here
@@ -62,6 +67,13 @@ func TestMain(m *testing.M) {
 	if len(os.Args) >= 3 && os.Args[1] == rootExecConnectSubcommand {
 		os.Exit(rootExecConnectMain(os.Args[2:]))
 	}
+	// install_sh_test.go runs a copy of this binary named privatae-bastion as
+	// a bastion left running outside its service: it only waits to be
+	// stopped, and never starts the suite.
+	if len(os.Args) >= 2 && os.Args[1] == installShStandInRun {
+		time.Sleep(2 * time.Minute)
+		os.Exit(0)
+	}
 	// Likewise when git runs this binary as the bastion's credential helper
 	// (claims_git_test.go): answer as the helper, with the config dir the
 	// test named, and never start the suite.

client-go/mgmt.go

@@ -105,6 +105,15 @@ type opHandler struct {
 //     is exec'd, so the discipline here is a fixed QUERY TABLE instead of a
 //     fixed argv: the host sends a NAME, the box owns the PromQL and the LogQL,
 //     and an unknown name is refused with the known ones listed.
+//   - observe:folders / observe:journal / observe:logins / observe:cert
+//     (observe_reads.go): the questions a host otherwise handed the person as
+//     a command — the largest folders under a path, one unit's recent journal,
+//     sshd's failed and accepted logins, the certificate a local port serves.
+//     Their caller values are a path, a unit name, a number and a port with a
+//     server name, each checked against a written grammar before use. The
+//     one caller string that reaches a program is the unit name, and only
+//     once this machine's own unit list names it; a window reaches journalctl
+//     only as a number this box parsed and wrote back out.
 var handlerOps = map[string]opHandler{
 	"computer:inventory": {rootNone, "", handleComputerInventory},
 	"computer:windows":   {rootNone, "", handleComputerWindows},
@@ -120,6 +129,10 @@ var handlerOps = map[string]opHandler{
 	"observe:alerts":     {rootNone, "", handleObserveAlerts},
 	"observe:metrics":    {rootNone, "", handleObserveMetrics},
 	"observe:logs":       {rootNone, "", handleObserveLogs},
+	"observe:folders":    {rootNone, "", handleObserveFolders},
+	"observe:journal":    {rootNone, "", handleObserveJournal},
+	"observe:logins":     {rootNone, "", handleObserveLogins},
+	"observe:cert":       {rootNone, "", handleObserveCert},
 	"ctx_put":            {rootCtx, "context store not configured", handleCtxPut},
 	"ctx_get":            {rootCtx, "context store not configured", handleCtxGet},
 	"ctx_del":            {rootCtx, "context store not configured", handleCtxDel},
@@ -158,10 +171,13 @@ var handlerOps = map[string]opHandler{
 	// op_* (ops.go / ops_exec_linux.go): an op the host wrote, held under
 	// signed terms and run in a sandbox. rootDcn: the op store and ops.json
 	// sit beside the pairing's grants, and the terms verify under its key.
+	// op_grant_drop <grant|all> (ops_bounds.go) takes a held grant back: a
+	// tighten (writes.go opTightens), so no quarantine or approval holds it.
 	"op_sync":       {rootDcn, "dcn store not configured", handleOpSync},
 	"op_dry_run":    {rootDcn, "dcn store not configured", handleOpDryRun},
 	"op_apply":      {rootDcn, "dcn store not configured", handleOpApply},
 	"op_grant_run":  {rootDcn, "dcn store not configured", handleOpGrantRun},
+	"op_grant_drop": {rootDcn, "dcn store not configured", handleOpGrantDrop},
 	"op_list":       {rootDcn, "dcn store not configured", handleOpList},
 	"op_run_status": {rootDcn, "dcn store not configured", handleOpRunStatus},
 	// op_plan_* (ops_plan.go): a line of a ship plan the person's device
@@ -231,10 +247,12 @@ type mgmtAccount struct {
 	self string
 	op   string // "" when the frame did not parse: the box does not know
 	// args is what the host passed, so the observe shelf can record WHAT was
-	// asked beside the result. Three ops read a caller value — observe:net
+	// asked beside the result. Seven ops read a caller value — observe:net
 	// (host[:port]), observe:metrics (a name), observe:logs (a name and an
-	// optional selector); the rest ignore theirs. The shelf records args only
+	// optional window), observe:folders (a path and a depth), observe:journal
-	// for those three, bounded (machinestore.go observeArgsRecorded): the first
+	// (a unit and a window), observe:logins (hours) and observe:cert (a port
+	// and a server name); the rest ignore theirs. The shelf records args only
+	// for those seven, bounded (machinestore.go observeArgsRecorded): the first
 	// version recorded whatever the host sent for every op, unbounded, and
 	// this comment — which said only one op took a value — made that look safe.
 	args []string
@@ -258,7 +276,7 @@ func beginMgmtAccount(ws *websocket.Conn, self, op string, args []string) {
 
 // mgmtAccountOf is the record for this connection, or nil. Read by the observe
 // shelf to learn which op produced a result and which host asked, without the
-// eleven handlers having to be told either.
+// observe handlers having to be told either.
 func mgmtAccountOf(ws *websocket.Conn) *mgmtAccount {
 	if v, ok := mgmtAccounts.Load(ws); ok {
 		return v.(*mgmtAccount)

client-go/mode.go

@@ -88,11 +88,13 @@ func setBoxMode(mode string) error {
 		}
 	}
 	if mode == modeLocal {
-		// Going back to local must not strand hosts: a local box serves ONE host,
+		// Going back to local must not strand hosts: a local box serves a second
-		// so with several pairings the box would be lying about its own rule.
+		// host only on a yes typed at this machine (pair_terminal.go), and these
+		// were paired under the networked rules, so with several pairings the box
+		// would serve hosts nobody here said yes to.
 		cfgs, err := loadPairings()
 		if err == nil && len(cfgs) > 1 {
-			return fmt.Errorf("cannot switch to local mode: %d hosts are paired and a local bastion serves one — remove the others first", len(cfgs))
+			return fmt.Errorf("cannot switch to local mode: %d hosts are paired, and a local bastion adds a second host only on a yes typed at this machine — remove the others first, then pair them again here", len(cfgs))
 		}
 		if currentAnchor() != nil {
 			return errors.New("cannot switch to local mode: this box is anchored (anchor.json) — anchoring is a networked-mode concept")

client-go/observe_ops.go

@@ -6,9 +6,12 @@ package main
 // execs runs as root.
 // The discipline is the one a read-only sudoers policy lives by: every op is
 // a FIXED argv, read-only forms only, and no byte of a job's args ever reaches a shell or an
-// argv position. The single exception is observe:net, whose one argument is
+// argv position. The single exception in this file is observe:net, whose one argument is
 // a host[:port] that passes a strict charset check and is then handed to
-// Go's net package — never to a program.
+// Go's net package — never to a program. observe_reads.go has the one caller
+// string in the family that does reach an argv: observe:journal's unit name,
+// after systemd's unit-name alphabet and this machine's own unit list. Its
+// windows reach journalctl only as numbers this box parsed and wrote back out.
 //
 // Every op answers typed JSON on stdout and exit 0. A box that cannot answer
 // (a tool missing, a platform without the probes) says so in the JSON —
@@ -849,7 +852,7 @@ func writeObserve(ws *websocket.Conn, v any) {
 	// The machine's own record of what it answered (machinestore.go, the
 	// observe shelf): the same bytes that go down the lane, filed under the op
 	// and the host that asked. Read off this connection's account rather than
-	// threaded through eleven handlers. BEFORE the reply, so a slow disk
+	// threaded through every handler. BEFORE the reply, so a slow disk
 	// cannot leave a result sent-but-unrecorded; a failed write is counted,
 	// never allowed to fail the reply.
 	if a := mgmtAccountOf(ws); a != nil {

client-go/observe_ops_test.go

@@ -393,7 +393,8 @@ func TestNetTargetPublicOnly(t *testing.T) {
 
 var observeOps = []string{"observe:host", "observe:sockets", "observe:firewall", "observe:units",
 	"observe:disk", "observe:kernel", "observe:k8s", "observe:net",
-	"observe:alerts", "observe:metrics", "observe:logs"}
+	"observe:alerts", "observe:metrics", "observe:logs",
+	"observe:folders", "observe:journal", "observe:logins", "observe:cert"}
 
 // observeArgOps are the ops in the family that read a caller value. Every one
 // of them must REFUSE the poison set rather than answer it; the rest ignore
@@ -408,6 +409,10 @@ var observeArgRefusal = map[string]string{
 	"observe:net":     "one argument",
 	"observe:metrics": "exactly one argument",
 	"observe:logs":    "takes a name",
+	"observe:folders": "takes a folder path",
+	"observe:journal": "takes a unit name",
+	"observe:logins":  "at most one argument",
+	"observe:cert":    "takes a local tcp port",
 }
 
 var observeArgOps = func() map[string]bool {
@@ -560,7 +565,8 @@ func TestObserveArgsNeverReachArgv(t *testing.T) {
 				t.Fatalf("%s: the arity refusal must say %q, got %q", op, want, errOut)
 			}
 			// exactly one poisoned value: still refused — by the charset check
-			// for observe:net, by the fixed query table for the other two.
+			// for observe:net, by the fixed query table for metrics and logs,
+			// and by the written grammar of each of the four in observe_reads.go.
 			_, errOut, code = driveObserve(t, op, poison[:1])
 			if code == 0 {
 				t.Fatalf("%s with a shell value must refuse: code=%d err=%q", op, code, errOut)

client-go/observe_pull.go

@@ -325,8 +325,8 @@ func parseAlerts(raw []byte) (alertsReport, error) {
 
 // handleObserveAlerts takes no argument: the op is the whole active set, the
 // way observe:host is the whole posture. Args are ignored exactly as they are
-// there, so the only arg-taking ops in the family stay observe:net,
+// there, so it stays out of the arg-taking ops (observeArgsRecorded,
-// observe:metrics and observe:logs.
+// machinestore.go, lists them).
 func handleObserveAlerts(ws *websocket.Conn, _ string, _ []string) {
 	ctx, cancel := opBudget()
 	defer cancel()

client-go/observe_reads_linux.go

@@ -0,0 +1,508 @@
+//go:build linux
+
+package main
+
+// Linux drivers for observe:folders, observe:journal, observe:logins and
+// observe:cert (observe_reads.go holds their grammar and parsers). The
+// programs are the ones observe_ops_linux.go keeps to — journalctl, systemctl
+// and ss, read-only forms only — and every exec shares one op budget.
+//
+// No elevation of its own. The networked install runs the bastion as root
+// (deploy/install.sh writes no User=), which is how observe:host already reads
+// nft and iptables, and so how these read the journal and every folder. A
+// bastion run as a user reads what that user can: a folder it cannot open is
+// named in skipped, and a journal it cannot read wholly is said so outright
+// (journalAccess), because journalctl does not fail for such a user — it shows
+// only the user's own lines, an empty answer that would read as a quiet machine.
+
+import (
+	"context"
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"syscall"
+	"time"
+)
+
+// journalAccess is the default observeJournalAccess. root reads everything;
+// any other account can read the system journal only when it may open the
+// system journal file itself (the systemd-journal or adm group), which is
+// exactly what journalctl will be able to do.
+func journalAccess() string {
+	if os.Geteuid() == 0 {
+		return ""
+	}
+	raw, err := os.ReadFile("/etc/machine-id")
+	mid := strings.TrimSpace(string(raw))
+	if err == nil && machineIDRe.MatchString(mid) {
+		for _, dir := range []string{"/var/log/journal/", "/run/log/journal/"} {
+			if f, err := os.Open(dir + mid + "/system.journal"); err == nil {
+				_ = f.Close()
+				return ""
+			}
+		}
+	}
+	return "the bastion runs as an account that cannot read the system journal; " +
+		"run it as root (the networked install does) or add that account to the systemd-journal group"
+}
+
+var machineIDRe = regexp.MustCompile(`^[0-9a-f]{32}$`)
+
+// ── observe:folders ──────────────────────────────────────────────────────────
+
+const (
+	// folderReadBatch is how many names one directory read takes: a folder of
+	// a million files is read in pieces, not into memory at once.
+	folderReadBatch = 512
+	// folderLinkCap bounds the set of hard-linked files already counted.
+	// Past it each further link is counted (sizes may read high) and the
+	// answer says so.
+	folderLinkCap = 1 << 20
+	// folderStuckMax bounds the walks left inside a read that has not
+	// returned. Each holds an OS thread for as long as that read hangs (a hard
+	// network mount: until it comes back), and a Host asking again and again
+	// about a path on one would otherwise pile them up until the bastion
+	// could start no more. Past it the op answers at once, sizing nothing.
+	folderStuckMax = 4
+)
+
+// folderStuckGrace is how long past the op budget the answer waits for a walk
+// that is inside one read, before answering without it. folderSizer is the
+// walk. Both are variables so a test can stand in a walk that never returns.
+var (
+	folderStuckGrace = 2 * time.Second
+	folderSizer      = sizeFolders
+	// folderWalksStuck counts the walks readFolders answered without that have not
+	// returned since.
+	folderWalksStuck atomic.Int32
+)
+
+// folderBeforeOpen is called with each folder's path between its stat and its
+// open: a seam so a test can swap the folder in that gap. nil outside tests.
+var folderBeforeOpen func(string)
+
+// reasonChanged is the skip reason for a folder that is no longer the one the
+// walk stat'd when it comes to open it: swapped for a link, or reached
+// through a folder above it that was.
+const reasonChanged = "changed while it was read, not counted"
+
+type folderWalk struct {
+	ctx      context.Context
+	root     string
+	depth    int
+	dev      uint64
+	mounts   map[string]bool
+	linked   map[uint64]struct{}
+	linkFull bool
+	top      folderTop
+	sized    int
+	skips    folderSkips
+	cut      bool
+}
+
+func (w *folderWalk) expired() bool {
+	if !w.cut && w.ctx.Err() != nil {
+		w.cut = true
+	}
+	return w.cut
+}
+
+// skip records what could not be sized against the folder that holds it,
+// folded to the asked depth. A file is never named: its folder is.
+func (w *folderWalk) skip(dir, reason string) {
+	w.skips.add(folderAt(w.root, dir, w.depth), reason)
+}
+
+func folderSkipReason(err error) string {
+	var errno syscall.Errno
+	if errors.As(err, &errno) {
+		if errno == syscall.EACCES || errno == syscall.EPERM {
+			return "permission denied"
+		}
+		return errno.Error()
+	}
+	return "could not be read"
+}
+
+// firstLink says whether a file with more than one link is being seen for
+// the first time, so its blocks are counted once, as du counts them.
+func (w *folderWalk) firstLink(ino uint64) bool {
+	if _, seen := w.linked[ino]; seen {
+		return false
+	}
+	if len(w.linked) >= folderLinkCap {
+		w.linkFull = true
+		return true
+	}
+	w.linked[ino] = struct{}{}
+	return true
+}
+
+// openFolder opens p only when it is still the folder st describes. Between
+// the stat and the open, p, or a folder above it, can be swapped for a link
+// by whoever owns the folder above; O_NOFOLLOW refuses a link at p itself,
+// and the device and inode of what opened refuse one above it. Without this
+// a link put there in that gap would lead the walk elsewhere, onto another
+// filesystem or into /proc, under p's name.
+func openFolder(p string, st *syscall.Stat_t) (*os.File, error) {
+	f, err := os.OpenFile(p, os.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW, 0)
+	if err != nil {
+		if errors.Is(err, syscall.ELOOP) || errors.Is(err, syscall.ENOTDIR) {
+			return nil, errFolderChanged
+		}
+		return nil, err
+	}
+	fi, err := f.Stat()
+	if err != nil {
+		_ = f.Close()
+		return nil, err
+	}
+	got, ok := fi.Sys().(*syscall.Stat_t)
+	if !ok || got.Dev != st.Dev || got.Ino != st.Ino {
+		_ = f.Close()
+		return nil, errFolderChanged
+	}
+	return f, nil
+}
+
+var errFolderChanged = errors.New(reasonChanged)
+
+// dir sizes one folder and everything under it on the same filesystem, and
+// returns the bytes. st is the folder's own stat, taken when its parent was
+// read: its blocks are counted, and the folder opened must still be the one
+// it describes (openFolder). Names are read in batches and stat'd as read;
+// subfolders are walked after the folder is closed, so the walk holds one
+// open folder at a time however deep it goes.
+func (w *folderWalk) dir(p string, level int, st *syscall.Stat_t) int64 {
+	total := int64(st.Blocks) * 512
+	if w.expired() {
+		return total
+	}
+	if folderBeforeOpen != nil {
+		folderBeforeOpen(p)
+	}
+	f, err := openFolder(p, st)
+	if err != nil {
+		if errors.Is(err, errFolderChanged) {
+			w.skip(p, reasonChanged)
+		} else {
+			w.skip(p, folderSkipReason(err))
+		}
+		return total
+	}
+	var subdirs []string
+	var subSt []syscall.Stat_t
+	for !w.expired() {
+		ents, rerr := f.ReadDir(folderReadBatch)
+		for _, e := range ents {
+			child := childPath(p, e.Name())
+			if w.mounts[child] {
+				w.skip(child, reasonOtherFS)
+				continue
+			}
+			var st syscall.Stat_t
+			if err := syscall.Lstat(child, &st); err != nil {
+				// Gone between the read and the stat is churn, not a gap.
+				if !errors.Is(err, syscall.ENOENT) {
+					w.skip(p, folderSkipReason(err))
+				}
+				continue
+			}
+			size := int64(st.Blocks) * 512
+			if st.Mode&syscall.S_IFMT == syscall.S_IFDIR {
+				// The mount table is read once at the start; a mount made
+				// since is caught here by its device instead.
+				if uint64(st.Dev) != w.dev {
+					w.skip(child, reasonOtherFS)
+					continue
+				}
+				subdirs = append(subdirs, child)
+				subSt = append(subSt, st)
+				continue
+			}
+			if uint64(st.Nlink) > 1 && !w.firstLink(uint64(st.Ino)) {
+				continue
+			}
+			total += size
+		}
+		if rerr != nil {
+			if rerr != io.EOF {
+				w.skip(p, folderSkipReason(rerr))
+			}
+			break
+		}
+	}
+	_ = f.Close()
+	for i, c := range subdirs {
+		if w.expired() {
+			break
+		}
+		total += w.dir(c, level+1, &subSt[i])
+	}
+	if level >= 1 && level <= w.depth {
+		w.sized++
+		w.top.offer(folderSize{Path: p, Bytes: total, Depth: level})
+	}
+	return total
+}
+
+// readFolders sizes the folders under asked. The error is a refusal: a path
+// that is not a folder here, or whose links lead into a kernel tree.
+//
+// All of it, the path's resolution included, runs on its own goroutine, so
+// the answer goes out at the op budget even when one call never returns: a
+// stat of a dead network mount named as the path, or a disk erroring slowly
+// under it. That goroutine owns everything it touches; on the stuck path this
+// function reads nothing of it and answers without it. Such a walk is counted
+// until it returns, and past folderStuckMax of them no walk starts.
+func readFolders(asked string, depth int) (foldersReport, error) {
+	stuck := func(partial, note string) foldersReport {
+		return foldersReport{Supported: true, Path: asked, Depth: depth, Folders: []folderSize{},
+			Skipped: []folderSkip{}, Partial: partial, Note: note}
+	}
+	if folderWalksStuck.Load() >= folderStuckMax {
+		return stuck("earlier reads on this machine have not returned",
+			"nothing was sized: "+strconv.Itoa(folderStuckMax)+" earlier walks are still inside a read that "+
+				"has not returned (a network mount that stopped answering, most often); try again once it answers"), nil
+	}
+	ctx, cancel := opBudget()
+	defer cancel()
+	type result struct {
+		rep foldersReport
+		err error
+	}
+	// 0 running, 1 returned, 2 answered without: whichever side moves it
+	// from 0 first decides whether the walk holds a place in folderWalksStuck.
+	var state atomic.Int32
+	done := make(chan result, 1)
+	go func() {
+		rep, err := folderSizer(ctx, asked, depth)
+		done <- result{rep, err}
+		if !state.CompareAndSwap(0, 1) {
+			folderWalksStuck.Add(-1)
+		}
+	}()
+	select {
+	case r := <-done:
+		return r.rep, r.err
+	case <-ctx.Done():
+		select {
+		case r := <-done:
+			return r.rep, r.err
+		case <-time.After(folderStuckGrace):
+			if !state.CompareAndSwap(0, 2) {
+				r := <-done
+				return r.rep, r.err
+			}
+			folderWalksStuck.Add(1)
+			return stuck("a read under this path did not return inside the op budget",
+				"nothing was sized; ask about a folder further down, or try again"), nil
+		}
+	}
+}
+
+func sizeFolders(ctx context.Context, asked string, depth int) (foldersReport, error) {
+	resolved, err := filepath.EvalSymlinks(asked)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return foldersReport{}, errors.New("there is no folder at that path on this machine")
+		}
+		return foldersReport{}, errors.New("that path cannot be read: " + folderSkipReason(err))
+	}
+	if err := folderPathAllowed(resolved); err != nil {
+		return foldersReport{}, err
+	}
+	var st syscall.Stat_t
+	if err := syscall.Lstat(resolved, &st); err != nil {
+		return foldersReport{}, errors.New("that path cannot be read: " + folderSkipReason(err))
+	}
+	if st.Mode&syscall.S_IFMT != syscall.S_IFDIR {
+		return foldersReport{}, errors.New("that path is not a folder")
+	}
+	rep := foldersReport{Supported: true, Path: asked, Depth: depth}
+	if resolved != asked {
+		rep.Resolved = resolved
+	}
+	mounts := map[string]bool{}
+	if b, err := os.ReadFile("/proc/self/mountinfo"); err == nil {
+		mounts = parseMountPoints(string(b))
+	}
+	w := &folderWalk{ctx: ctx, root: resolved, depth: depth, dev: uint64(st.Dev), mounts: mounts,
+		linked: map[uint64]struct{}{}}
+	rep.TotalBytes = w.dir(resolved, 0, &st)
+	rep.Folders = w.top.sorted()
+	rep.Sized = w.sized
+	rep.Skipped = w.skips.list()
+	rep.SkippedTotal = w.skips.total
+	rep.Complete = !w.cut
+	if w.cut {
+		rep.Partial = "timeout"
+		rep.Note = "the walk ran out of time: every size is at least what is shown, and a folder it never reached is missing"
+	}
+	if w.linkFull {
+		rep.Note = strings.TrimSpace(rep.Note + " More than " + strconv.Itoa(folderLinkCap) +
+			" hard-linked files: past that each link was counted, so sizes may read high.")
+	}
+	return rep, nil
+}
+
+// ── observe:journal ──────────────────────────────────────────────────────────
+
+// readJournal reads one unit's recent journal. The unit has passed
+// normalizeUnitName; the error is a refusal when this machine has no such
+// unit, and every other gap is a reported reason.
+func readJournal(unit string, minutes int) (journalReport, error) {
+	rep := journalReport{Source: "journal", Unit: unit, Minutes: minutes}
+	if !observeHave("journalctl") {
+		rep.Reason = "journalctl not installed"
+		return rep, nil
+	}
+	if !observeHave("systemctl") {
+		rep.Reason = "systemctl not installed, so this machine cannot say which units it has"
+		return rep, nil
+	}
+	if why := observeJournalAccess(); why != "" {
+		rep.Reason = why
+		return rep, nil
+	}
+	ctx, cancel := opBudget()
+	defer cancel()
+	// list-units is observe:units' read with --all for --failed: every unit
+	// systemd has loaded. A failed run is not an empty list here either —
+	// it would refuse every unit as unknown — so its error is checked.
+	listed, lerr := observeExec(ctx, "systemctl", "list-units", "--all", "--no-legend", "--plain")
+	if ctx.Err() != nil {
+		rep.Reason = "systemctl list-units: timeout"
+		return rep, nil
+	}
+	if lerr != nil && len(listed) == 0 {
+		rep.Reason = "systemctl list-units: " + lerr.Error()
+		return rep, nil
+	}
+	// The same for list-unit-files: without it an installed unit that is not
+	// loaded right now would be refused as one this machine does not have.
+	files, ferr := observeExec(ctx, "systemctl", "list-unit-files", "--no-legend", "--plain")
+	if ctx.Err() != nil {
+		rep.Reason = "systemctl list-unit-files: timeout"
+		return rep, nil
+	}
+	if ferr != nil && len(files) == 0 {
+		rep.Reason = "systemctl list-unit-files: " + ferr.Error()
+		return rep, nil
+	}
+	loaded, installed := parseUnitList(string(listed)), parseUnitFiles(string(files))
+	if !unitKnown(unit, loaded, installed) {
+		return journalReport{}, errUnknownUnit(unit, loaded, installed)
+	}
+	// Bound to their flags with '=', so neither can be read as a flag of its
+	// own whatever it held. --lines is observeLogLineLimit, the line limit
+	// observe:logs asks Loki for: the newest 5000 lines in the window.
+	unitArg := "--unit=" + unit
+	sinceArg := "--since=-" + strconv.Itoa(minutes) + "min"
+	out, err := observeExec(ctx, "journalctl", unitArg, sinceArg, "-o", "short-iso", "--no-pager", "-q", "--lines=5000")
+	if ctx.Err() != nil {
+		rep.Partial = "journalctl: timeout"
+	} else if err != nil && len(out) == 0 {
+		rep.Reason = "journalctl: " + err.Error()
+		return rep, nil
+	}
+	rep.Supported = true
+	rep.Log, rep.Truncated = capLines(string(out), observeLogLineLimit, observeTextCap)
+	if strings.TrimSpace(rep.Log) != "" {
+		rep.Lines = strings.Count(strings.TrimRight(rep.Log, "\n"), "\n") + 1
+	} else {
+		rep.Log = ""
+		rep.Note = "no lines from " + unit + " in the last " + strconv.Itoa(minutes) + " minutes"
+	}
+	return rep, nil
+}
+
+// ── observe:logins ───────────────────────────────────────────────────────────
+
+// readLogins counts sshd's logins over the window. sshd is matched two ways,
+// either one enough ("+" is journalctl's OR): by program — sshd, and the
+// sshd-session and sshd-auth processes newer OpenSSH splits it into — and by
+// unit, ssh.service on Debian and Ubuntu, sshd.service elsewhere. --lines is
+// loginsLineCap.
+//
+// Each match also needs _UID=0. Any account can run a program named sshd and
+// log under _COMM=sshd, and one whose shell stays in ssh.service's cgroup (no
+// pam_systemd) logs under that unit; either could add failures or accepted
+// logins, or bury the real ones under 50,000 lines. _UID is journald's own,
+// from the sender's credentials, and every message parsed here is written by
+// sshd's root monitor (OpenSSH sends its unprivileged child's lines through
+// it). A sshd run by an ordinary account is not read.
+func readLogins(hours int) loginsReport {
+	rep := loginsReport{Source: "journal", Hours: hours, FailedTotal: -1, AcceptedTotal: -1,
+		FailedBySource: []loginSource{}, FailedByUser: []loginUser{}, Accepted: []acceptedLogin{}}
+	if !observeHave("journalctl") {
+		rep.Reason = "journalctl not installed"
+		return rep
+	}
+	if why := observeJournalAccess(); why != "" {
+		rep.Reason = why
+		return rep
+	}
+	ctx, cancel := opBudget()
+	defer cancel()
+	sinceArg := "--since=-" + strconv.Itoa(hours) + "h"
+	out, err := observeExec(ctx, "journalctl", sinceArg, "-o", "short-iso", "--no-pager", "-q", "--lines=50000",
+		"_COMM=sshd", "_COMM=sshd-session", "_COMM=sshd-auth", "_UID=0",
+		"+", "_SYSTEMD_UNIT=ssh.service", "_SYSTEMD_UNIT=sshd.service", "_UID=0")
+	late := ctx.Err() != nil
+	if !late && err != nil && len(out) == 0 {
+		rep.Reason = "journalctl: " + err.Error()
+		return rep
+	}
+	t := parseSSHLogins(string(out))
+	rep.Supported = true
+	t.fill(&rep)
+	rep.Truncated = t.entries >= loginsLineCap
+	if late {
+		rep.Partial = "journalctl: timeout"
+	}
+	if t.entries == 0 {
+		rep.Note = "no sshd entries in the journal in the last " + strconv.Itoa(hours) + " hours"
+	}
+	return rep
+}
+
+// ── observe:cert ─────────────────────────────────────────────────────────────
+
+// readCert reads the certificate this machine's listener on port serves. The
+// listener table is observe:sockets' own read (ss -tlnpH); the error is a
+// refusal when nothing listens on the port.
+func readCert(port int, name string) (certReport, error) {
+	rep := certReport{Port: port, ServerName: name, Listening: []string{}, Tried: []string{},
+		CheckedAt: time.Now().UTC().Format(time.RFC3339)}
+	if !observeHave("ss") {
+		rep.Reason = "ss not installed, so this machine cannot say which ports it listens on"
+		return rep, nil
+	}
+	ctx, cancel := opBudget()
+	defer cancel()
+	out, err := observeExec(ctx, "ss", "-tlnpH")
+	// A failed ss is not an empty table (readSockets says why): here an empty
+	// table would refuse every port as not listening.
+	if ctx.Err() != nil {
+		rep.Reason = "ss: timeout"
+		return rep, nil
+	}
+	if err != nil {
+		rep.Reason = "ss: " + err.Error()
+		return rep, nil
+	}
+	targets, listening := certTargets(parseSS("tcp", string(out)), port, observeOwnAddrs())
+	if len(listening) == 0 {
+		return certReport{}, errors.New("nothing on this machine listens on tcp port " + strconv.Itoa(port))
+	}
+	rep.Supported = true
+	rep.Listening = listening
+	dialCert(ctx, &rep, targets, name)
+	return rep, nil
+}

client-go/observe_reads_linux_test.go

@@ -0,0 +1,711 @@
+//go:build linux
+
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"net/netip"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"syscall"
+	"testing"
+	"time"
+)
+
+// stubObserveReads puts every exec of the four ops behind answer and records
+// each argv, joined by spaces, in the order run. Every tool is present and
+// the journal readable unless a test says otherwise.
+func stubObserveReads(t *testing.T, answer func(argv string) ([]byte, error)) func() []string {
+	t.Helper()
+	var mu sync.Mutex
+	var recorded []string
+	origExec, origHave, origAccess, origOwn := observeExec, observeHave, observeJournalAccess, observeOwnAddrs
+	observeExec = func(_ context.Context, name string, args ...string) ([]byte, error) {
+		argv := strings.Join(append([]string{name}, args...), " ")
+		mu.Lock()
+		recorded = append(recorded, argv)
+		mu.Unlock()
+		return answer(argv)
+	}
+	observeHave = func(string) bool { return true }
+	observeJournalAccess = func() string { return "" }
+	t.Cleanup(func() {
+		observeExec, observeHave, observeJournalAccess, observeOwnAddrs = origExec, origHave, origAccess, origOwn
+	})
+	return func() []string {
+		mu.Lock()
+		defer mu.Unlock()
+		out := append([]string(nil), recorded...)
+		recorded = nil
+		return out
+	}
+}
+
+func unitAnswers(journal string) func(string) ([]byte, error) {
+	return func(argv string) ([]byte, error) {
+		switch {
+		case strings.HasPrefix(argv, "systemctl list-units "):
+			return []byte(fxListUnits), nil
+		case strings.HasPrefix(argv, "systemctl list-unit-files "):
+			return []byte(fxUnitFiles), nil
+		case strings.HasPrefix(argv, "journalctl "):
+			return []byte(journal), nil
+		}
+		return nil, errors.New("unexpected " + argv)
+	}
+}
+
+// ── observe:journal ──────────────────────────────────────────────────────────
+
+// observe:journal runs exactly three argvs, and the unit reaches the third
+// only as a name this machine's own lists hold, bound to --unit=.
+func TestObserveJournalRunsOnlyItsPinnedArgv(t *testing.T) {
+	log := "2026-10-29T10:00:00+00:00 box-a example[42]: started\n" +
+		"2026-10-29T10:00:05+00:00 box-a example[42]: listening on 8080\n"
+	recorded := stubObserveReads(t, unitAnswers(log))
+	out, errOut, code := driveObserve(t, "observe:journal", []string{"example", "5"})
+	if code != 0 {
+		t.Fatalf("exit %d: %s", code, errOut)
+	}
+	want := []string{
+		"systemctl list-units --all --no-legend --plain",
+		"systemctl list-unit-files --no-legend --plain",
+		"journalctl --unit=example.service --since=-5min -o short-iso --no-pager -q --lines=" +
+			strconv.Itoa(observeLogLineLimit),
+	}
+	if got := recorded(); strings.Join(got, "\n") != strings.Join(want, "\n") {
+		t.Fatalf("argvs\n got: %q\nwant: %q", got, want)
+	}
+	var rep journalReport
+	if err := json.Unmarshal([]byte(out), &rep); err != nil {
+		t.Fatalf("%v: %s", err, out)
+	}
+	if !rep.Supported || rep.Unit != "example.service" || rep.Minutes != 5 || rep.Lines != 2 || rep.Truncated ||
+		!strings.HasSuffix(rep.Log, "listening on 8080") || rep.Note != "" || rep.Source != "journal" {
+		t.Fatalf("%+v", rep)
+	}
+
+	// Installed and unloaded since, and an instance of an installed template:
+	// both are this machine's units.
+	for unit, want := range map[string]string{"report": "--unit=report.service", "worker@3": "--unit=worker@3.service"} {
+		if _, errOut, code := driveObserve(t, "observe:journal", []string{unit}); code != 0 {
+			t.Fatalf("%s: exit %d %s", unit, code, errOut)
+		}
+		got := recorded()
+		if len(got) != 3 || !strings.HasPrefix(got[2], "journalctl "+want+" --since=-15min ") {
+			t.Fatalf("%s: %q", unit, got)
+		}
+	}
+
+	// A unit this machine does not have, or knows only as not-found, is
+	// refused before journalctl runs, and the refusal names the near ones.
+	for unit, hint := range map[string]string{"ssh": "ssh.socket", "gone": "no unit gone.service"} {
+		_, errOut, code := driveObserve(t, "observe:journal", []string{unit})
+		if code != 2 || !strings.Contains(errOut, "refused: this machine has no unit") || !strings.Contains(errOut, hint) {
+			t.Fatalf("%s: code=%d err=%q", unit, code, errOut)
+		}
+		for _, argv := range recorded() {
+			if strings.HasPrefix(argv, "journalctl") {
+				t.Fatalf("%s: journalctl ran for a unit this machine does not have: %q", unit, argv)
+			}
+		}
+	}
+}
+
+func TestObserveJournalSaysWhyItCannotAnswer(t *testing.T) {
+	recorded := stubObserveReads(t, unitAnswers(""))
+	// Empty: a note that names the unit and the window.
+	out, _, code := driveObserve(t, "observe:journal", []string{"example.service", "1"})
+	var rep journalReport
+	_ = json.Unmarshal([]byte(out), &rep)
+	if code != 0 || !rep.Supported || rep.Lines != 0 || rep.Log != "" ||
+		rep.Note != "no lines from example.service in the last 1 minutes" {
+		t.Fatalf("empty: %d %+v", code, rep)
+	}
+	recorded()
+
+	// An account that cannot read the system journal: said, at exit 0, and
+	// nothing is run — journalctl would show that account's own lines only.
+	observeJournalAccess = func() string { return "cannot read the system journal" }
+	out, _, code = driveObserve(t, "observe:journal", []string{"example"})
+	rep = journalReport{}
+	_ = json.Unmarshal([]byte(out), &rep)
+	if code != 0 || rep.Supported || rep.Reason != "cannot read the system journal" || len(recorded()) != 0 {
+		t.Fatalf("no access: %d %+v", code, rep)
+	}
+	observeJournalAccess = func() string { return "" }
+
+	// A list-units that failed is not an empty list: every unit would be
+	// refused as unknown.
+	observeExec = func(_ context.Context, name string, args ...string) ([]byte, error) {
+		return nil, errors.New("exit status 1")
+	}
+	out, _, code = driveObserve(t, "observe:journal", []string{"example"})
+	rep = journalReport{}
+	_ = json.Unmarshal([]byte(out), &rep)
+	if code != 0 || rep.Supported || !strings.Contains(rep.Reason, "systemctl list-units: exit status 1") {
+		t.Fatalf("failed list: %d %+v", code, rep)
+	}
+	// And a failed list-unit-files: an installed unit that is not loaded now
+	// would otherwise be refused as one this machine does not have.
+	observeExec = func(_ context.Context, name string, args ...string) ([]byte, error) {
+		if args[0] == "list-units" {
+			return []byte(fxListUnits), nil
+		}
+		return nil, errors.New("exit status 1")
+	}
+	out, _, code = driveObserve(t, "observe:journal", []string{"report"})
+	rep = journalReport{}
+	_ = json.Unmarshal([]byte(out), &rep)
+	if code != 0 || rep.Supported || !strings.Contains(rep.Reason, "systemctl list-unit-files: exit status 1") {
+		t.Fatalf("failed unit files: %d %+v", code, rep)
+	}
+}
+
+// ── observe:logins ───────────────────────────────────────────────────────────
+
+func TestObserveLoginsRunsItsPinnedArgv(t *testing.T) {
+	recorded := stubObserveReads(t, func(argv string) ([]byte, error) { return []byte(fxSSHD), nil })
+	out, errOut, code := driveObserve(t, "observe:logins", []string{"48"})
+	if code != 0 {
+		t.Fatalf("exit %d: %s", code, errOut)
+	}
+	want := "journalctl --since=-48h -o short-iso --no-pager -q --lines=" + strconv.Itoa(loginsLineCap) +
+		" _COMM=sshd _COMM=sshd-session _COMM=sshd-auth _UID=0 + _SYSTEMD_UNIT=ssh.service _SYSTEMD_UNIT=sshd.service _UID=0"
+	if got := recorded(); len(got) != 1 || got[0] != want {
+		t.Fatalf("argv\n got: %q\nwant: %q", got, want)
+	}
+	var rep loginsReport
+	if err := json.Unmarshal([]byte(out), &rep); err != nil {
+		t.Fatalf("%v: %s", err, out)
+	}
+	if !rep.Supported || rep.Hours != 48 || rep.FailedTotal != 8 || rep.FailedSources != 5 || rep.AcceptedTotal != 2 ||
+		rep.EntriesRead != 16 || rep.Truncated || rep.Note != "" || rep.OldestEntry != "2026-10-29T10:00:01Z" {
+		t.Fatalf("%+v", rep)
+	}
+	if _, _, code := driveObserve(t, "observe:logins", nil); code != 0 || !strings.HasPrefix(recorded()[0], "journalctl --since=-24h ") {
+		t.Fatalf("the default window is 24 hours")
+	}
+
+	// No journal access: unknown, not zero.
+	observeJournalAccess = func() string { return "cannot read the system journal" }
+	out, _, code = driveObserve(t, "observe:logins", nil)
+	rep = loginsReport{}
+	_ = json.Unmarshal([]byte(out), &rep)
+	if code != 0 || rep.Supported || rep.FailedTotal != -1 || rep.AcceptedTotal != -1 || len(recorded()) != 0 {
+		t.Fatalf("no access must read unknown (-1), never 0: %d %+v", code, rep)
+	}
+	observeJournalAccess = func() string { return "" }
+
+	// Nothing logged: zeros, and a note that says which window was empty.
+	observeExec = func(context.Context, string, ...string) ([]byte, error) { return nil, nil }
+	out, _, _ = driveObserve(t, "observe:logins", []string{"1"})
+	rep = loginsReport{}
+	_ = json.Unmarshal([]byte(out), &rep)
+	if !rep.Supported || rep.FailedTotal != 0 || rep.Note != "no sshd entries in the journal in the last 1 hours" ||
+		rep.FailedBySource == nil || rep.Accepted == nil {
+		t.Fatalf("empty: %+v", rep)
+	}
+}
+
+// Any account can name a process sshd (copy a logger, call it sshd) and
+// write lines journald files under _COMM=sshd, and an account whose shell
+// stays in ssh.service's cgroup (no pam_systemd) writes under that unit. Only
+// root's lines count: every message this op reads is the root monitor's
+// (OpenSSH logs its unprivileged child through it), and _UID is journald's
+// own, from the sender's credentials. Each disjunct carries _UID=0, so no
+// match reads a non-root line.
+func TestObserveLoginsCountsOnlyRootsSSHDLines(t *testing.T) {
+	recorded := stubObserveReads(t, func(string) ([]byte, error) { return nil, nil })
+	if _, errOut, code := driveObserve(t, "observe:logins", nil); code != 0 {
+		t.Fatalf("exit %d: %s", code, errOut)
+	}
+	got := recorded()
+	if len(got) != 1 {
+		t.Fatalf("%q", got)
+	}
+	f := strings.Fields(got[0])
+	start := 0
+	for i, a := range f {
+		if strings.HasPrefix(a, "--lines=") {
+			start = i + 1
+		}
+	}
+	if start == 0 || start >= len(f) {
+		t.Fatalf("no matches after --lines: %q", got[0])
+	}
+	var groups [][]string
+	cur := []string{}
+	for _, a := range f[start:] {
+		if a == "+" {
+			groups, cur = append(groups, cur), []string{}
+			continue
+		}
+		cur = append(cur, a)
+	}
+	groups = append(groups, cur)
+	for _, g := range groups {
+		uid := false
+		for _, a := range g {
+			uid = uid || a == "_UID=0"
+		}
+		if !uid {
+			t.Fatalf("a match reads lines any account can write: %q in %q", g, got[0])
+		}
+	}
+}
+
+// ── observe:cert ─────────────────────────────────────────────────────────────
+
+func ssLine(local string, port int) string {
+	return "LISTEN 0      4096       " + local + ":" + strconv.Itoa(port) + "   0.0.0.0:* users:((\"example\",pid=10,fd=3))\n"
+}
+
+// The port must be one this machine listens on, the listener table is ss's,
+// and the handshake goes to loopback or this machine's own addresses only.
+func TestObserveCertReadsOnlyThisMachinesListener(t *testing.T) {
+	cert := observeTestCert(t, "box-a.example", []string{"box-a.example"}, nil, time.Now().Add(10*24*time.Hour+time.Hour))
+	port := observeTLSListener(t, cert)
+	foreign := closedPort(t)
+	ss := ssLine("127.0.0.1", port) + ssLine("192.0.2.50", foreign)
+	recorded := stubObserveReads(t, func(argv string) ([]byte, error) {
+		if argv == "ss -tlnpH" {
+			return []byte(ss), nil
+		}
+		return nil, errors.New("unexpected " + argv)
+	})
+	observeOwnAddrs = func() map[netip.Addr]bool { return map[netip.Addr]bool{netip.MustParseAddr("127.0.0.1"): true} }
+
+	out, errOut, code := driveObserve(t, "observe:cert", []string{strconv.Itoa(port), "box-a.example"})
+	if code != 0 {
+		t.Fatalf("exit %d: %s", code, errOut)
+	}
+	if got := recorded(); len(got) != 1 || got[0] != "ss -tlnpH" {
+		t.Fatalf("the one argv is observe:sockets' tcp read: %q", got)
+	}
+	var rep certReport
+	if err := json.Unmarshal([]byte(out), &rep); err != nil {
+		t.Fatalf("%v: %s", err, out)
+	}
+	if !rep.Supported || rep.ConnectedTo != "127.0.0.1:"+strconv.Itoa(port) || !rep.TLS || rep.ServerName != "box-a.example" ||
+		len(rep.Listening) != 1 || rep.Listening[0] != "127.0.0.1" || rep.DaysLeft == nil || *rep.DaysLeft != 10 ||
+		rep.ChainVerified == nil || *rep.ChainVerified || rep.CheckedAt == "" {
+		t.Fatalf("%s", out)
+	}
+
+	// Nothing listens: refused, and nothing dialled.
+	_, errOut, code = driveObserve(t, "observe:cert", []string{"1"})
+	if code != 2 || !strings.Contains(errOut, "refused: nothing on this machine listens on tcp port 1") {
+		t.Fatalf("code=%d err=%q", code, errOut)
+	}
+
+	// A listener bound to an address this machine does not hold: loopback is
+	// tried and the other address never is — it would reach another machine.
+	out, _, code = driveObserve(t, "observe:cert", []string{strconv.Itoa(foreign)})
+	rep = certReport{}
+	_ = json.Unmarshal([]byte(out), &rep)
+	if code != 0 || !rep.Supported || rep.ConnectedTo != "" || len(rep.Tried) != 2 || rep.TLS {
+		t.Fatalf("%d %s", code, out)
+	}
+	for _, tried := range rep.Tried {
+		if strings.Contains(tried, "192.0.2.50") {
+			t.Fatalf("dialled an address this machine does not hold: %v", rep.Tried)
+		}
+	}
+
+	// A failed ss is not an empty table: it says so instead of refusing.
+	observeExec = func(context.Context, string, ...string) ([]byte, error) { return nil, errors.New("exit status 1") }
+	out, _, code = driveObserve(t, "observe:cert", []string{strconv.Itoa(port)})
+	rep = certReport{}
+	_ = json.Unmarshal([]byte(out), &rep)
+	if code != 0 || rep.Supported || rep.Reason != "ss: exit status 1" {
+		t.Fatalf("%d %s", code, out)
+	}
+}
+
+// ── observe:folders ──────────────────────────────────────────────────────────
+
+func writeFile(t *testing.T, p string, n int) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(p, bytes.Repeat([]byte("x"), n), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// folderTree is a tree with a nested chain, a folder with one file linked
+// twice, a file linked from a second folder, and an empty folder.
+func folderTree(t *testing.T) string {
+	t.Helper()
+	root := t.TempDir()
+	writeFile(t, root+"/a/a1", 64<<10)
+	writeFile(t, root+"/a/b/b1", 32<<10)
+	writeFile(t, root+"/a/b/c/c1", 16<<10)
+	writeFile(t, root+"/a/b/c/d/d1", 8<<10)
+	writeFile(t, root+"/big/big1", 256<<10)
+	if err := os.Link(root+"/big/big1", root+"/big/big1-again"); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.MkdirAll(root+"/empty", 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return root
+}
+
+func blocksOf(t *testing.T, p string) int64 {
+	t.Helper()
+	var st syscall.Stat_t
+	if err := syscall.Lstat(p, &st); err != nil {
+		t.Fatal(err)
+	}
+	return int64(st.Blocks) * 512
+}
+
+func TestObserveFoldersSizesTheTree(t *testing.T) {
+	root := folderTree(t)
+	rep, err := readFolders(root, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !rep.Supported || !rep.Complete || rep.Partial != "" || rep.Path != root || rep.Resolved != "" || rep.Depth != 2 {
+		t.Fatalf("%+v", rep)
+	}
+	// What is expected, from the blocks of each thing: big1 once, though two
+	// names link it.
+	dirs := func(ps ...string) (n int64) {
+		for _, p := range ps {
+			n += blocksOf(t, p)
+		}
+		return n
+	}
+	c := dirs(root+"/a/b/c", root+"/a/b/c/c1", root+"/a/b/c/d", root+"/a/b/c/d/d1")
+	b := dirs(root+"/a/b", root+"/a/b/b1") + c
+	a := dirs(root+"/a", root+"/a/a1") + b
+	bigd := dirs(root+"/big", root+"/big/big1")
+	empty := dirs(root + "/empty")
+	want := map[string]int64{root + "/a": a, root + "/a/b": b, root + "/big": bigd, root + "/empty": empty}
+	if rep.Sized != len(want) || len(rep.Folders) != len(want) {
+		t.Fatalf("depth 2 sizes the folders at 1 and 2 below the path: %+v", rep.Folders)
+	}
+	for _, f := range rep.Folders {
+		if want[f.Path] != f.Bytes {
+			t.Fatalf("%s: %d, want %d", f.Path, f.Bytes, want[f.Path])
+		}
+		if f.Depth != strings.Count(strings.TrimPrefix(f.Path, root), "/") {
+			t.Fatalf("depth of %s: %d", f.Path, f.Depth)
+		}
+		if strings.Contains(f.Path, "/a/b/c") {
+			t.Fatalf("a folder below the depth was named: %s", f.Path)
+		}
+	}
+	if rep.TotalBytes != blocksOf(t, root)+a+bigd+empty {
+		t.Fatalf("total %d", rep.TotalBytes)
+	}
+	if rep.Folders[0].Path != root+"/big" && rep.Folders[0].Path != root+"/a" {
+		t.Fatalf("largest first: %+v", rep.Folders)
+	}
+	// Only folders: no file name anywhere in the answer.
+	raw, _ := json.Marshal(rep)
+	for _, file := range []string{"a1", "b1", "c1", "d1", "big1"} {
+		if strings.Contains(string(raw), "/"+file) {
+			t.Fatalf("a file name reached the answer: %s", raw)
+		}
+	}
+
+	// Through a symlink: sized where it leads, and said so.
+	link := filepath.Join(t.TempDir(), "link")
+	if err := os.Symlink(root, link); err != nil {
+		t.Fatal(err)
+	}
+	rep, err = readFolders(link, 1)
+	if err != nil || rep.Resolved != root || rep.Path != link || rep.Sized != 3 {
+		t.Fatalf("%v %+v", err, rep)
+	}
+}
+
+// The same tree measured by du: the op's numbers are du -x's, folder for
+// folder. Skipped where there is no GNU du to ask.
+func TestObserveFoldersAgreesWithDu(t *testing.T) {
+	if _, err := exec.LookPath("du"); err != nil {
+		t.Skip("no du here")
+	}
+	root := folderTree(t)
+	out, err := exec.Command("du", "-x", "-B1", "--max-depth=2", root).Output()
+	if err != nil {
+		t.Skipf("not a du that takes -B1 --max-depth: %v", err)
+	}
+	du := map[string]int64{}
+	for _, l := range strings.Split(strings.TrimSpace(string(out)), "\n") {
+		n, p, _ := strings.Cut(l, "\t")
+		du[p], _ = strconv.ParseInt(n, 10, 64)
+	}
+	rep, err := readFolders(root, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rep.TotalBytes != du[root] {
+		t.Fatalf("total %d, du %d", rep.TotalBytes, du[root])
+	}
+	for _, f := range rep.Folders {
+		if du[f.Path] != f.Bytes {
+			t.Fatalf("%s: %d, du %d", f.Path, f.Bytes, du[f.Path])
+		}
+	}
+}
+
+// A mount point under the path is not crossed and not stat'd, and is
+// reported against the folder at the asked depth that holds it.
+func TestObserveFoldersDoesNotCrossAMount(t *testing.T) {
+	root := folderTree(t)
+	var st syscall.Stat_t
+	if err := syscall.Lstat(root, &st); err != nil {
+		t.Fatal(err)
+	}
+	walk := func(depth int, mounts ...string) *folderWalk {
+		w := &folderWalk{ctx: context.Background(), root: root, depth: depth, dev: uint64(st.Dev),
+			mounts: map[string]bool{}, linked: map[uint64]struct{}{}}
+		for _, m := range mounts {
+			w.mounts[m] = true
+		}
+		w.dir(root, 0, &st)
+		return w
+	}
+	w := walk(2, root+"/a/b")
+	for _, f := range w.top.sorted() {
+		if f.Path == root+"/a/b" {
+			t.Fatalf("a mount point was sized: %+v", f)
+		}
+		if f.Path == root+"/a" && f.Bytes != blocksOf(t, root+"/a")+blocksOf(t, root+"/a/a1") {
+			t.Fatalf("what is under the mount was counted: %+v", f)
+		}
+	}
+	if l := w.skips.list(); len(l) != 1 || l[0].Path != root+"/a/b" || l[0].Reason != reasonOtherFS || l[0].Count != 1 {
+		t.Fatalf("%+v", l)
+	}
+	w = walk(1, root+"/a/b/c/d")
+	if l := w.skips.list(); len(l) != 1 || l[0].Path != root+"/a" {
+		t.Fatalf("a deep skip is named by its folder at the asked depth: %+v", l)
+	}
+	// A different device on a folder, as a mount made after the table was
+	// read looks: not crossed either.
+	w = &folderWalk{ctx: context.Background(), root: root, depth: 2, dev: uint64(st.Dev) + 1,
+		mounts: map[string]bool{}, linked: map[uint64]struct{}{}}
+	w.dir(root, 0, &st)
+	if w.sized != 0 || w.skips.total != 3 {
+		t.Fatalf("every subfolder is on another device here: sized %d skipped %d", w.sized, w.skips.total)
+	}
+}
+
+// A folder swapped for a link between the walk's stat and its open, or one
+// reached through a folder above it that was, is not read: the walk reads
+// only the folder it stat'd, so a link can never lead it elsewhere, onto
+// another filesystem or into /proc. Here elsewhere is on the same filesystem,
+// so the device alone would not tell; the inode does.
+func TestObserveFoldersReadsOnlyTheFolderItStatd(t *testing.T) {
+	for _, tc := range []struct{ name, swap string }{
+		{"the folder itself", "/a/b"},
+		{"a folder above it", "/a"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			root := folderTree(t)
+			elsewhere := t.TempDir()
+			writeFile(t, elsewhere+"/b/elsewhere1", 4<<20)
+			target := elsewhere
+			if tc.swap == "/a/b" {
+				target = elsewhere + "/b"
+			}
+			orig := folderBeforeOpen
+			t.Cleanup(func() { folderBeforeOpen = orig })
+			folderBeforeOpen = func(p string) {
+				if p != root+"/a/b" {
+					return
+				}
+				if err := os.Rename(root+tc.swap, root+tc.swap+".moved"); err != nil {
+					t.Error(err)
+				}
+				if err := os.Symlink(target, root+tc.swap); err != nil {
+					t.Error(err)
+				}
+			}
+			rep, err := readFolders(root, 3)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if rep.TotalBytes >= 4<<20 {
+				t.Fatalf("the walk read a folder it never stat'd: total %d, %+v", rep.TotalBytes, rep.Folders)
+			}
+			for _, f := range rep.Folders {
+				if f.Bytes >= 4<<20 {
+					t.Fatalf("the walk read a folder it never stat'd: %+v", f)
+				}
+			}
+			found := false
+			for _, s := range rep.Skipped {
+				found = found || (s.Path == root+"/a/b" && s.Reason == reasonChanged)
+			}
+			if !found {
+				t.Fatalf("the swapped folder is not said: %+v", rep.Skipped)
+			}
+		})
+	}
+}
+
+// A walk inside a read that never returns (a hard network mount that went
+// away) keeps its thread however long that read hangs. The op answers at the
+// budget either way, and past folderStuckMax such walks it starts no more, so
+// a Host asking again and again cannot pile threads up until the bastion can
+// start none. A walk that comes back frees its place.
+func TestObserveFoldersStartsNoWalkPastTheStuckOnes(t *testing.T) {
+	origSizer, origGrace, origBudget := folderSizer, folderStuckGrace, observeOpBudget
+	release := make(chan struct{})
+	var started atomic.Int32
+	folderSizer = func(context.Context, string, int) (foldersReport, error) {
+		started.Add(1)
+		<-release
+		return foldersReport{}, nil
+	}
+	folderStuckGrace, observeOpBudget = time.Millisecond, time.Millisecond
+	t.Cleanup(func() {
+		folderSizer, folderStuckGrace, observeOpBudget = origSizer, origGrace, origBudget
+	})
+	for i := 0; i < folderStuckMax+3; i++ {
+		rep, err := readFolders("/srv", 1)
+		if err != nil || rep.Partial == "" || len(rep.Folders) != 0 {
+			t.Fatalf("call %d: %v %+v", i, err, rep)
+		}
+	}
+	if n := started.Load(); n != folderStuckMax {
+		t.Fatalf("%d walks started behind reads that never returned; at most %d may", n, folderStuckMax)
+	}
+	close(release)
+	deadline := time.Now().Add(5 * time.Second)
+	for folderWalksStuck.Load() != 0 && time.Now().Before(deadline) {
+		time.Sleep(5 * time.Millisecond)
+	}
+	if n := folderWalksStuck.Load(); n != 0 {
+		t.Fatalf("walks that came back still hold %d places", n)
+	}
+	folderSizer = func(context.Context, string, int) (foldersReport, error) {
+		started.Add(1)
+		return foldersReport{Supported: true, Complete: true}, nil
+	}
+	observeOpBudget = time.Second
+	if rep, err := readFolders("/srv", 1); err != nil || !rep.Complete {
+		t.Fatalf("a walk once the stuck ones came back: %v %+v", err, rep)
+	}
+}
+
+func TestObserveFoldersRefusalsAndBudget(t *testing.T) {
+	root := folderTree(t)
+	for p, want := range map[string]string{
+		root + "/a/a1":      "not a folder",
+		root + "/missing":   "no folder at that path",
+		root + "/a/missing": "no folder at that path",
+	} {
+		if _, err := readFolders(p, 2); err == nil || !strings.Contains(err.Error(), want) {
+			t.Fatalf("%s: %v", p, err)
+		}
+	}
+	// A link into /proc is refused like /proc.
+	link := filepath.Join(t.TempDir(), "into-proc")
+	if err := os.Symlink("/proc/self", link); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := readFolders(link, 1); err == nil || err.Error() != errFolderKernelTree {
+		t.Fatalf("%v", err)
+	}
+	// Through the dispatcher: refused at exit 2 without the path.
+	_, errOut, code := driveObserve(t, "observe:folders", []string{root + "/a/a1"})
+	if code != 2 || !strings.Contains(errOut, "not a folder") || strings.Contains(errOut, root) {
+		t.Fatalf("code=%d err=%q", code, errOut)
+	}
+	// An unreadable folder is named in skipped. Root reads every folder, so
+	// this half runs as a user only.
+	if os.Geteuid() != 0 {
+		if err := os.Chmod(root+"/a/b", 0); err != nil {
+			t.Fatal(err)
+		}
+		defer os.Chmod(root+"/a/b", 0o755)
+		rep, err := readFolders(root, 1)
+		if err != nil || len(rep.Skipped) != 1 || rep.Skipped[0].Path != root+"/a" || rep.Skipped[0].Reason != "permission denied" {
+			t.Fatalf("%v %+v", err, rep.Skipped)
+		}
+		_ = os.Chmod(root+"/a/b", 0o755)
+	}
+	// Out of budget: an answer, marked incomplete, never a hang.
+	orig := observeOpBudget
+	observeOpBudget = time.Nanosecond
+	defer func() { observeOpBudget = orig }()
+	rep, err := readFolders(root, 2)
+	if err != nil || rep.Complete || rep.Partial != "timeout" || rep.Note == "" {
+		t.Fatalf("%v %+v", err, rep)
+	}
+}
+
+// Through the dispatcher, the answer is the report.
+func TestObserveFoldersThroughTheLane(t *testing.T) {
+	root := folderTree(t)
+	out, errOut, code := driveObserve(t, "observe:folders", []string{root, "1"})
+	if code != 0 {
+		t.Fatalf("exit %d: %s", code, errOut)
+	}
+	var rep foldersReport
+	if err := json.Unmarshal([]byte(out), &rep); err != nil {
+		t.Fatalf("%v: %s", err, out)
+	}
+	if !rep.Supported || rep.Depth != 1 || rep.Sized != 3 || len(rep.Folders) != 3 || !rep.Complete || rep.Skipped == nil {
+		t.Fatalf("%s", out)
+	}
+	for _, f := range rep.Folders {
+		if f.Depth != 1 {
+			t.Fatalf("depth 1 names only the folders directly under the path: %+v", f)
+		}
+	}
+}
+
+// The four against this machine, through the real dispatcher with the real
+// programs — the same switch as TestObserveLive. A machine without systemd
+// answers journal and logins with a reason, which is an answer.
+func TestObserveReadsLive(t *testing.T) {
+	if testing.Short() {
+		t.Skip("runs the real programs")
+	}
+	cert := observeTestCert(t, "box-a.example", []string{"box-a.example"}, nil, time.Now().Add(48*time.Hour))
+	port := strconv.Itoa(observeTLSListener(t, cert))
+	for _, c := range []struct {
+		op   string
+		args []string
+		want string
+	}{
+		{"observe:folders", []string{"/etc", "1"}, `"supported":true`},
+		{"observe:journal", []string{"systemd-journald", "5"}, `"source":"journal"`},
+		{"observe:logins", []string{"1"}, `"hours":1`},
+		{"observe:cert", []string{port, "box-a.example"}, `"connected_to":"127.0.0.1:` + port + `"`},
+	} {
+		// A machine without ss cannot say which ports it listens on, and the
+		// cert read answers that as its own state (CI's container has no ss).
+		if c.op == "observe:cert" {
+			if _, err := exec.LookPath("ss"); err != nil {
+				c.want = `"reason":"ss not installed`
+			}
+		}
+		out, errOut, code := driveObserve(t, c.op, c.args)
+		if code != 0 || !json.Valid([]byte(out)) || !strings.Contains(out, c.want) {
+			t.Fatalf("%s: exit %d %s %s", c.op, code, errOut, out)
+		}
+		if len(out) > 300 {
+			out = out[:300] + "…"
+		}
+		t.Logf("%s: %s", c.op, strings.TrimSpace(out))
+	}
+}

client-go/observe_reads_other.go

@@ -0,0 +1,15 @@
+//go:build !linux
+
+package main
+
+// observe:folders, observe:journal, observe:logins and observe:cert off Linux:
+// the handlers check the arguments the same way and answer
+// {"unsupported": "<goos>"}, as observe_ops_other.go's ops do. These are
+// never reached (the handlers ask observeHostSupported first) and exist so
+// the package builds.
+
+func journalAccess() string                { return "" }
+func readFolders(string, int) (any, error) { return observeUnsupported(), nil }
+func readJournal(string, int) (any, error) { return observeUnsupported(), nil }
+func readLogins(int) any                   { return observeUnsupported() }
+func readCert(int, string) (any, error)    { return observeUnsupported(), nil }

client-go/observe_reads_test.go

@@ -0,0 +1,625 @@
+package main
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/tls"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/json"
+	"math/big"
+	"net"
+	"net/netip"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+// ── fixtures ─────────────────────────────────────────────────────────────────
+// Invented, in the shapes the programs print: systemctl's --plain lists,
+// journalctl -o short-iso, /proc/self/mountinfo.
+
+const fxListUnits = `example.service                    loaded    active   running Example service
+backup-nightly.service             loaded    inactive dead    Nightly backup
+getty@tty1.service                 loaded    active   running Getty on tty1
+gone.service                       not-found inactive dead    gone.service
+dev-disk-by\x2dlabel-data.device   loaded    active   plugged /dev/disk/by-label/data
+`
+
+const fxUnitFiles = `example.service      enabled  enabled
+report.service       static   -
+worker@.service      static   -
+ssh.socket           enabled  enabled
+`
+
+// One connection per pid. The spoof line names an address inside the user
+// name; the last line's user name is a sentence; one line uses the older
+// offset format; the indented one is a continuation, not an entry.
+const fxSSHD = `2026-10-29T10:00:01+00:00 box-a sshd-session[1001]: Invalid user admin from 203.0.113.5 port 40001
+2026-10-29T10:00:02+00:00 box-a sshd-session[1001]: Failed password for invalid user admin from 203.0.113.5 port 40001 ssh2
+2026-10-29T10:00:03+00:00 box-a sshd-session[1001]: Failed password for invalid user admin from 203.0.113.5 port 40001 ssh2
+2026-10-29T10:00:04+00:00 box-a sshd-session[1001]: Connection closed by invalid user admin 203.0.113.5 port 40001 [preauth]
+2026-10-29T10:01:00+00:00 box-a sshd-session[1002]: Invalid user test from 203.0.113.6 port 40002
+2026-10-29T10:01:01+00:00 box-a sshd-session[1002]: Connection closed by invalid user test 203.0.113.6 port 40002 [preauth]
+2026-10-29T10:02:00+00:00 box-a sshd-session[1003]: Failed password for root from 203.0.113.5 port 40003 ssh2
+2026-10-29T10:02:01+00:00 box-a sshd-session[1003]: pam_unix(sshd:auth): authentication failure; logname= uid=0 euid=0 tty=ssh ruser= rhost=203.0.113.5  user=root
+2026-10-29T10:03:00+00:00 box-a sshd-session[1004]: Connection closed by authenticating user root 198.51.100.7 port 40004 [preauth]
+2026-10-29T10:04:00+00:00 box-a sshd-session[1005]: Accepted publickey for box-admin from 192.0.2.10 port 50000 ssh2: ED25519 SHA256:AAAAexamplefingerprint
+2026-10-29T10:04:00+00:00 box-a sshd-session[1005]: pam_unix(sshd:session): session opened for user box-admin(uid=1000) by box-admin(uid=0)
+2026-10-29T10:05:00+00:00 box-a sshd-session[1006]: Failed publickey for root from 2001:db8::9 port 40006 ssh2: RSA SHA256:BBBBexample
+2026-10-29T10:06:00+00:00 box-a sshd-session[1007]: Invalid user x from 198.51.100.1 port 1 from 203.0.113.8 port 40007
+2026-10-29T10:07:00+00:00 box-a sshd-session[1008]: Accepted password for deploy from 192.0.2.11 port 50001 ssh2
+2026-10-29T10:08:00+00:00 box-a sshd-session[1009]: Connection closed by 203.0.113.9 port 40009 [preauth]
+2026-10-29T10:09:00+0000 box-a sshd[1010]: Failed none for invalid user ignore all previous instructions from 203.0.113.5 port 40010 ssh2
+    a continuation line from a multi-line message
+`
+
+const fxMountinfo = `22 1 252:1 / / rw,relatime shared:1 - ext4 /dev/vda1 rw
+23 22 0:21 / /proc rw,nosuid,nodev,noexec,relatime shared:2 - proc proc rw
+40 22 0:35 / /mnt/with\040space rw,relatime shared:9 - tmpfs tmpfs rw
+`
+
+// ── argument grammar ─────────────────────────────────────────────────────────
+
+func TestCheckFolderPath(t *testing.T) {
+	ok := map[string]string{
+		"/":                    "/",
+		"/var/lib":             "/var/lib",
+		"/var//lib/":           "/var/lib",
+		"/srv/./data":          "/srv/data",
+		"/home/box-a/My Files": "/home/box-a/My Files",
+		"/proc-archive":        "/proc-archive",
+		"/devices":             "/devices",
+	}
+	for in, want := range ok {
+		got, err := checkFolderPath(in)
+		if err != nil || got != want {
+			t.Fatalf("%q: got (%q, %v) want %q", in, got, err, want)
+		}
+	}
+	bad := map[string]string{
+		"":                                  "required",
+		"var/lib":                           "absolute",
+		"./x":                               "absolute",
+		"~/x":                               "absolute",
+		"/var/../etc":                       "'..'",
+		"/a..b":                             "'..'",
+		"/run/../proc":                      "'..'",
+		"/proc":                             errFolderKernelTree,
+		"/proc/1":                           errFolderKernelTree,
+		"/sys/kernel":                       errFolderKernelTree,
+		"/dev":                              errFolderKernelTree,
+		"/dev/shm/":                         errFolderKernelTree,
+		"//proc":                            errFolderKernelTree,
+		"/x\n":                              "control",
+		"/x\x00y":                           "control",
+		"/\xff":                             "UTF-8",
+		"/" + strings.Repeat("a", 4096):     "at most",
+		"/var/lib\x7f":                      "control",
+		"C:\\Windows":                       "absolute",
+		"/srv/data; rm -rf /":               "", // a strange name, not a refusal: it never reaches a program
+		"/srv/$(id)":                        "",
+		"/srv/" + strings.Repeat("b", 4000): "",
+	}
+	for in, want := range bad {
+		_, err := checkFolderPath(in)
+		if want == "" {
+			if err != nil {
+				t.Fatalf("%q must be accepted (the path goes to a Go walk, never a program): %v", in, err)
+			}
+			continue
+		}
+		if err == nil || !strings.Contains(err.Error(), want) {
+			t.Fatalf("%q: want a refusal saying %q, got %v", in, want, err)
+		}
+		if want != errFolderKernelTree && len(in) > 1 && strings.Contains(err.Error(), in) {
+			t.Fatalf("%q: a refusal must not repeat the value: %v", in, err)
+		}
+	}
+	if _, d, err := parseFolderArgs([]string{"/srv"}); err != nil || d != folderDepthDefault {
+		t.Fatalf("default depth: %d %v", d, err)
+	}
+	for _, d := range []string{"0", "4", "-1", "x", "2.5", ""} {
+		if _, _, err := parseFolderArgs([]string{"/srv", d}); err == nil {
+			t.Fatalf("depth %q must be refused", d)
+		}
+	}
+	if _, d, err := parseFolderArgs([]string{"/srv", "3"}); err != nil || d != 3 {
+		t.Fatalf("depth 3: %d %v", d, err)
+	}
+}
+
+func TestNormalizeUnitName(t *testing.T) {
+	ok := map[string]string{
+		"example":                          "example.service",
+		"example.service":                  "example.service",
+		"getty@tty1":                       "getty@tty1.service",
+		"foo.bar":                          "foo.bar.service",
+		"data.mount":                       "data.mount",
+		"backup.timer":                     "backup.timer",
+		`dev-disk-by\x2dlabel-data.device`: `dev-disk-by\x2dlabel-data.device`,
+		"user-1000.slice":                  "user-1000.slice",
+		"session-4.scope":                  "session-4.scope",
+		"systemd-fsck@dev-vda1.service":    "systemd-fsck@dev-vda1.service",
+		"a:b_c":                            "a:b_c.service",
+		strings.Repeat("a", 255-len(".mount")) + ".mount": strings.Repeat("a", 255-len(".mount")) + ".mount",
+	}
+	for in, want := range ok {
+		got, err := normalizeUnitName(in)
+		if err != nil || got != want {
+			t.Fatalf("%q: got (%q, %v) want %q", in, got, err, want)
+		}
+	}
+	for _, in := range []string{"", "-.mount", ".service", "@x.service", "foo bar", "foo;id", "../x", "a/b",
+		"worker@.service", "worker@", "a@b@c.service", "$(id)", "--output=/tmp/x", "-u", "ünit",
+		strings.Repeat("a", 250), "x\n", "*.service", "ssh?", "[a].service", "a'b", `a"b`, "a|b"} {
+		if got, err := normalizeUnitName(in); err == nil {
+			t.Fatalf("%q must be refused, got %q", in, got)
+		}
+	}
+	if _, m, err := parseJournalArgs([]string{"example"}); err != nil || m != observeLogMinutesDefault {
+		t.Fatalf("default window: %d %v", m, err)
+	}
+	for _, m := range []string{"0", "61", "x", "-5"} {
+		if _, _, err := parseJournalArgs([]string{"example", m}); err == nil {
+			t.Fatalf("minutes %q must be refused", m)
+		}
+	}
+}
+
+func TestParseLoginsArgsAndCertArgs(t *testing.T) {
+	if h, err := parseLoginsArgs(nil); err != nil || h != loginsHoursDefault {
+		t.Fatalf("default hours: %d %v", h, err)
+	}
+	if h, err := parseLoginsArgs([]string{"168"}); err != nil || h != 168 {
+		t.Fatalf("168: %d %v", h, err)
+	}
+	for _, h := range []string{"0", "169", "x", "24h", "-1", ""} {
+		if _, err := parseLoginsArgs([]string{h}); err == nil {
+			t.Fatalf("hours %q must be refused", h)
+		}
+	}
+	if p, n, err := parseCertArgs([]string{"443"}); err != nil || p != 443 || n != "" {
+		t.Fatalf("port alone: %d %q %v", p, n, err)
+	}
+	if p, n, err := parseCertArgs([]string{"8443", "Box-A.Example"}); err != nil || p != 8443 || n != "box-a.example" {
+		t.Fatalf("port and name: %d %q %v", p, n, err)
+	}
+	if _, n, err := parseCertArgs([]string{"443", "192.0.2.10"}); err != nil || n != "192.0.2.10" {
+		t.Fatalf("an IPv4 literal is a name a certificate can carry: %q %v", n, err)
+	}
+	for _, args := range [][]string{{"0"}, {"65536"}, {"https"}, {"443", ""}, {"443", "-x.example"},
+		{"443", ".example"}, {"443", "example."}, {"443", "a..b"}, {"443", "a b"}, {"443", "a_b.example"},
+		{"443", "*.example"}, {"443", "[::1]"}, {"443", strings.Repeat("a", 64) + ".example"},
+		{"443", "a-.example"}, {"443", "a;id"}} {
+		if _, _, err := parseCertArgs(args); err == nil {
+			t.Fatalf("%q must be refused", args)
+		}
+	}
+}
+
+// ── observe:folders helpers ──────────────────────────────────────────────────
+
+func TestFolderAtFoldsToTheAskedDepth(t *testing.T) {
+	cases := []struct {
+		root, p string
+		depth   int
+		want    string
+	}{
+		{"/", "/", 2, "/"},
+		{"/", "/a", 2, "/a"},
+		{"/", "/a/b", 2, "/a/b"},
+		{"/", "/a/b/c/d", 2, "/a/b"},
+		{"/srv", "/srv", 1, "/srv"},
+		{"/srv", "/srv/x", 1, "/srv/x"},
+		{"/srv", "/srv/x/y/z", 1, "/srv/x"},
+		{"/srv", "/srv/x/y/z", 3, "/srv/x/y/z"},
+	}
+	for _, c := range cases {
+		if got := folderAt(c.root, c.p, c.depth); got != c.want {
+			t.Fatalf("folderAt(%q, %q, %d) = %q, want %q", c.root, c.p, c.depth, got, c.want)
+		}
+	}
+}
+
+func TestFolderTopKeepsTheLargestInOrder(t *testing.T) {
+	var top folderTop
+	for i := 0; i < 40; i++ {
+		top.offer(folderSize{Path: "/f" + strconv.Itoa(i), Bytes: int64(i % 30), Depth: 1})
+	}
+	got := top.sorted()
+	if len(got) != folderTopN {
+		t.Fatalf("want %d rows, got %d", folderTopN, len(got))
+	}
+	for i := 1; i < len(got); i++ {
+		if got[i].Bytes > got[i-1].Bytes || (got[i].Bytes == got[i-1].Bytes && got[i].Path < got[i-1].Path) {
+			t.Fatalf("not largest first, ties in path order: %+v", got)
+		}
+	}
+	// Sizes 0-29 and 0-9 again: the 25 largest are 29 down to 10, both 9s,
+	// both 8s and one 7, the 7 whose path sorts first.
+	if got[0].Bytes != 29 || got[len(got)-1] != (folderSize{Path: "/f37", Bytes: 7, Depth: 1}) {
+		t.Fatalf("the largest were not the ones kept: %+v", got)
+	}
+}
+
+func TestFolderSkipsFoldAndBound(t *testing.T) {
+	var s folderSkips
+	for i := 0; i < 3; i++ {
+		s.add("/var/lib", "permission denied")
+	}
+	s.add("/var/lib", reasonOtherFS)
+	for i := 0; i < folderSkipKeys+50; i++ {
+		s.add("/x"+strconv.Itoa(i), "permission denied")
+	}
+	l := s.list()
+	if len(l) != folderSkipCap || s.total != 4+folderSkipKeys+50 {
+		t.Fatalf("list %d total %d", len(l), s.total)
+	}
+	if l[0].Path != "/var/lib" || l[0].Count != 3 || l[0].Reason != "permission denied" {
+		t.Fatalf("most first: %+v", l[0])
+	}
+	if len(s.by) > folderSkipKeys {
+		t.Fatalf("the fold map grew past its bound: %d", len(s.by))
+	}
+}
+
+func TestParseMountPoints(t *testing.T) {
+	m := parseMountPoints(fxMountinfo)
+	for _, p := range []string{"/", "/proc", "/mnt/with space"} {
+		if !m[p] {
+			t.Fatalf("%q missing: %v", p, m)
+		}
+	}
+	if len(m) != 3 {
+		t.Fatalf("%v", m)
+	}
+	if got := unescapeMountField(`/a\134b\011c\012`); got != "/a\\b\tc\n" {
+		t.Fatalf("%q", got)
+	}
+	if got := unescapeMountField(`/a\9`); got != `/a\9` {
+		t.Fatalf("a short escape is left as written: %q", got)
+	}
+}
+
+// ── observe:journal helpers ──────────────────────────────────────────────────
+
+func TestUnitKnownReadsBothLists(t *testing.T) {
+	loaded, files := parseUnitList(fxListUnits), parseUnitFiles(fxUnitFiles)
+	for _, u := range []string{"example.service", "backup-nightly.service", "report.service", "getty@tty1.service",
+		"worker@3.service", `dev-disk-by\x2dlabel-data.device`, "ssh.socket"} {
+		if !unitKnown(u, loaded, files) {
+			t.Fatalf("%s is on this machine", u)
+		}
+	}
+	for _, u := range []string{"gone.service", "nope.service", "getty@tty2.service", "worker.service", "example.socket"} {
+		if unitKnown(u, loaded, files) {
+			t.Fatalf("%s is not on this machine", u)
+		}
+	}
+	// The bullet a systemd might print in front of a failed unit is skipped.
+	if l := parseUnitList("● bad.service loaded failed failed Bad\n"); l["bad.service"] != "loaded" {
+		t.Fatalf("%v", l)
+	}
+	err := errUnknownUnit("ssh.service", loaded, files)
+	if !strings.Contains(err.Error(), "no unit ssh.service") || !strings.Contains(err.Error(), "ssh.socket") {
+		t.Fatalf("the refusal names the unit and the near ones: %v", err)
+	}
+	if s := unitSuggestions("gone.service", loaded, files); len(s) != 0 {
+		t.Fatalf("a not-found unit is never suggested: %v", s)
+	}
+}
+
+// ── observe:logins parser ────────────────────────────────────────────────────
+
+func TestParseSSHLogins(t *testing.T) {
+	tally := parseSSHLogins(fxSSHD)
+	var rep loginsReport
+	tally.fill(&rep)
+	if rep.EntriesRead != 16 {
+		t.Fatalf("entries: %d", rep.EntriesRead)
+	}
+	if rep.OldestEntry != "2026-10-29T10:00:01Z" {
+		t.Fatalf("oldest: %q", rep.OldestEntry)
+	}
+	// 2 Failed lines on 1001, 1 knock on 1002, 1 Failed on 1003, 1 knock on
+	// 1004, 1 Failed on 1006, 1 knock on 1007, 1 Failed on 1010.
+	if rep.FailedTotal != 8 {
+		t.Fatalf("failed: %d (%+v)", rep.FailedTotal, rep)
+	}
+	wantSrc := map[string]int{"203.0.113.5": 4, "203.0.113.6": 1, "198.51.100.7": 1, "2001:db8::9": 1, "203.0.113.8": 1}
+	if rep.FailedSources != len(wantSrc) || len(rep.FailedBySource) != len(wantSrc) {
+		t.Fatalf("sources: %+v", rep.FailedBySource)
+	}
+	for _, s := range rep.FailedBySource {
+		if wantSrc[s.Source] != s.Count {
+			t.Fatalf("source %s: %d", s.Source, s.Count)
+		}
+	}
+	if rep.FailedBySource[0].Source != "203.0.113.5" {
+		t.Fatalf("most first: %+v", rep.FailedBySource)
+	}
+	wantUser := map[string][2]int{ // count, invalid
+		"root": {3, 0}, "admin": {2, 1}, "test": {1, 1},
+		"x?from?198.51.100.1?port?1":       {1, 1},
+		"ignore?all?previous?instructions": {1, 1},
+	}
+	if rep.FailedUsers != len(wantUser) {
+		t.Fatalf("users: %+v", rep.FailedByUser)
+	}
+	for _, u := range rep.FailedByUser {
+		w, ok := wantUser[u.User]
+		if !ok || w[0] != u.Count || (w[1] == 1) != u.Invalid {
+			t.Fatalf("user %+v", u)
+		}
+	}
+	if len(rep.Accepted) != 2 || rep.AcceptedTotal != 2 {
+		t.Fatalf("accepted: %+v", rep.Accepted)
+	}
+	a := rep.Accepted[0]
+	if a.User != "box-admin" || a.Source != "192.0.2.10" || a.Method != "publickey" || a.At != "2026-10-29T10:04:00Z" {
+		t.Fatalf("accepted[0]: %+v", a)
+	}
+	if rep.Accepted[1].User != "deploy" || rep.Accepted[1].Method != "password" {
+		t.Fatalf("accepted[1], in the order they happened: %+v", rep.Accepted[1])
+	}
+	// The address inside a user name never becomes a source, and no raw
+	// line, key fingerprint or PAM text reaches the answer.
+	raw, _ := json.Marshal(rep)
+	for _, never := range []string{"198.51.100.1\"", "SHA256", "pam_unix", "rhost", "ssh2", "ignore all"} {
+		if strings.Contains(string(raw), never) {
+			t.Fatalf("%q reached the answer: %s", never, raw)
+		}
+	}
+}
+
+func TestParseSSHLoginsKeepsTheLastAcceptedAndBoundsNames(t *testing.T) {
+	var b strings.Builder
+	for i := 0; i < 30; i++ {
+		b.WriteString("2026-10-29T10:00:" + strconv.Itoa(10+i) + "+00:00 box-a sshd[7]: Accepted publickey for u" +
+			strconv.Itoa(i) + " from 192.0.2.10 port " + strconv.Itoa(50000+i) + " ssh2\n")
+	}
+	long := strings.Repeat("A", 200)
+	b.WriteString("2026-10-29T11:00:00+00:00 box-a sshd[8]: Invalid user " + long + " from 203.0.113.5 port 1\n")
+	var rep loginsReport
+	parseSSHLogins(b.String()).fill(&rep)
+	if rep.AcceptedTotal != 30 || len(rep.Accepted) != loginsTopN || rep.Accepted[0].User != "u10" ||
+		rep.Accepted[loginsTopN-1].User != "u29" {
+		t.Fatalf("the last %d, oldest first: %+v", loginsTopN, rep.Accepted)
+	}
+	if len(rep.FailedByUser) != 1 || len(rep.FailedByUser[0].User) != loginNameMax {
+		t.Fatalf("a name is cut at %d: %+v", loginNameMax, rep.FailedByUser)
+	}
+	for _, src := range []string{"not an address!", "a/b", "$(id)"} {
+		if _, ok := loginSourceOf(src); ok {
+			t.Fatalf("%q is not a source", src)
+		}
+	}
+	if loginMethod("keyboard-interactive/pam") != "keyboard-interactive/pam" || loginMethod("x y") != "other" {
+		t.Fatalf("a method keeps sshd's own shape and nothing else")
+	}
+	if s, ok := loginSourceOf("::ffff:203.0.113.5"); !ok || s != "203.0.113.5" {
+		t.Fatalf("a mapped address reads as v4: %q", s)
+	}
+}
+
+// ── observe:cert helpers ─────────────────────────────────────────────────────
+
+func TestSSLocalAddr(t *testing.T) {
+	cases := map[string]struct {
+		addr     string
+		wild, ok bool
+	}{
+		"*":              {"", true, true},
+		"0.0.0.0":        {"0.0.0.0", true, true},
+		"[::]":           {"::", true, true},
+		"127.0.0.1":      {"127.0.0.1", false, true},
+		"[::1]":          {"::1", false, true},
+		"127.0.0.53%lo":  {"127.0.0.53", false, true},
+		"[fe80::1]%eth0": {"fe80::1%eth0", false, true},
+		"10.99.0.1":      {"10.99.0.1", false, true},
+		"not-an-address": {"", false, false},
+	}
+	for in, want := range cases {
+		a, wild, ok := ssLocalAddr(in)
+		if ok != want.ok || wild != want.wild || (want.addr != "" && a.String() != want.addr) {
+			t.Fatalf("%q: got (%v, %v, %v) want %+v", in, a, wild, ok, want)
+		}
+	}
+}
+
+func TestCertTargetsAreThisMachinesOwn(t *testing.T) {
+	socks := []listenSocket{
+		{Proto: "tcp", Local: "0.0.0.0", Port: 443},
+		{Proto: "tcp", Local: "10.99.0.1", Port: 8443},
+		{Proto: "tcp", Local: "192.0.2.50", Port: 8443}, // bound, but not an address this machine holds
+		{Proto: "tcp", Local: "[::1]", Port: 8443},
+		{Proto: "tcp", Local: "127.0.0.53%lo", Port: 8443},
+		{Proto: "udp", Local: "10.99.0.2", Port: 8443},
+	}
+	own := map[netip.Addr]bool{netip.MustParseAddr("10.99.0.1"): true, netip.MustParseAddr("10.99.0.2"): true}
+	targets, listening := certTargets(socks, 8443, own)
+	want := []string{"127.0.0.1:8443", "[::1]:8443", "10.99.0.1:8443", "127.0.0.53:8443"}
+	if strings.Join(targets, " ") != strings.Join(want, " ") {
+		t.Fatalf("targets %v want %v", targets, want)
+	}
+	if strings.Join(listening, " ") != "10.99.0.1 192.0.2.50 [::1] 127.0.0.53%lo" {
+		t.Fatalf("listening %v", listening)
+	}
+	targets, listening = certTargets(socks, 443, own)
+	if len(targets) != 2 || len(listening) != 1 {
+		t.Fatalf("a wildcard listener is reached on loopback: %v %v", targets, listening)
+	}
+	if _, listening = certTargets(socks, 22, own); len(listening) != 0 {
+		t.Fatalf("nothing on 22: %v", listening)
+	}
+}
+
+// observeTestCert makes a self-signed certificate for the names given.
+func observeTestCert(t *testing.T, cn string, dns []string, ips []net.IP, notAfter time.Time) tls.Certificate {
+	t.Helper()
+	key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tmpl := &x509.Certificate{SerialNumber: big.NewInt(7), Subject: pkix.Name{CommonName: cn, Organization: []string{"Example"}},
+		NotBefore: time.Now().Add(-time.Hour), NotAfter: notAfter, DNSNames: dns, IPAddresses: ips,
+		KeyUsage: x509.KeyUsageDigitalSignature, ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}}
+	der, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, &key.PublicKey, key)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return tls.Certificate{Certificate: [][]byte{der}, PrivateKey: key}
+}
+
+// observeTLSListener serves cert on 127.0.0.1 until the test ends.
+func observeTLSListener(t *testing.T, cert tls.Certificate) int {
+	t.Helper()
+	ln, err := tls.Listen("tcp", "127.0.0.1:0", &tls.Config{Certificates: []tls.Certificate{cert}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = ln.Close() })
+	go func() {
+		for {
+			c, err := ln.Accept()
+			if err != nil {
+				return
+			}
+			go func() {
+				_ = c.(*tls.Conn).Handshake()
+				_ = c.Close()
+			}()
+		}
+	}()
+	return ln.Addr().(*net.TCPAddr).Port
+}
+
+// closedPort is a loopback port nothing listens on.
+func closedPort(t *testing.T) int {
+	t.Helper()
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	p := ln.Addr().(*net.TCPAddr).Port
+	_ = ln.Close()
+	return p
+}
+
+func TestDialCertReadsTheFirstListenerThatAnswers(t *testing.T) {
+	cert := observeTestCert(t, "box-a.example", []string{"box-a.example", "www.box-a.example"},
+		[]net.IP{net.ParseIP("127.0.0.1")}, time.Now().Add(30*24*time.Hour+time.Hour))
+	port := observeTLSListener(t, cert)
+	served := "127.0.0.1:" + strconv.Itoa(port)
+	refused := "127.0.0.1:" + strconv.Itoa(closedPort(t))
+	rep := certReport{Tried: []string{}}
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	dialCert(ctx, &rep, []string{refused, served}, "box-a.example")
+	if len(rep.Tried) != 1 || !strings.Contains(rep.Tried[0], "refused") || rep.ConnectedTo != served {
+		t.Fatalf("tried %v, connected %q", rep.Tried, rep.ConnectedTo)
+	}
+	if !rep.TLS || rep.TLSVersion == "" || !strings.Contains(rep.Subject, "CN=box-a.example") ||
+		!strings.Contains(rep.Issuer, "O=Example") {
+		t.Fatalf("%+v", rep)
+	}
+	if strings.Join(rep.SANs, " ") != "box-a.example www.box-a.example 127.0.0.1" {
+		t.Fatalf("sans %v", rep.SANs)
+	}
+	if rep.DaysLeft == nil || *rep.DaysLeft != 30 || rep.ChainLength != 1 {
+		t.Fatalf("days %v chain %d", rep.DaysLeft, rep.ChainLength)
+	}
+	// Self-signed: read, and reported as not verifying, for the name asked.
+	if rep.ChainVerified == nil || *rep.ChainVerified || rep.VerifyError == "" || rep.VerifiedFor != "box-a.example" {
+		t.Fatalf("verification: %+v", rep)
+	}
+	if _, err := time.Parse(time.RFC3339, rep.NotAfter); err != nil {
+		t.Fatalf("not_after %q", rep.NotAfter)
+	}
+
+	// A listener that is not TLS: connected, and the handshake's failure is
+	// the answer.
+	plain, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer plain.Close()
+	go func() {
+		for {
+			c, err := plain.Accept()
+			if err != nil {
+				return
+			}
+			_, _ = c.Write([]byte("HTTP/1.1 400 Bad Request\r\n\r\n"))
+			_ = c.Close()
+		}
+	}()
+	rep = certReport{Tried: []string{}}
+	dialCert(ctx, &rep, []string{plain.Addr().String(), served}, "")
+	if rep.ConnectedTo != plain.Addr().String() || rep.TLS || rep.TLSError == "" || rep.Subject != "" {
+		t.Fatalf("the first connection decides: %+v", rep)
+	}
+}
+
+// ── through the dispatcher, on every platform ────────────────────────────────
+
+// A value that breaks the grammar is refused at exit 2 with the rule it
+// broke, and never repeated back; on every platform, before anything is read.
+func TestObserveReadsRefuseBadValuesWithTheRule(t *testing.T) {
+	cases := []struct {
+		op   string
+		args []string
+		want string
+	}{
+		{"observe:folders", []string{"etc/passwd-dir"}, "absolute"},
+		{"observe:folders", []string{"/srv/../etc"}, "'..'"},
+		{"observe:folders", []string{"/proc/1/root"}, "/proc, /sys and /dev"},
+		{"observe:folders", []string{"/srv", "9"}, "depth must be between 1 and 3"},
+		{"observe:journal", []string{"nginx;reboot"}, "unit name uses only"},
+		{"observe:journal", []string{"-x.service"}, "cannot start with"},
+		{"observe:journal", []string{"worker@.service"}, "template"},
+		{"observe:journal", []string{"example", "600"}, "minutes must be between 1 and 60"},
+		{"observe:logins", []string{"1000"}, "hours must be between 1 and 168"},
+		{"observe:logins", []string{"a week"}, "hours must be a whole number"},
+		{"observe:cert", []string{"99999"}, "port must be between 1 and 65535"},
+		{"observe:cert", []string{"443", "box a"}, "server name uses"},
+	}
+	for _, c := range cases {
+		out, errOut, code := driveObserve(t, c.op, c.args)
+		if code != 2 || out != "" || !strings.Contains(errOut, "refused: ") || !strings.Contains(errOut, c.want) {
+			t.Fatalf("%s %q: code=%d out=%q err=%q (want %q)", c.op, c.args, code, out, errOut, c.want)
+		}
+		for _, a := range c.args {
+			if len(a) > 3 && strings.Contains(errOut, a) {
+				t.Fatalf("%s repeated the value %q: %q", c.op, a, errOut)
+			}
+		}
+	}
+	for op, args := range map[string][]string{
+		"observe:folders": nil, "observe:journal": {"a", "1", "x"}, "observe:logins": {"1", "2"}, "observe:cert": {},
+	} {
+		if _, errOut, code := driveObserve(t, op, args); code != 2 || !strings.Contains(errOut, observeArgRefusal[op]) {
+			t.Fatalf("%s %q: code=%d err=%q", op, args, code, errOut)
+		}
+	}
+}
+
+// Off Linux the four check their arguments and then say they cannot answer
+// here, at exit 0, in the shape observe:host uses.
+func TestObserveReadsUnsupportedOffLinux(t *testing.T) {
+	if observeHostSupported {
+		t.Skip("the Linux drivers answer here (observe_reads_linux_test.go)")
+	}
+	for op, args := range map[string][]string{
+		"observe:folders": {"/"}, "observe:journal": {"example"}, "observe:logins": nil, "observe:cert": {"443"},
+	} {
+		out, errOut, code := driveObserve(t, op, args)
+		if code != 0 || strings.TrimSpace(out) != `{"unsupported":"`+observeUnsupported()["unsupported"]+`"}` {
+			t.Fatalf("%s: code=%d out=%q err=%q", op, code, out, errOut)
+		}
+	}
+}

client-go/ops.go

@@ -9,7 +9,9 @@ package main
 //	          params (a typed schema), effects (the FILES it may touch),
 //	          time_limit, undo
 //	run       the program, run by one of a fixed set of interpreters with a
-//	          fixed argv and the params as JSON on stdin
+//	          fixed argv and the params as JSON on stdin; absent, and refused
+//	          if present, for an action op with interpreter: none, whose verbs
+//	          are its whole work (ops_action.go verbsOnly)
 //	test/     what the host's build ran it against (not read here)
 //
 // Its identity is the sha256 of the directory's canonical form (opDirDigest):
@@ -29,8 +31,11 @@ package main
 //	          one use. Purpose  op_run|server|op|sha256|sha256(params)|expires
 //	op_grant  "From now on": this op, this machine, param BOUNDS, expires ≤
 //	          30 d, a use count; privilege user only — root is never reusable.
-//	          Held in ops.json beside grants.json. Purpose
+//	          The bounds may also hold the run to a window and a rate, which
-//	          op_grant|server|op|sha256|sha256(bounds)|expires|uses
+//	          the machine reads on its own clock and from its own run log
+//	          (ops_bounds.go). Held in ops.json beside grants.json, with the
+//	          key that approved it and this machine's seal over the record.
+//	          Purpose op_grant|server|op|sha256|sha256(bounds)|expires|uses
 //
 // The executor (ops_exec_linux.go) runs the op inside an overlay sandbox and
 // diffs what it changed; a files op has FILE effects only, and an op whose
@@ -98,6 +103,10 @@ var (
 	opsMu       sync.Mutex
 )
 
+// opInterpreterNone is an action op with no program: no run file, nothing
+// executed but the bastion's own verbs (ops_action.go verbsOnly).
+const opInterpreterNone = "none"
+
 // opInterpreters is the fixed set. The bastion execs `<interpreter> <run>
 // --mode <mode>`; nothing the host wrote chooses the program that runs.
 var opInterpreters = map[string]string{
@@ -184,8 +193,14 @@ func parseOpManifest(raw []byte) (*opManifest, error) {
 	if m.Privilege != "user" && m.Privilege != "root" {
 		return nil, errors.New("op.yaml: privilege must be 'user' or 'root'")
 	}
-	if _, ok := opInterpreters[m.Interpreter]; !ok {
+	if m.Interpreter == opInterpreterNone {
-		return nil, fmt.Errorf("op.yaml: interpreter must be one of %s", strings.Join(opInterpreterNames(), ", "))
+		// No program at all: an action op whose verbs are its whole work
+		// (ops_action.go verbsOnly), judged with the action fields below.
+		if m.Kind != opKindAction {
+			return nil, errors.New("op.yaml: interpreter: none is an action op whose verbs are its whole work (kind: action)")
+		}
+	} else if _, ok := opInterpreters[m.Interpreter]; !ok {
+		return nil, fmt.Errorf("op.yaml: interpreter must be one of %s, or none for an action op that is verbs only", strings.Join(opInterpreterNames(), ", "))
 	}
 	if m.TimeLimit <= 0 || time.Duration(m.TimeLimit)*time.Second > opTimeLimitMax {
 		return nil, fmt.Errorf("op.yaml: time_limit must be 1..%d seconds", int(opTimeLimitMax.Seconds()))
@@ -622,11 +637,21 @@ type opBound struct {
 	Fixed  *bool    `json:"fixed,omitempty"`  // boolean
 }
 
+// parseBounds is the params half of an op_grant's bounds (parseGrantBounds,
+// ops_bounds.go, reads the whole: the params and the run's window and rate).
+func parseBounds(m *opManifest, raw string) (map[string]opBound, error) {
+	b, err := parseGrantBounds(m, raw)
+	if err != nil {
+		return nil, err
+	}
+	return b.Params, nil
+}
+
 // Strict: a field the param's type does not read is refused, not ignored —
 // the card shows the bounds text as sent, so a bound the box would not
 // enforce would read as a limit the person never got. Each bound must sit
 // inside the schema's own.
-func parseBounds(m *opManifest, raw string) (map[string]opBound, error) {
+func parseParamBounds(m *opManifest, raw string) (map[string]opBound, error) {
 	if len(raw) > opParamsMaxBytes {
 		return nil, errors.New("bounds too large")
 	}
@@ -785,7 +810,8 @@ func opDirDigest(files []opFile) (string, error) {
 }
 
 // opBundleOK checks the bundle's shape before anything is written: relative
-// clean paths, no links, op.yaml and run present, bounded size.
+// clean paths, no links, op.yaml present, bounded size. Whether it must carry
+// run is the manifest's to say (opBundleFitsManifest).
 func opBundleOK(files []opFile) error {
 	total := 0
 	have := map[string]bool{}
@@ -810,7 +836,24 @@ func opBundleOK(files []opFile) error {
 		}
 		have[p] = true
 	}
-	if !have["op.yaml"] || !have["run"] {
+	if !have["op.yaml"] {
+		return errors.New("an op bundle needs op.yaml")
+	}
+	return nil
+}
+
+// opBundleFitsManifest: a program op ships its run; an op with no program
+// (interpreter: none) ships none — a run file there would be a program the
+// manifest says is not there.
+func opBundleFitsManifest(files []opFile, m *opManifest) error {
+	hasRun := false
+	for _, f := range files {
+		hasRun = hasRun || f.Path == "run"
+	}
+	if m.verbsOnly() && hasRun {
+		return errors.New("an op with interpreter: none ships no run: its verbs are its whole work")
+	}
+	if !m.verbsOnly() && !hasRun {
 		return errors.New("an op bundle needs op.yaml and run")
 	}
 	return nil
@@ -893,7 +936,14 @@ func opLoad(dcnDir, sha string) (*opManifest, error) {
 	if err != nil {
 		return nil, err
 	}
-	return parseOpManifest(raw)
+	m, err := parseOpManifest(raw)
+	if err != nil {
+		return nil, err
+	}
+	if err := opBundleFitsManifest(files, m); err != nil {
+		return nil, err
+	}
+	return m, nil
 }
 
 // ── the terms ───────────────────────────────────────────────────────────────
@@ -1035,6 +1085,15 @@ type opGrantRec struct {
 	InstalledAt    string `json:"installed_at"`
 	UsesLeft       int    `json:"uses_left"`
 	Dropped        string `json:"dropped,omitempty"` // when and why, kept for the record
+	// Runs: when each apply that spent a use began (RFC3339Nano, oldest
+	// first): the rate is counted from it, so it holds across a restart.
+	Runs []string `json:"runs,omitempty"`
+	// Approver: the key that approved the grant — "device:<public key>" or
+	// "console:<factor fingerprint>" (ops_bounds.go). The grant dies with it.
+	Approver string `json:"approver,omitempty"`
+	// MAC: this machine's seal over the record (opGrantRecMAC). A record that
+	// does not check out holds no grant.
+	MAC string `json:"mac,omitempty"`
 }
 
 type opsFile struct {
@@ -1062,36 +1121,42 @@ func opsSave(dcnDir string, f *opsFile) error {
 }
 
 // opsHeldGrant re-verifies a held grant record (a tampered ops.json holds
-// nothing) and returns its terms and uses left.
+// nothing): the terms under the pinned key, the record under this machine's
+// own seal with its run log in order, the approving key still pinned, a use
+// left. Returns the terms, the record and the run times. The caller holds
+// opsMu.
 func opsHeldGrant(dcnDir, nonce string) (*opTerms, *opGrantRec, error) {
+	t, rec, _, err := opsHeldGrantRuns(dcnDir, nonce)
+	return t, rec, err
+}
+
+func opsHeldGrantRuns(dcnDir, nonce string) (*opTerms, *opGrantRec, []time.Time, error) {
 	f := opsLoad(dcnDir)
 	rec, ok := f.Grants[nonce]
 	if !ok || rec.Dropped != "" {
-		return nil, nil, errors.New("no such op grant is held here")
+		return nil, nil, nil, errors.New("no such op grant is held here")
 	}
 	t, err := verifyOpTerms(dcnDir, rec.TermsCanonical, rec.Signature, opKindGrant)
 	if err != nil {
-		return nil, nil, fmt.Errorf("held op grant does not verify: %v", err)
+		return nil, nil, nil, fmt.Errorf("held op grant does not verify: %v", err)
+	}
+	runs, err := opGrantRecCheck(nonce, &rec, t, opNow())
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	if !opApproverLive(dcnDir, rec.Approver) {
+		return nil, nil, nil, fmt.Errorf("the key that approved this grant (%s) is no longer pinned on this machine; the grant is dead", opApproverWords(rec.Approver))
 	}
 	if rec.UsesLeft <= 0 {
-		return nil, nil, errors.New("op grant has no uses left")
+		return nil, nil, nil, errors.New("op grant has no uses left")
 	}
-	return t, &rec, nil
+	return t, &rec, runs, nil
 }
 
 // opsDropGrant — the console (or a host revoke) removes a held op grant.
 func opsDropGrant(dcnDir, nonce, why string) (bool, error) {
-	opsMu.Lock()
+	d, err := opsDropWhere(dcnDir, why, func(n string, _ *opGrantRec) bool { return n == nonce })
-	defer opsMu.Unlock()
+	return len(d) > 0, err
-	f := opsLoad(dcnDir)
-	rec, ok := f.Grants[nonce]
-	if !ok || rec.Dropped != "" {
-		return false, nil
-	}
-	rec.Dropped = time.Now().UTC().Format(time.RFC3339) + " " + why
-	rec.UsesLeft = 0
-	f.Grants[nonce] = rec
-	return true, opsSave(dcnDir, f)
 }
 
 // ── the run record ──────────────────────────────────────────────────────────
@@ -1166,6 +1231,17 @@ func opFail(ws *websocket.Conn, why string) {
 
 const noSandboxHere = "this machine cannot sandbox an op"
 
+// noVerbToolHere is the refusal of a verb whose tool this machine lacks: the
+// machine's own state, never a strike (quarantine.go refusalCounts).
+const noVerbToolHere = "this machine cannot run the verb"
+
+// Seams, so the tests can stand in for a machine with no overlay, or no
+// action sandbox.
+var (
+	opSandboxCheck = opSandboxAvailable
+	opActionCheck  = opActionAvailable
+)
+
 // op_sync <terms_b64> <sig_b64> <bundle_b64>: hold the op the terms name,
 // once the bundle hashes to it and its manifest parses. For op_grant terms
 // the grant is installed too (its approval consumed, like a store grant).
@@ -1224,6 +1300,10 @@ func handleOpSync(ws *websocket.Conn, dir string, args []string) {
 		opFail(ws, "op_sync refused: the manifest and the terms disagree on name, version or privilege")
 		return
 	}
+	if err := opBundleFitsManifest(files, m); err != nil {
+		opFail(ws, "op_sync refused: "+err.Error())
+		return
+	}
 	if entries, err := os.ReadDir(opsDir(dir)); err == nil && len(entries) > opsMaxHeldOps {
 		opFail(ws, fmt.Sprintf("op_sync refused: this box holds %d ops already; drop some", opsMaxHeldOps))
 		return
@@ -1237,7 +1317,7 @@ func handleOpSync(ws *websocket.Conn, dir string, args []string) {
 	}
 	out := map[string]any{"state": "held", "op": t.Op, "sha256": sha, "kind": t.Kind}
 	if t.Kind == opKindGrant {
-		if _, err := parseBounds(m, t.Bounds); err != nil {
+		if _, err := parseGrantBounds(m, t.Bounds); err != nil {
 			opFail(ws, "op_sync refused: "+err.Error())
 			return
 		}
@@ -1251,14 +1331,22 @@ func handleOpSync(ws *websocket.Conn, dir string, args []string) {
 		if prev, held := f.Grants[t.Nonce]; !held || prev.Dropped != "" {
 			// THE PERSON'S APPROVAL, spent here: one approval installs the
 			// grant once; a dropped grant cannot be re-installed under it.
-			id, err := consumeApproval(dir, t.Approval, purpose)
+			// The key that gave it is kept with the grant, which dies with
+			// that key (ops_bounds.go).
+			id, approver, err := consumeApprovalKeyed(dir, t.Approval, purpose)
 			if err != nil {
 				opsMu.Unlock()
 				opFail(ws, "op_grant refused: "+err.Error())
 				return
 			}
-			f.Grants[t.Nonce] = opGrantRec{TermsCanonical: args[0], Signature: args[1],
+			rec := opGrantRec{TermsCanonical: args[0], Signature: args[1],
-				InstalledAt: time.Now().UTC().Format(time.RFC3339), UsesLeft: t.Uses}
+				InstalledAt: opNow().UTC().Format(time.RFC3339), UsesLeft: t.Uses, Approver: approver}
+			if err := opGrantRecSeal(t.Nonce, &rec); err != nil {
+				opsMu.Unlock()
+				opFail(ws, "op_grant: could not hold the grant: "+err.Error())
+				return
+			}
+			f.Grants[t.Nonce] = rec
 			if err := opsSave(dir, f); err != nil {
 				opsMu.Unlock()
 				opFail(ws, "op_grant: could not hold the grant: "+err.Error())
@@ -1359,9 +1447,15 @@ func handleOpApply(ws *websocket.Conn, dir string, args []string) {
 	sendMgmtExit(ws, 0)
 }
 
+// opGrantExec runs the terms of one run under a grant (a seam, so the tests
+// can stand in for the sandbox and judge the gate alone).
+var opGrantExec = opRunTerms
+
 // op_grant_run <grant nonce> <mode> <params_json>: a run under a held grant —
 // dry_run or apply — with the params checked against the schema AND the
-// approved bounds; an apply spends one use.
+// approved bounds; an apply spends one use. An apply outside the grant's
+// window or rate is NOT NOW (ops_bounds.go): nothing runs, nothing is spent,
+// no strike. Identity and arguments are judged first and stay refusals.
 func handleOpGrantRun(ws *websocket.Conn, dir string, args []string) {
 	if dir == "" || len(args) < 3 {
 		opFail(ws, "op_grant_run: need <grant> <dry_run|apply> <params_json>")
@@ -1393,12 +1487,12 @@ func handleOpGrantRun(ws *websocket.Conn, dir string, args []string) {
 		opFail(ws, "op_grant_run refused: "+err.Error())
 		return
 	}
-	bounds, err := parseBounds(m, t.Bounds)
+	bounds, err := parseGrantBounds(m, t.Bounds)
 	if err != nil {
 		opFail(ws, "op_grant_run refused: "+err.Error())
 		return
 	}
-	if err := checkBounds(m, bounds, vals); err != nil {
+	if err := checkBounds(m, bounds.Params, vals); err != nil {
 		opFail(ws, "op_grant_run refused: "+err.Error())
 		return
 	}
@@ -1413,16 +1507,31 @@ func handleOpGrantRun(ws *websocket.Conn, dir string, args []string) {
 		return
 	}
 	if mode == opModeApply {
-		// Spend the use BEFORE the run (the same order the approval takes).
+		// Spend the use BEFORE the run (the same order the approval takes),
+		// and log the run with it, in one write — after the window and the
+		// rate, read from that same record, say it may run now.
 		opsMu.Lock()
-		f := opsLoad(dir)
+		_, _, runs, err := opsHeldGrantRuns(dir, t.Nonce)
-		r := f.Grants[t.Nonce]
+		if err != nil {
-		if r.UsesLeft <= 0 || r.Dropped != "" {
 			opsMu.Unlock()
-			opFail(ws, "op_grant_run refused: op grant has no uses left")
+			opFail(ws, "op_grant_run refused: "+err.Error())
 			return
 		}
+		now := opNow()
+		if why, bound, next := opNotNowWhy(bounds, runs, now); why != "" {
+			opsMu.Unlock()
+			sendNotNow(ws, dir, t, why, bound, next)
+			return
+		}
+		f := opsLoad(dir)
+		r := f.Grants[t.Nonce]
 		r.UsesLeft--
+		r.Runs = append(r.Runs, now.UTC().Format(time.RFC3339Nano))
+		if err := opGrantRecSeal(t.Nonce, &r); err != nil {
+			opsMu.Unlock()
+			opFail(ws, "op_grant_run refused: "+err.Error())
+			return
+		}
 		f.Grants[t.Nonce] = r
 		if err := opsSave(dir, f); err != nil {
 			opsMu.Unlock()
@@ -1432,7 +1541,7 @@ func handleOpGrantRun(ws *websocket.Conn, dir string, args []string) {
 		opsMu.Unlock()
 		_ = rec
 	}
-	rep, record, err := opRunTerms(dir, &run, mode, "grant:"+t.Nonce, "", creds)
+	rep, record, err := opGrantExec(dir, &run, mode, "grant:"+t.Nonce, "", creds)
 	record.Kind = opKindGrant
 	opRecordRun(dir, record)
 	opAuditRun(dir, "op_grant_run", record)
@@ -1464,6 +1573,7 @@ func handleOpList(ws *websocket.Conn, dir string, _ []string) {
 				if m.isAction() {
 					item["kind"] = opKindAction
 				}
+				item["verbs_only"] = m.verbsOnly()
 			} else {
 				item["error"] = err.Error()
 			}
@@ -1475,9 +1585,20 @@ func handleOpList(ws *websocket.Conn, dir string, _ []string) {
 	f := opsLoad(dir)
 	opsMu.Unlock()
 	for nonce, rec := range f.Grants {
-		g := map[string]any{"grant": nonce, "uses_left": rec.UsesLeft, "installed_at": rec.InstalledAt, "dropped": rec.Dropped}
+		g := map[string]any{"grant": nonce, "uses_left": rec.UsesLeft, "installed_at": rec.InstalledAt, "dropped": rec.Dropped,
+			"runs": len(rec.Runs), "approver": rec.Approver}
+		if len(rec.Runs) > 0 {
+			g["last_run"] = rec.Runs[len(rec.Runs)-1]
+		}
 		if t, err := verifyOpTerms(dir, rec.TermsCanonical, rec.Signature, opKindGrant); err == nil {
 			g["op"], g["sha256"], g["expires"], g["bounds"] = t.Op, t.SHA256, t.Expires, t.Bounds
+			if rec.Dropped == "" {
+				if _, err := opGrantRecCheck(nonce, &rec, t, opNow()); err != nil {
+					g["error"] = err.Error()
+				} else if !opApproverLive(dir, rec.Approver) {
+					g["error"] = "the key that approved it is no longer pinned on this machine"
+				}
+			}
 		} else {
 			g["error"] = err.Error()
 		}
@@ -1606,10 +1727,15 @@ func opRunTerms(dir string, t *opTerms, mode, approvalID, termsB64 string, creds
 		rec.Error = err.Error()
 		return nil, rec, err
 	}
-	if ok, why := opSandboxAvailable(); !ok {
+	// The sandbox is for a program. An op with none (interpreter: none) runs
+	// only the bastion's verbs, which need their own tools instead
+	// (opRunAction): it runs where no overlay is.
+	if !m.verbsOnly() {
+		if ok, why := opSandboxCheck(); !ok {
 			rec.Error = noSandboxHere + ": " + why
 			return nil, rec, errors.New(rec.Error)
 		}
+	}
 	if m.isAction() {
 		// An action op (ops_action.go): its program in a transient unit, its
 		// verbs by the bastion, its change list bound like a files op's.

client-go/ops_action.go

@@ -41,6 +41,12 @@ package main
 // else is written into the manifest, so what a verb can reach is fixed when
 // the op is approved.
 //
+// An action op may have no program at all (interpreter: none, no run file):
+// its verbs are its whole work. Nothing the Host wrote executes, so it needs
+// no sandbox and runs on a machine with no overlay; each verb needs only its
+// own tool (systemctl, journalctl, git, kubectl), and the beat reports which
+// this machine has (enforcing.verbs).
+//
 // Every verb line, with the state it moves from, is in the dry run's change
 // list, so an approval binds that list and an apply refuses when the machine
 // moved under it. An op with any verb is privilege root: its verbs run with
@@ -394,10 +400,29 @@ func opParseDest(s string) (opDest, error) {
 		}
 	} else if why := opForbiddenDest(ip); why != "" {
 		return opDest{}, errors.New(why)
+	} else if why := opLocalNetworkDest(ip); why != "" {
+		return opDest{}, errors.New(why)
 	}
 	return opDest{Host: h, Port: uint16(port)}, nil
 }
 
+// opLocalNetworkDest: "" when an address may be a destination on this box as
+// it stands, else why not. An anchored machine is a fleet's, and its ship
+// steps reach the fleet's private control planes, so it keeps private
+// destinations. On any other machine (a person's own, which no fleet has
+// anchored) an op reaches the public internet and nothing around the
+// machine: a private, ULA, CGNAT or reserved address (internalIP, the rule
+// the egress lane holds every box to) is refused, by address here and, for a
+// name, by every address it resolves to at apply (opResolveDests). Another
+// computer of theirs is reached through a bastion on that computer.
+func opLocalNetworkDest(ip net.IP) string {
+	if currentAnchor() != nil || !internalIP(ip) {
+		return ""
+	}
+	return "a destination is never an address on a private network (a home network, a VPN or a carrier NAT) " +
+		"on a machine no fleet has anchored; to reach another computer on it, install a bastion on that computer"
+}
+
 // opMetadataAddrs are the cloud metadata services that do not sit in
 // link-local space (Alibaba's, AWS's IPv6 one). They hand out the machine's
 // own credentials to anything that asks from it.
@@ -445,6 +470,12 @@ func opCredEnv(name string) string {
 	return b.String()
 }
 
+// verbsOnly: an action op with no program (interpreter: none). Its whole work
+// is its verbs, done by the bastion with their arguments fixed in the
+// manifest; nothing the Host wrote executes, so it needs no sandbox (a machine
+// with no overlay runs it), only the tools its verbs run.
+func (m *opManifest) verbsOnly() bool { return m.isAction() && m.Interpreter == opInterpreterNone }
+
 // opActionManifestOK is parseOpManifest's judgement of an action op.
 func opActionManifestOK(m *opManifest) error {
 	if len(m.Effects.Files)+len(m.Effects.Units)+len(m.Effects.Packages)+len(m.Effects.Network) > 0 {
@@ -489,6 +520,25 @@ func opActionManifestOK(m *opManifest) error {
 	if (len(verbs) > 0) != (m.Privilege == "root") {
 		return errors.New("op.yaml: an action op is privilege root exactly when it has verbs: they run with the bastion's own root")
 	}
+	if m.verbsOnly() {
+		if len(verbs) == 0 {
+			return errors.New("op.yaml: interpreter: none is an op whose verbs are its whole work, and it names none")
+		}
+		if len(m.Destinations) > 0 || m.Builder || len(m.Reads) > 0 {
+			return errors.New("op.yaml: destinations, builder and reads are a program's, and interpreter: none has no program")
+		}
+		named := map[string]bool{}
+		for _, v := range verbs {
+			if c := v.Args["credential"]; c != "" {
+				named[c] = true
+			}
+		}
+		for _, c := range m.Credentials {
+			if !named[c] {
+				return fmt.Errorf("op.yaml: credential %q is named by no verb, and interpreter: none has no program to hand it to", c)
+			}
+		}
+	}
 	return nil
 }
 

client-go/ops_action_linux.go

@@ -350,7 +350,9 @@ type opResolvedDests struct {
 // what the unit is allowed to reach, and the names go in the run's own
 // /etc/hosts (the machine's resolver is not reachable from the sandbox). A
 // destination that resolves to this machine, its loopback or nothing is
-// refused: a local service is never an op's destination.
+// refused: a local service is never an op's destination. On a machine no
+// fleet has anchored, so is one that resolves to a private network
+// (opLocalNetworkDest).
 func opResolveDests(ctx context.Context, dests []string) (*opResolvedDests, error) {
 	own := map[string]bool{}
 	for _, ip := range opActionOwnAddrs() {
@@ -379,6 +381,9 @@ func opResolveDests(ctx context.Context, dests []string) (*opResolvedDests, erro
 			if why := opForbiddenDest(ip); why != "" {
 				return nil, fmt.Errorf("destination %s resolves to %s: %s", d, ip, why)
 			}
+			if why := opLocalNetworkDest(ip); why != "" {
+				return nil, fmt.Errorf("destination %s resolves to %s: %s", d, ip, why)
+			}
 			if own[ip.String()] {
 				return nil, fmt.Errorf("destination %s resolves to %s, which is this machine", d, ip)
 			}

client-go/ops_action_local_linux_test.go

@@ -0,0 +1,237 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"strings"
+	"testing"
+)
+
+// RESULT: red before opLocalNetworkDest — on a local box a name that resolves
+// to a home network's address was put in the apply's allowlist.
+func TestALocalBoxRefusesANameThatResolvesToAPrivateNetworkAtApply(t *testing.T) {
+	localOpBox(t)
+	prevOwn, prevRes := opActionOwnAddrs, opActionResolve
+	opActionOwnAddrs = func() []net.IP { return nil }
+	opActionResolve = func(_ context.Context, h string) ([]net.IP, error) {
+		switch h {
+		case "nas.home.example":
+			return []net.IP{net.ParseIP("10.0.0.2")}, nil
+		case "split.example.com":
+			return []net.IP{net.ParseIP("203.0.113.10"), net.ParseIP("192.168.1.2")}, nil
+		case "forge.example.com":
+			return []net.IP{net.ParseIP("203.0.113.10")}, nil
+		}
+		return nil, fmt.Errorf("no")
+	}
+	t.Cleanup(func() { opActionOwnAddrs, opActionResolve = prevOwn, prevRes })
+
+	for _, d := range []string{"nas.home.example:80", "split.example.com:443"} {
+		if _, err := opResolveDests(context.Background(), []string{d}); err == nil ||
+			!strings.Contains(err.Error(), "private network") {
+			t.Errorf("%s: a local box resolves it into the allowlist: %v", d, err)
+		}
+	}
+	got, err := opResolveDests(context.Background(), []string{"forge.example.com:443"})
+	if err != nil || len(got.Addrs) != 1 || got.Addrs[0] != "203.0.113.10" {
+		t.Fatalf("a public name resolves to its address: %+v %v", got, err)
+	}
+
+	// An anchored fleet keeps the same name.
+	setupBox(t)
+	if got, err := opResolveDests(context.Background(), []string{"nas.home.example:80"}); err != nil || got.Addrs[0] != "10.0.0.2" {
+		t.Fatalf("an anchored box resolves a private control plane: %+v %v", got, err)
+	}
+}
+
+// A destination written as an address is judged again at apply by the anchor
+// the machine has then: an op held while the machine was anchored does not
+// reach a private address after the anchor is gone.
+func TestAPrivateDestinationHeldWhileAnchoredIsRefusedAtApplyOnceTheAnchorIsGone(t *testing.T) {
+	setupBox(t)
+	prevOwn := opActionOwnAddrs
+	opActionOwnAddrs = func() []net.IP { return nil }
+	t.Cleanup(func() { opActionOwnAddrs = prevOwn })
+	for _, d := range []string{"10.0.0.2:80", "[::ffff:10.0.0.2]:80"} {
+		if _, err := opResolveDests(context.Background(), []string{d}); err != nil {
+			t.Fatalf("%s: an anchored box reaches its private control plane: %v", d, err)
+		}
+	}
+	localOpBox(t)
+	for _, d := range []string{"10.0.0.2:80", "[::ffff:10.0.0.2]:80"} {
+		if _, err := opResolveDests(context.Background(), []string{d}); err == nil || !strings.Contains(err.Error(), "private network") {
+			t.Errorf("%s: held while anchored, reached after the anchor is gone: %v", d, err)
+		}
+	}
+}
+
+// A verb fetches too: tree.checkout fetches its repo, and k8s.set_image
+// fetches its repo to check ancestry, each with the bastion's own root and
+// outside the program's sandbox. On a local machine that fetch is held to
+// the rule a destination is: a repository whose host resolves to a private
+// network is never fetched, and no git runs for it. An interpreter: none op
+// is nothing but verbs, so this is the whole of its reach.
+//
+// RESULT: red before opFetchPin — the ancestry fetch ran git against the
+// name, which git resolved itself, so a name on a home network was fetched.
+func TestALocalBoxNeverFetchesAVerbsRepositoryFromAPrivateNetwork(t *testing.T) {
+	localOpBox(t)
+	prevOwn, prevRes := opActionOwnAddrs, opActionResolve
+	opActionOwnAddrs = func() []net.IP { return nil }
+	opActionResolve = func(_ context.Context, h string) ([]net.IP, error) {
+		switch h {
+		case "nas.home.example":
+			return []net.IP{net.ParseIP("10.0.0.2")}, nil
+		case "split.example.com":
+			return []net.IP{net.ParseIP("203.0.113.10"), net.ParseIP("::ffff:192.168.1.2")}, nil
+		case "meta.example.com":
+			return []net.IP{net.ParseIP("169.254.169.254")}, nil
+		}
+		return nil, fmt.Errorf("no")
+	}
+	t.Cleanup(func() { opActionOwnAddrs, opActionResolve = prevOwn, prevRes })
+
+	older, newer := strings.Repeat("a", 40), strings.Repeat("b", 40)
+	for repo, want := range map[string]string{
+		"https://nas.home.example/acme/app.git":  "private network",
+		"https://split.example.com/acme/app.git": "private network",
+		"https://meta.example.com/acme/app.git":  "link-local",
+	} {
+		err := opAncestryByFetch(repo, older, newer, nil)
+		if err == nil || !strings.Contains(err.Error(), want) {
+			t.Errorf("%s: a local box fetched it: %v", repo, err)
+		}
+	}
+	// The pin a public repository is fetched under: git is held to the
+	// address checked here and never looks the name up again.
+	prevGit := opGitPinnable
+	opGitPinnable = func() string { return "" }
+	t.Cleanup(func() { opGitPinnable = prevGit })
+	opActionResolve = func(_ context.Context, h string) ([]net.IP, error) {
+		return []net.IP{net.ParseIP("2001:db8::10")}, nil
+	}
+	if pin, err := opFetchPin(context.Background(), "https://forge.example.com:8443/acme/app.git"); err != nil ||
+		strings.Join(pin, " ") != "-c http.curloptResolve=forge.example.com:8443:[2001:db8::10]" {
+		t.Fatalf("a public repository is fetched pinned to its address: %q %v", pin, err)
+	}
+	// A git that would drop the pin is refused, never run unpinned.
+	opGitPinnable = func() string { return "git 2.34 cannot hold a fetch to one address" }
+	if _, err := opFetchPin(context.Background(), "https://forge.example.com/acme/app.git"); err == nil {
+		t.Fatal("a git that ignores the pin fetched unpinned")
+	}
+	// An anchored fleet fetches from its private forge, pinned to it.
+	opGitPinnable = func() string { return "" }
+	setupBox(t)
+	opActionResolve = func(_ context.Context, h string) ([]net.IP, error) {
+		return []net.IP{net.ParseIP("10.0.0.2")}, nil
+	}
+	if pin, err := opFetchPin(context.Background(), "https://nas.home.example/acme/app.git"); err != nil ||
+		strings.Join(pin, " ") != "-c http.curloptResolve=nas.home.example:443:10.0.0.2" {
+		t.Fatalf("an anchored box fetches from its private forge: %q %v", pin, err)
+	}
+}
+
+// An anchored machine keeps its fleet's private forges, but a verb's fetch
+// there is still never this machine, its loopback, a link-local address or a
+// cloud's metadata service: a name steered to one is refused before git runs.
+//
+// RESULT: red before opFetchPin ran on anchored machines — git fetched each
+// name itself, whatever it resolved to.
+func TestAnAnchoredBoxNeverFetchesAVerbsRepositoryFromItselfOrTheMetadataService(t *testing.T) {
+	setupBox(t)
+	prevOwn, prevRes := opActionOwnAddrs, opActionResolve
+	opActionOwnAddrs = func() []net.IP { return []net.IP{net.ParseIP("203.0.113.99")} }
+	opActionResolve = func(_ context.Context, h string) ([]net.IP, error) {
+		switch h {
+		case "lo.example.com":
+			return []net.IP{net.ParseIP("127.0.0.1")}, nil
+		case "mapped.example.com":
+			return []net.IP{net.ParseIP("203.0.113.10"), net.ParseIP("::ffff:127.0.0.1")}, nil
+		case "meta.example.com":
+			return []net.IP{net.ParseIP("169.254.169.254")}, nil
+		case "ali.example.com":
+			return []net.IP{net.ParseIP("100.100.100.200")}, nil
+		case "self.example.com":
+			return []net.IP{net.ParseIP("203.0.113.99")}, nil
+		}
+		return nil, fmt.Errorf("no")
+	}
+	t.Cleanup(func() { opActionOwnAddrs, opActionResolve = prevOwn, prevRes })
+	older, newer := strings.Repeat("a", 40), strings.Repeat("b", 40)
+	for repo, want := range map[string]string{
+		"https://lo.example.com/acme/app.git":     "loopback",
+		"https://mapped.example.com/acme/app.git": "loopback",
+		"https://meta.example.com/acme/app.git":   "link-local",
+		"https://ali.example.com/acme/app.git":    "metadata service",
+		"https://self.example.com/acme/app.git":   "this machine",
+	} {
+		err := opAncestryByFetch(repo, older, newer, nil)
+		if err == nil || !strings.Contains(err.Error(), want) {
+			t.Errorf("%s: an anchored box fetched it: %v", repo, err)
+		}
+	}
+}
+
+// k8s.set_image hands an image to the cluster, and the machine's container
+// runtime pulls it by name, outside the bastion's walls. On a local machine
+// an image whose registry is on the private network around it is refused
+// where the bastion takes the image, so the runtime is never sent there; a
+// Docker Hub repository and a public registry pass; an anchored fleet keeps
+// its private registry.
+//
+// RESULT: red before opRegistryOK — the plan took a receipt for an image on a
+// home network's registry and went on to the live image's record.
+func TestALocalBoxNeverPutsLiveAnImageFromARegistryOnItsNetwork(t *testing.T) {
+	localOpBox(t)
+	prevOwn, prevRes := opActionOwnAddrs, opActionResolve
+	opActionOwnAddrs = func() []net.IP { return nil }
+	opActionResolve = func(_ context.Context, h string) ([]net.IP, error) {
+		switch h {
+		case "nas.home.example":
+			return []net.IP{net.ParseIP("10.0.0.2")}, nil
+		case "registry.example.com":
+			return []net.IP{net.ParseIP("203.0.113.10")}, nil
+		}
+		return nil, fmt.Errorf("no")
+	}
+	t.Cleanup(func() { opActionOwnAddrs, opActionResolve = prevOwn, prevRes })
+	useAncestry(t, func(_, _, _ string, _ []string) error { return nil })
+	ctx := context.Background()
+	commit := strings.Repeat("c", 40)
+	for i, tc := range []struct{ image, want string }{
+		{"nas.home.example:5000/acme/web", "private network"},
+		{"10.0.0.2:5000/acme/web", "private network"},
+		{"192.168.1.2/acme/web", "private network"},
+		{"localhost:5000/acme/web", "loopback"},
+		{"169.254.169.254/acme/web", "link-local"},
+		{"registry.example.com/acme/web", ""},
+		{"acme/web", ""},
+	} {
+		digest := "sha256:" + strings.Repeat(fmt.Sprintf("%x", i+1), 64)
+		if _, err := opIssueReceipts("r", "web-build", strings.Repeat("e", 64), "{}", []opResultImage{{Image: tc.image,
+			Digest: digest, Source: tRepo, Commit: commit}}); err != nil {
+			t.Fatal(err)
+		}
+		f := &fakeKube{containers: map[string]string{"bridge": tc.image + "@sha256:" + strings.Repeat("0", 64)}}
+		useFakeKube(t, f)
+		line := setImageLine(digest)
+		line.Args["image"] = tc.image
+		_, err := opImagePlan(ctx, line, nil)
+		if tc.want != "" {
+			if err == nil || !strings.Contains(err.Error(), tc.want) || !strings.Contains(err.Error(), "comes from the registry") {
+				t.Errorf("%s: a local box would put it live: %v", tc.image, err)
+			}
+			if _, err := opImageDo(ctx, line, nil, nil, ""); err == nil || len(f.sets()) != 0 {
+				t.Errorf("%s: and set it: %v %v", tc.image, err, f.sets())
+			}
+		} else if err != nil && strings.Contains(err.Error(), "comes from the registry") {
+			t.Errorf("%s: a public registry is refused: %v", tc.image, err)
+		}
+	}
+	// An anchored fleet keeps its private registry.
+	setupBox(t)
+	if err := opRegistryOK(ctx, "nas.home.example:5000/acme/web@sha256:"+strings.Repeat("1", 64)); err != nil {
+		t.Fatalf("an anchored box pulls from its private registry: %v", err)
+	}
+}

client-go/ops_action_local_test.go

@@ -0,0 +1,122 @@
+//go:build !windows
+
+package main
+
+import (
+	"crypto/ed25519"
+	"encoding/base64"
+	"os"
+	"strings"
+	"testing"
+	"time"
+)
+
+// An action op on a person's own machine (local, unanchored) reaches the
+// public internet and nothing around the machine; an anchored fleet keeps its
+// private destinations, because its ship steps reach private control planes.
+// The addresses are documentation and private examples, invented here.
+
+// localOpBox: a local machine, anchored by nobody, with one pairing whose
+// pairing dir pins a signing key we hold.
+func localOpBox(t *testing.T) (dcn string, priv ed25519.PrivateKey) {
+	t.Helper()
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	p, _ := modePath()
+	if err := os.WriteFile(p, []byte(`{"mode":"local"}`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	writePairing(t, tAnchor)
+	if currentAnchor() != nil {
+		t.Fatal("the local box must not be anchored")
+	}
+	dcn = t.TempDir()
+	pub, priv, _ := ed25519.GenerateKey(nil)
+	if err := dcnSaveFile(dcn, &dcnGrantFile{Stores: map[string]dcnGrantRec{},
+		VerifyPubkey: base64.StdEncoding.EncodeToString(pub)}); err != nil {
+		t.Fatal(err)
+	}
+	return dcn, priv
+}
+
+// actionBundle: an unprivileged action op declaring one destination.
+func actionBundle(dest string) []opFile {
+	man := `name: optest-reach
+version: 1.0.0
+summary: An action op that reaches one destination.
+kind: action
+target: machine
+privilege: user
+interpreter: /bin/sh
+time_limit: 30
+destinations: ["` + dest + `"]
+modes: [dry_run, apply, verify]
+undo: none
+`
+	return []opFile{
+		{Path: "op.yaml", Mode: 0o644, B64: base64.StdEncoding.EncodeToString([]byte(man))},
+		{Path: "run", Mode: 0o755, B64: base64.StdEncoding.EncodeToString([]byte("#!/bin/sh\ntrue\n"))},
+	}
+}
+
+// syncAction drives op_sync for an action op declaring dest, under op_run
+// terms signed by priv; it returns the op's output, its error text and code.
+func syncAction(t *testing.T, dcn string, priv ed25519.PrivateKey, dest string) (string, string, int) {
+	t.Helper()
+	files := actionBundle(dest)
+	sha, err := opDirDigest(files)
+	if err != nil {
+		t.Fatal(err)
+	}
+	terms := opTerm(opKindRun, sha, `{}`, "", 1, time.Hour, "user")
+	terms["op"] = "optest-reach"
+	pair := signTermsPair(t, priv, terms)
+	return driveJob(t, tAnchor, mgmtJob{Op: "op_sync", Args: append(pair, bundleB64(files))}, "", dcn)
+}
+
+// RESULT: red before opLocalNetworkDest — a local box held an op declaring
+// 10.0.0.2:80 (a home network's address), and its apply would have reached it.
+func TestALocalBoxRefusesAnActionOpThatDeclaresAPrivateNetwork(t *testing.T) {
+	dcn, priv := localOpBox(t)
+	for _, dest := range []string{
+		"10.0.0.2:80",         // RFC 1918
+		"192.168.1.2:443",     // a home router's range
+		"172.16.0.2:8080",     // RFC 1918
+		"100.64.0.2:22",       // carrier NAT, and VPN meshes that use it
+		"[fd00::2]:80",        // ULA
+		"[64:ff9b::a00:2]:80", // 10.0.0.2 through NAT64
+		"[2002:a00:2::1]:80",  // 10.0.0.2 through 6to4
+		"198.18.0.2:80",       // benchmarking, never a public host
+	} {
+		out, errOut, code := syncAction(t, dcn, priv, dest)
+		if code == 0 || strings.Contains(out, `"held"`) {
+			t.Errorf("%s: a local box held an op declaring it: %d %s %s", dest, code, out, errOut)
+			continue
+		}
+		if !strings.Contains(errOut, "private network") || !strings.Contains(errOut, "install a bastion on that computer") {
+			t.Errorf("%s: the refusal must say why and what to do instead: %q", dest, errOut)
+		}
+	}
+	// The public internet is still a destination.
+	if out, errOut, code := syncAction(t, dcn, priv, "203.0.113.10:443"); code != 0 || !strings.Contains(out, `"held"`) {
+		t.Fatalf("a public destination is held on a local box: %d %s %s", code, out, errOut)
+	}
+	// A name is judged at apply, by every address it resolves to
+	// (opResolveDests); at sync it is only a name.
+	if out, errOut, code := syncAction(t, dcn, priv, "forge.example.com:443"); code != 0 || !strings.Contains(out, `"held"`) {
+		t.Fatalf("a destination by name is held on a local box: %d %s %s", code, out, errOut)
+	}
+}
+
+func TestAnAnchoredFleetKeepsItsPrivateDestinations(t *testing.T) {
+	dcn, priv := opTestBox(t)
+	enrollFactor(t, dcn)
+	for _, dest := range []string{"10.0.0.2:80", "100.64.0.2:6443", "[fd00::2]:80"} {
+		if out, errOut, code := syncAction(t, dcn, priv, dest); code != 0 || !strings.Contains(out, `"held"`) {
+			t.Errorf("%s: an anchored box holds a ship step to a private control plane: %d %s %s", dest, code, out, errOut)
+		}
+	}
+	// What every box refuses stays refused.
+	if _, errOut, code := syncAction(t, dcn, priv, "127.0.0.1:80"); code == 0 || !strings.Contains(errOut, "loopback") {
+		t.Fatalf("loopback stays refused on an anchored box: %d %q", code, errOut)
+	}
+}

client-go/ops_bounds.go

@@ -0,0 +1,516 @@
+package main
+
+// ops_bounds.go — what an op_grant bounds besides the params, and the record
+// that lets this machine hold it there (bastion 0.58.0).
+//
+// The bounds text an op_grant carries (ops.go parseBounds) names params by
+// their names, which match ^[a-z]. Two keys beginning with "_" bound the RUN
+// rather than a param, so they can never collide with one:
+//
+//	"_window": {"days": ["mon", …, "sun"], "from": "HH:MM", "to": "HH:MM", "tz": "Europe/Berlin"}
+//	           applies run only inside this window of the machine's clock, read
+//	           in tz (an IANA name, "UTC" when absent). days is optional (every
+//	           day when absent). from > to wraps midnight: the window opens on a
+//	           listed day and closes the next morning.
+//	"_rate":   {"per_day": n, "min_interval_s": s}
+//	           at most n applies in any 24 hours, and s seconds between two.
+//	           Either may be absent, not both.
+//
+// Either key may be null, which bounds nothing. Any other "_" key is refused:
+// a bound this machine does not enforce would read on the card as a limit the
+// person never got. An older box refuses both as "names no param", so a grant
+// carrying them fails closed there.
+//
+// An apply outside the window or the rate is NOT NOW, not refused: nothing
+// runs, no use is spent, and it is no strike toward the quarantine — the Host
+// asked for something the person allows, at a time they do not. The answer is
+// an 'O' frame {"state": "not_now", …} and exit 75 (sysexits EX_TEMPFAIL).
+// Identity and argument failures stay refusals, as before.
+//
+// THE RECORD. ops.json keeps, for each grant, the times of the applies that
+// spent a use (the run log, which the rate is counted from, so it holds across
+// a restart), the key that approved it, and a MAC over the record under a key
+// this machine derives from its own encryption key. A record edited outside
+// the bastion — a run removed, a use given back, the approver changed — no
+// longer checks out, and the grant is unusable until the person drops it and
+// approves again. A grant installed by a bastion older than this one carries
+// neither and is unusable too (none were held when it shipped).
+//
+// THE APPROVER. The device key that signed the approval, or the factor enrolled
+// at this console. A grant whose approver is no longer pinned (the device key
+// unpinned, the factor re-enrolled) is dead: unpinning a device drops every
+// grant it approved, here and in every pairing.
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+	// The zone database is in the binary: a window's tz reads the same on a
+	// machine with no tzdata installed, and a grant is never refused at one
+	// box and accepted at another for want of a file.
+	_ "time/tzdata"
+
+	"github.com/gorilla/websocket"
+)
+
+const (
+	opBoundWindow     = "_window"
+	opBoundRate       = "_rate"
+	opRateMinInterval = 30 * 24 * 60 * 60 // seconds: the longest a grant lives
+	// opNotNowExit is the exit an apply that was held to its window or its
+	// rate ends with (sysexits.h EX_TEMPFAIL: "try again later").
+	opNotNowExit = 75
+	opNotNow     = "not_now"
+)
+
+var (
+	opHHMMRe = regexp.MustCompile(`^([01][0-9]|2[0-3]):[0-5][0-9]$`)
+	opTZRe   = regexp.MustCompile(`^[A-Za-z][A-Za-z0-9_+-]*(/[A-Za-z0-9_+-]+){0,2}$`)
+	opDays   = []string{"sun", "mon", "tue", "wed", "thu", "fri", "sat"} // time.Weekday order
+	// opNow is the machine's clock as the run gate reads it (a seam for the
+	// tests, which move it).
+	opNow = time.Now
+)
+
+type opWindow struct {
+	Days []string `json:"days,omitempty"`
+	From string   `json:"from"`
+	To   string   `json:"to"`
+	TZ   string   `json:"tz,omitempty"`
+
+	loc      *time.Location
+	from, to int // minutes past midnight
+	day      [7]bool
+}
+
+type opRate struct {
+	PerDay      *int `json:"per_day,omitempty"`
+	MinInterval *int `json:"min_interval_s,omitempty"`
+}
+
+// opGrantBounds is the whole of what an op_grant's bounds text says.
+type opGrantBounds struct {
+	Params map[string]opBound
+	Window *opWindow
+	Rate   *opRate
+}
+
+func strictJSON(raw []byte, into any) error {
+	dec := json.NewDecoder(strings.NewReader(string(raw)))
+	dec.DisallowUnknownFields()
+	if err := dec.Decode(into); err != nil {
+		return err
+	}
+	if dec.More() {
+		return errors.New("trailing data")
+	}
+	return nil
+}
+
+func parseOpWindow(raw json.RawMessage) (*opWindow, error) {
+	if string(raw) == "null" {
+		return nil, nil
+	}
+	var w opWindow
+	if err := strictJSON(raw, &w); err != nil {
+		return nil, errors.New(`bound "_window": {"days": [mon..sun], "from": "HH:MM", "to": "HH:MM", "tz": "<IANA zone>"}`)
+	}
+	if !opHHMMRe.MatchString(w.From) || !opHHMMRe.MatchString(w.To) {
+		return nil, errors.New(`bound "_window": from and to are 24-hour "HH:MM"`)
+	}
+	if w.From == w.To {
+		return nil, errors.New(`bound "_window": from and to are the same minute, which is no window`)
+	}
+	hm := func(s string) int { h, _ := strconv.Atoi(s[:2]); m, _ := strconv.Atoi(s[3:]); return h*60 + m }
+	w.from, w.to = hm(w.From), hm(w.To)
+	if w.Days != nil {
+		if len(w.Days) == 0 || len(w.Days) > 7 {
+			return nil, errors.New(`bound "_window": days names 1..7 days, or is left out for every day`)
+		}
+		for _, d := range w.Days {
+			i := opDayIndex(d)
+			if i < 0 {
+				return nil, fmt.Errorf(`bound "_window": %q is not a day (mon, tue, wed, thu, fri, sat, sun)`, d)
+			}
+			if w.day[i] {
+				return nil, fmt.Errorf(`bound "_window": %q is named twice`, d)
+			}
+			w.day[i] = true
+		}
+	} else {
+		for i := range w.day {
+			w.day[i] = true
+		}
+	}
+	tz := w.TZ
+	if tz == "" {
+		tz = "UTC"
+	}
+	if !opTZRe.MatchString(tz) || strings.EqualFold(tz, "local") {
+		return nil, fmt.Errorf(`bound "_window": tz %q is not an IANA zone name`, w.TZ)
+	}
+	loc, err := time.LoadLocation(tz)
+	if err != nil {
+		return nil, fmt.Errorf(`bound "_window": tz %q is not a zone this machine knows`, w.TZ)
+	}
+	w.loc = loc
+	return &w, nil
+}
+
+func opDayIndex(d string) int {
+	for i, s := range opDays {
+		if s == d {
+			return i
+		}
+	}
+	return -1
+}
+
+func parseOpRate(raw json.RawMessage) (*opRate, error) {
+	if string(raw) == "null" {
+		return nil, nil
+	}
+	var r opRate
+	if err := strictJSON(raw, &r); err != nil {
+		return nil, errors.New(`bound "_rate": {"per_day": n, "min_interval_s": s}`)
+	}
+	if r.PerDay == nil && r.MinInterval == nil {
+		return nil, errors.New(`bound "_rate": names per_day, min_interval_s or both`)
+	}
+	if r.PerDay != nil && (*r.PerDay < 1 || *r.PerDay > opGrantUsesMax) {
+		return nil, fmt.Errorf(`bound "_rate": per_day is 1..%d`, opGrantUsesMax)
+	}
+	if r.MinInterval != nil && (*r.MinInterval < 1 || *r.MinInterval > opRateMinInterval) {
+		return nil, fmt.Errorf(`bound "_rate": min_interval_s is 1..%d`, opRateMinInterval)
+	}
+	return &r, nil
+}
+
+// parseGrantBounds reads an op_grant's bounds text: the params (parseBounds'
+// rules, each inside the schema) and the run bounds above.
+func parseGrantBounds(m *opManifest, raw string) (*opGrantBounds, error) {
+	if len(raw) > opParamsMaxBytes {
+		return nil, errors.New("bounds too large")
+	}
+	var top map[string]json.RawMessage
+	if err := json.Unmarshal([]byte(raw), &top); err != nil || top == nil {
+		return nil, errors.New("bounds are not a JSON object of {param: {min, max | values | prefix | fixed}, _window, _rate}")
+	}
+	out := &opGrantBounds{}
+	params := map[string]json.RawMessage{}
+	for k, v := range top {
+		var err error
+		switch {
+		case k == opBoundWindow:
+			out.Window, err = parseOpWindow(v)
+		case k == opBoundRate:
+			out.Rate, err = parseOpRate(v)
+		case strings.HasPrefix(k, "_"):
+			err = fmt.Errorf("bound %q is not one this machine enforces (%s, %s)", k, opBoundWindow, opBoundRate)
+		default:
+			params[k] = v
+		}
+		if err != nil {
+			return nil, err
+		}
+	}
+	prest, _ := json.Marshal(params)
+	p, err := parseParamBounds(m, string(prest))
+	if err != nil {
+		return nil, err
+	}
+	out.Params = p
+	return out, nil
+}
+
+// inside: is t inside the window? A window that wraps midnight belongs to the
+// day it opens on.
+func (w *opWindow) inside(t time.Time) bool {
+	l := t.In(w.loc)
+	mins := l.Hour()*60 + l.Minute()
+	today := int(l.Weekday())
+	if w.from < w.to {
+		return w.day[today] && mins >= w.from && mins < w.to
+	}
+	yesterday := (today + 6) % 7
+	return (w.day[today] && mins >= w.from) || (w.day[yesterday] && mins < w.to)
+}
+
+// next is when the window next opens after t (zero when it never does, which
+// a parsed window cannot be).
+func (w *opWindow) next(t time.Time) time.Time {
+	l := t.In(w.loc)
+	for i := 0; i <= 8; i++ {
+		d := l.AddDate(0, 0, i)
+		open := time.Date(d.Year(), d.Month(), d.Day(), w.from/60, w.from%60, 0, 0, w.loc)
+		if open.After(t) && w.day[int(open.Weekday())] {
+			return open
+		}
+	}
+	return time.Time{}
+}
+
+func (w *opWindow) words() string {
+	days := "every day"
+	if len(w.Days) > 0 && len(w.Days) < 7 {
+		days = strings.Join(w.Days, ",")
+	}
+	return fmt.Sprintf("%s %s-%s %s", days, w.From, w.To, w.loc.String())
+}
+
+// opNotNowWhy is the run gate on window and rate: "" when an apply may run at
+// now, else why not, which bound held it, and when it next could.
+func opNotNowWhy(b *opGrantBounds, runs []time.Time, now time.Time) (why, bound string, next time.Time) {
+	if b.Window != nil && !b.Window.inside(now) {
+		return "outside the approved window (" + b.Window.words() + ")", opBoundWindow, b.Window.next(now)
+	}
+	if b.Rate == nil || len(runs) == 0 {
+		return "", "", time.Time{}
+	}
+	last := runs[len(runs)-1]
+	if b.Rate.MinInterval != nil {
+		gap := time.Duration(*b.Rate.MinInterval) * time.Second
+		if now.Sub(last) < gap {
+			return fmt.Sprintf("the last run was %s ago; the approval keeps %s between runs",
+				now.Sub(last).Round(time.Second), gap), opBoundRate, last.Add(gap)
+		}
+	}
+	if b.Rate.PerDay != nil {
+		var day []time.Time
+		for _, r := range runs {
+			if now.Sub(r) < 24*time.Hour {
+				day = append(day, r)
+			}
+		}
+		if len(day) >= *b.Rate.PerDay {
+			return fmt.Sprintf("%d run(s) in the last 24 hours; the approval allows %d", len(day), *b.Rate.PerDay),
+				opBoundRate, day[len(day)-*b.Rate.PerDay].Add(24 * time.Hour)
+		}
+	}
+	return "", "", time.Time{}
+}
+
+// sendNotNow answers an apply that was held to its window or rate: recorded,
+// never a strike, nothing spent.
+func sendNotNow(ws *websocket.Conn, dir string, t *opTerms, why, bound string, next time.Time) {
+	out := map[string]any{"state": opNotNow, "grant": t.Nonce, "op": t.Op, "why": why, "bound": bound}
+	if !next.IsZero() {
+		out["next"] = next.UTC().Format(time.RFC3339)
+	}
+	dcnAudit(dir, "op_grant_run", 0, t.Op+"@"+t.SHA256[:12], "not now "+t.Nonce[:8]+": "+truncate(why, mgmtAuditWhyMax))
+	b, _ := json.Marshal(out)
+	sendMgmt(ws, 'O', b)
+	sendMgmtExit(ws, opNotNowExit)
+}
+
+// ── the record ──────────────────────────────────────────────────────────────
+
+// opGrantMACKey is this machine's key for its grant records, derived from its
+// encryption key (which lives in the machine's record, masked from every op,
+// and is never silently replaced).
+func opGrantMACKey() ([]byte, error) {
+	_, priv, err := opEncKey()
+	if err != nil {
+		return nil, err
+	}
+	h := sha256.New()
+	h.Write([]byte("privatae-bastion op-grant record v1\x00"))
+	h.Write(priv[:])
+	return h.Sum(nil), nil
+}
+
+// opGrantRecMAC covers every field of the record, the grant's nonce with it,
+// each framed by its length (argsDigest's framing).
+func opGrantRecMAC(nonce string, rec *opGrantRec) (string, error) {
+	key, err := opGrantMACKey()
+	if err != nil {
+		return "", err
+	}
+	parts := []string{"v1", nonce, rec.TermsCanonical, rec.Signature, rec.InstalledAt,
+		strconv.Itoa(rec.UsesLeft), rec.Dropped, rec.Approver, strconv.Itoa(len(rec.Runs))}
+	parts = append(parts, rec.Runs...)
+	m := hmac.New(sha256.New, key)
+	m.Write([]byte(argsDigest(parts)))
+	return hex.EncodeToString(m.Sum(nil)), nil
+}
+
+func opGrantRecSeal(nonce string, rec *opGrantRec) error {
+	mac, err := opGrantRecMAC(nonce, rec)
+	if err != nil {
+		return fmt.Errorf("this machine cannot seal the grant's record: %v", err)
+	}
+	rec.MAC = mac
+	return nil
+}
+
+const opGrantTampered = "the record of this grant on this machine does not check out (changed outside the bastion); " +
+	"it is held unusable — drop it and approve it again"
+
+// opGrantRecCheck: the record is this machine's own (its MAC), the run log
+// reads in order and none of it is in the future, and the uses left are the
+// uses granted less the runs logged. Returns the run times.
+func opGrantRecCheck(nonce string, rec *opGrantRec, t *opTerms, now time.Time) ([]time.Time, error) {
+	if rec.MAC == "" || rec.Approver == "" {
+		return nil, errors.New("this grant was installed before this machine kept who approved it and what ran under it; approve it again")
+	}
+	want, err := opGrantRecMAC(nonce, rec)
+	if err != nil {
+		return nil, err
+	}
+	if !hmac.Equal([]byte(want), []byte(rec.MAC)) {
+		return nil, errors.New(opGrantTampered)
+	}
+	runs := make([]time.Time, 0, len(rec.Runs))
+	for _, s := range rec.Runs {
+		r, err := time.Parse(time.RFC3339Nano, s)
+		if err != nil || r.After(now.Add(deviceClockSkew)) || (len(runs) > 0 && r.Before(runs[len(runs)-1])) {
+			return nil, errors.New(opGrantTampered)
+		}
+		runs = append(runs, r)
+	}
+	if t != nil && rec.UsesLeft != t.Uses-len(runs) {
+		return nil, errors.New(opGrantTampered)
+	}
+	return runs, nil
+}
+
+// ── the approver ────────────────────────────────────────────────────────────
+
+// stepupFactorFingerprint names the factor enrolled at this console for a
+// pairing, without its secret: a re-enrolled factor is another one. "" when
+// none is enrolled.
+func stepupFactorFingerprint(dir string) string {
+	f, err := stepupLoad(dir)
+	if err != nil || f.SecretB32 == "" || f.EnrolledAt == "" {
+		return ""
+	}
+	sum := sha256.Sum256([]byte("privatae-bastion stepup factor v1\x00" + f.SecretB32 + "\x00" + f.EnrolledAt))
+	return hex.EncodeToString(sum[:16])
+}
+
+// consumeApprovalKeyed is consumeApproval that also names the key that gave
+// the approval: "device:<public key>" or "console:<factor fingerprint>".
+func consumeApprovalKeyed(dir, approval, purpose string) (id, key string, err error) {
+	if isDeviceApproval(approval) {
+		var a deviceApproval
+		_ = json.Unmarshal([]byte(strings.TrimSpace(approval)), &a)
+		if id, err = consumeApproval(dir, approval, purpose); err != nil {
+			return "", "", err
+		}
+		return id, "device:" + a.Key, nil
+	}
+	fp := stepupFactorFingerprint(dir)
+	if id, err = consumeApproval(dir, approval, purpose); err != nil {
+		return "", "", err
+	}
+	if fp == "" {
+		return "", "", errors.New("the approval came from this console with no factor enrolled to keep it under")
+	}
+	return id, "console:" + fp, nil
+}
+
+// opApproverLive: is the key that approved a grant still pinned here?
+func opApproverLive(dir, approver string) bool {
+	kind, key, _ := strings.Cut(approver, ":")
+	switch kind {
+	case "device":
+		for _, k := range deviceKeys() {
+			if k == key && key != "" {
+				return true
+			}
+		}
+	case "console":
+		return key != "" && key == stepupFactorFingerprint(dir)
+	}
+	return false
+}
+
+func opApproverWords(approver string) string {
+	kind, key, _ := strings.Cut(approver, ":")
+	if kind == "device" {
+		return "approval device " + truncate(key, 12)
+	}
+	return "this console's factor " + truncate(key, 12)
+}
+
+// ── taking grants back ──────────────────────────────────────────────────────
+
+// opsDropWhere drops every held grant in one pairing that match says to,
+// sealing each record again. Returns the nonces dropped.
+func opsDropWhere(dcnDir, why string, match func(nonce string, rec *opGrantRec) bool) ([]string, error) {
+	opsMu.Lock()
+	defer opsMu.Unlock()
+	f := opsLoad(dcnDir)
+	var dropped []string
+	for nonce, rec := range f.Grants {
+		if rec.Dropped != "" || !match(nonce, &rec) {
+			continue
+		}
+		rec.Dropped = opNow().UTC().Format(time.RFC3339) + " " + why
+		rec.UsesLeft = 0
+		// A record that can no longer be sealed is still dropped: the drop is
+		// what makes it unusable, and an unsealed record is unusable anyway.
+		_ = opGrantRecSeal(nonce, &rec)
+		f.Grants[nonce] = rec
+		dropped = append(dropped, nonce)
+	}
+	if len(dropped) == 0 {
+		return nil, nil
+	}
+	return dropped, opsSave(dcnDir, f)
+}
+
+// opsDropApprovedBy drops, in every pairing, the grants a device key approved
+// (the key is being unpinned). Returns how many.
+func opsDropApprovedBy(approver string) int {
+	cfgs, err := loadPairings()
+	if err != nil {
+		return 0
+	}
+	n := 0
+	for _, c := range cfgs {
+		if c == nil || c.dcnDir() == "" {
+			continue
+		}
+		d, _ := opsDropWhere(c.dcnDir(), "its approving key was unpinned", func(_ string, rec *opGrantRec) bool {
+			return rec.Approver == approver
+		})
+		n += len(d)
+	}
+	return n
+}
+
+// op_grant_drop <grant nonce | all>: the Host (or the app, through it) takes
+// a grant back. A tighten (writes.go opTightens): never held by the
+// quarantine, never waiting on an approval. A grant not held here is already
+// gone, which is what was asked for.
+func handleOpGrantDrop(ws *websocket.Conn, dir string, args []string) {
+	if dir == "" || len(args) < 1 || strings.TrimSpace(args[0]) == "" {
+		opFail(ws, "op_grant_drop: need <grant> or all")
+		return
+	}
+	which := strings.TrimSpace(args[0])
+	dropped, err := opsDropWhere(dir, "taken back by the host", func(nonce string, _ *opGrantRec) bool {
+		return which == "all" || nonce == which
+	})
+	if err != nil {
+		opFail(ws, "op_grant_drop: could not record the drop: "+err.Error())
+		return
+	}
+	if dropped == nil {
+		dropped = []string{}
+	}
+	for _, n := range dropped {
+		dcnAudit(dir, "op_grant_drop", 0, truncate(n, 8), "dropped by the host")
+	}
+	b, _ := json.Marshal(map[string]any{"state": "dropped", "dropped": dropped})
+	sendMgmt(ws, 'O', b)
+	sendMgmtExit(ws, 0)
+}

client-go/ops_exec_other.go

@@ -79,6 +79,15 @@ func opRunAction(_ string, _ *opManifest, _ *opTerms, _, _ string, _ []string, _
 	return nil, errors.New(why)
 }
 
+// opVerbsReport: no verb runs on this platform.
+func opVerbsReport() map[string]any {
+	out := map[string]any{}
+	for _, verb := range opVerbNames() {
+		out[verb] = map[string]any{"ok": false, "why": "no op runs on this platform yet"}
+	}
+	return out
+}
+
 func opActionOuterMain(_ string) int { return 125 }
 func opActionChildMain(_ string) int { return 125 }
 func opActionProbeMain(_ string) int { return 125 }

client-go/ops_plan_linux.go

@@ -245,9 +245,11 @@ func planRunLine(dir, planB64, nArg, recB64 string, credBlobs []string) (map[str
 	if _, err := opOpenCreds(credBlobs, m, p.Nonce, false); err != nil {
 		return nil, err
 	}
-	if ok, why := opActionAvailable(); !ok {
+	if !m.verbsOnly() {
+		if ok, why := opActionCheck(); !ok {
 			return nil, errors.New("this machine cannot run an action op: " + why)
 		}
+	}
 	if err := planRecordVersion(p.Pipeline, p.Version); err != nil {
 		return nil, fmt.Errorf("could not record the plan's version: %v", err)
 	}

client-go/ops_skill_bounds_test.go

@@ -0,0 +1,506 @@
+//go:build !windows
+
+package main
+
+// ops_skill_bounds_test.go — a grant held to a window and a rate on the
+// machine (ops_bounds.go): "not now" is no strike and spends nothing, the run
+// log holds across a restart and refuses being edited, a grant dies with the
+// key that approved it, and a drop goes through a quarantine. And the op with
+// no program (interpreter: none): no run file, no sandbox needed, while a
+// program op still needs one.
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func userFixture() []opFile {
+	files := opFixture("/srv/optest", "")
+	files[0].B64 = base64.StdEncoding.EncodeToString([]byte(strings.Replace(fmt.Sprintf(opTestManifest, "/srv/optest"),
+		"privilege: root", "privilege: user", 1)))
+	return files
+}
+
+// grantBox installs a user grant with these bounds under a console approval,
+// and stands in for the sandbox: each run under it is counted, never run.
+func grantBox(t *testing.T, bounds string, uses int, approve func(dcn, purpose string) string) (dcn, nonce string, ran *int) {
+	t.Helper()
+	dcn, priv := opTestBox(t)
+	files := userFixture()
+	sha, _ := opDirDigest(files)
+	gt := opTerm(opKindGrant, sha, "", bounds, uses, time.Hour, "user")
+	purpose, err := purposeForOpGrant(&opTerms{Server: gt["server"].(string), Op: "write-hello", SHA256: sha,
+		Bounds: bounds, Expires: gt["expires"].(string), Uses: uses})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if approve == nil {
+		approve = grantConsoleApproval(t)
+	}
+	gt["approval"] = approve(dcn, purpose)
+	if _, errOut, code := driveJob(t, tAnchor, mgmtJob{Op: "op_sync", Args: append(signTermsPair(t, priv, gt), bundleB64(files))}, "", dcn); code != 0 {
+		t.Fatalf("the grant installs: %d %s", code, errOut)
+	}
+	n := 0
+	prev := opGrantExec
+	opGrantExec = func(_ string, tm *opTerms, mode, _, _ string, _ []string) (*opReport, *opRunRecord, error) {
+		n++
+		id, _ := newID()
+		return &opReport{Mode: mode, Changes: []opChange{}}, &opRunRecord{ID: id, Op: tm.Op, SHA256: tm.SHA256, Mode: mode}, nil
+	}
+	t.Cleanup(func() { opGrantExec = prev })
+	return dcn, gt["nonce"].(string), &n
+}
+
+func grantConsoleApproval(t *testing.T) func(dcn, purpose string) string {
+	return func(dcn, purpose string) string {
+		t.Helper()
+		enrollFactor(t, dcn)
+		raw, _ := b32decode(tSecret)
+		a, err := stepupIssueApproval(dcn, hotp(raw, time.Now().Unix()/stepupPeriod), purpose)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return a
+	}
+}
+
+func atClock(t *testing.T, at *time.Time) {
+	prev := opNow
+	opNow = func() time.Time { return *at }
+	t.Cleanup(func() { opNow = prev })
+}
+
+const grantParams = `{"name":"x","count":1,"kind":"a"}`
+
+func grantApply(t *testing.T, dcn, nonce string) (string, string, int) {
+	t.Helper()
+	return driveJob(t, tAnchor, mgmtJob{Op: "op_grant_run", Args: []string{nonce, opModeApply, grantParams}}, "", dcn)
+}
+
+func strikes() int { return len(quarantineLoad().Pairing[tAnchor].refusalsNow()) }
+
+func usesLeft(t *testing.T, dcn, nonce string) int {
+	t.Helper()
+	rec, ok := opsLoad(dcn).Grants[nonce]
+	if !ok {
+		t.Fatal("no record")
+	}
+	return rec.UsesLeft
+}
+
+// ── the grammar ─────────────────────────────────────────────────────────────
+
+func TestGrantRunBoundsGrammar(t *testing.T) {
+	setupBox(t)
+	m, _ := parseOpManifest([]byte(fmt.Sprintf(opTestManifest, "/srv/optest")))
+	for _, ok := range []string{
+		`{"_window":{"from":"02:00","to":"04:00"}}`,
+		`{"_window":{"days":["mon","fri"],"from":"22:00","to":"06:00","tz":"Europe/Berlin"},"count":{"max":2}}`,
+		`{"_rate":{"per_day":3,"min_interval_s":600}}`,
+		`{"_rate":{"per_day":1}}`,
+		`{"_window":null,"_rate":null}`,
+	} {
+		if _, err := parseGrantBounds(m, ok); err != nil {
+			t.Errorf("%s parses: %v", ok, err)
+		}
+	}
+	for name, bad := range map[string]string{
+		"an unknown run bound":     `{"_when":{"from":"02:00","to":"04:00"}}`,
+		"a day that is not one":    `{"_window":{"days":["mon","funday"],"from":"02:00","to":"04:00"}}`,
+		"a day named twice":        `{"_window":{"days":["mon","mon"],"from":"02:00","to":"04:00"}}`,
+		"no days at all":           `{"_window":{"days":[],"from":"02:00","to":"04:00"}}`,
+		"a window of no length":    `{"_window":{"from":"02:00","to":"02:00"}}`,
+		"a clock past 23:59":       `{"_window":{"from":"24:00","to":"02:00"}}`,
+		"a zone nobody has":        `{"_window":{"from":"02:00","to":"04:00","tz":"Mars/Olympus"}}`,
+		"the machine's local zone": `{"_window":{"from":"02:00","to":"04:00","tz":"Local"}}`,
+		"a field the window lacks": `{"_window":{"from":"02:00","to":"04:00","every":"day"}}`,
+		"a rate that bounds none":  `{"_rate":{}}`,
+		"zero a day":               `{"_rate":{"per_day":0}}`,
+		"more a day than uses":     `{"_rate":{"per_day":1001}}`,
+		"an interval past 30 days": `{"_rate":{"min_interval_s":2592001}}`,
+		"a field the rate lacks":   `{"_rate":{"per_hour":3}}`,
+		"a rate as a string":       `{"_rate":"3/day"}`,
+	} {
+		if _, err := parseGrantBounds(m, bad); err == nil {
+			t.Errorf("%s must be refused: %s", name, bad)
+		}
+	}
+	// A window that wraps midnight belongs to the day it opens on.
+	b, _ := parseGrantBounds(m, `{"_window":{"days":["fri"],"from":"22:00","to":"06:00","tz":"UTC"}}`)
+	for at, want := range map[string]bool{
+		"2026-10-30T23:00:00Z": true,  // Friday night
+		"2026-10-31T03:00:00Z": true,  // Saturday morning, the Friday window
+		"2026-10-30T03:00:00Z": false, // Friday morning: Thursday's window, not listed
+		"2026-10-31T07:00:00Z": false,
+	} {
+		ts, _ := time.Parse(time.RFC3339, at)
+		if got := b.Window.inside(ts); got != want {
+			t.Errorf("%s inside=%v, want %v", at, got, want)
+		}
+	}
+}
+
+// ── not now: the window ─────────────────────────────────────────────────────
+
+func TestGrantOutsideItsWindowIsNotNowAndSpendsNothing(t *testing.T) {
+	// Thursday noon UTC; the window is Monday 02:00-04:00 in Berlin.
+	now, _ := time.Parse(time.RFC3339, "2026-10-29T12:00:00Z")
+	atClock(t, &now)
+	dcn, nonce, ran := grantBox(t, `{"_window":{"days":["mon"],"from":"02:00","to":"04:00","tz":"Europe/Berlin"}}`, 5, nil)
+	before := strikes()
+	out, errOut, code := grantApply(t, dcn, nonce)
+	if code != opNotNowExit || !strings.Contains(out, `"state":"not_now"`) || !strings.Contains(out, `"bound":"_window"`) {
+		t.Fatalf("outside the window: not now: %d %s %s", code, out, errOut)
+	}
+	// Berlin is UTC+1 after 25 October: Monday 02:00 there is 01:00 UTC.
+	if !strings.Contains(out, `"next":"2026-11-02T01:00:00Z"`) {
+		t.Fatalf("it says when the window opens: %s", out)
+	}
+	if *ran != 0 || usesLeft(t, dcn, nonce) != 5 || strikes() != before {
+		t.Fatalf("nothing ran, no use spent, no strike: ran=%d uses=%d strikes %d->%d", *ran, usesLeft(t, dcn, nonce), before, strikes())
+	}
+	// A dry run changes nothing and is never held to the window.
+	if _, errOut, code := driveJob(t, tAnchor, mgmtJob{Op: "op_grant_run", Args: []string{nonce, opModeDryRun, grantParams}}, "", dcn); code != 0 {
+		t.Fatalf("a dry run outside the window: %d %s", code, errOut)
+	}
+	// Bad params outside the window are still refused, with the strike.
+	if _, _, code := driveJob(t, tAnchor, mgmtJob{Op: "op_grant_run", Args: []string{nonce, opModeApply, `{"name":"x","count":9,"kind":"a"}`}}, "", dcn); code != 126 {
+		t.Fatalf("arguments outside the op are refused, window or not: %d", code)
+	}
+	now, _ = time.Parse(time.RFC3339, "2026-11-02T01:30:00Z")
+	if _, errOut, code := grantApply(t, dcn, nonce); code != 0 || *ran != 2 || usesLeft(t, dcn, nonce) != 4 {
+		t.Fatalf("inside the window it runs and spends one use: %d %s ran=%d uses=%d", code, errOut, *ran, usesLeft(t, dcn, nonce))
+	}
+}
+
+// ── not now: the rate ───────────────────────────────────────────────────────
+
+func TestGrantInsideItsMinIntervalDoesNotRun(t *testing.T) {
+	now := time.Now().UTC().Truncate(time.Second)
+	atClock(t, &now)
+	dcn, nonce, ran := grantBox(t, `{"_rate":{"min_interval_s":600}}`, 5, nil)
+	if _, errOut, code := grantApply(t, dcn, nonce); code != 0 {
+		t.Fatalf("the first run: %d %s", code, errOut)
+	}
+	before := strikes()
+	first := now
+	now = now.Add(5 * time.Minute)
+	out, _, code := grantApply(t, dcn, nonce)
+	if code != opNotNowExit || !strings.Contains(out, `"bound":"_rate"`) ||
+		!strings.Contains(out, `"next":"`+first.Add(10*time.Minute).Format(time.RFC3339)+`"`) {
+		t.Fatalf("five minutes after a run, with ten approved between: not now: %d %s", code, out)
+	}
+	if *ran != 1 || usesLeft(t, dcn, nonce) != 4 || strikes() != before {
+		t.Fatalf("the second did not run, spend or strike: ran=%d uses=%d", *ran, usesLeft(t, dcn, nonce))
+	}
+	now = first.Add(11 * time.Minute)
+	if _, _, code := grantApply(t, dcn, nonce); code != 0 || *ran != 2 {
+		t.Fatalf("past the interval it runs: %d", code)
+	}
+}
+
+func TestGrantPerDayHoldsAcrossARestart(t *testing.T) {
+	now := time.Now().UTC().Truncate(time.Second)
+	atClock(t, &now)
+	dcn, nonce, ran := grantBox(t, `{"_rate":{"per_day":2}}`, 10, nil)
+	start := now
+	for i := 0; i < 2; i++ {
+		if _, errOut, code := grantApply(t, dcn, nonce); code != 0 {
+			t.Fatalf("run %d: %d %s", i, code, errOut)
+		}
+		now = now.Add(time.Hour)
+	}
+	// The run log is on disk, in the record, not in this process.
+	raw, err := os.ReadFile(opsFilePath(dcn))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var f opsFile
+	if json.Unmarshal(raw, &f) != nil || len(f.Grants[nonce].Runs) != 2 {
+		t.Fatalf("both runs are in ops.json: %s", raw)
+	}
+	// A restart: another process reads the same record. Copy the pairing's
+	// state to a fresh place and ask there.
+	moved := t.TempDir()
+	if err := copyTree(dcn, moved); err != nil {
+		t.Fatal(err)
+	}
+	out, _, code := grantApply(t, moved, nonce)
+	if code != opNotNowExit || !strings.Contains(out, "2 run(s) in the last 24 hours") {
+		t.Fatalf("the third run in a day, after a restart: not now: %d %s", code, out)
+	}
+	if *ran != 2 {
+		t.Fatalf("it did not run: %d", *ran)
+	}
+	// 24 hours after the first, one slot is free again.
+	now = start.Add(24*time.Hour + time.Second)
+	if _, errOut, code := grantApply(t, moved, nonce); code != 0 {
+		t.Fatalf("a day after the first run: %d %s", code, errOut)
+	}
+}
+
+func copyTree(from, to string) error {
+	return filepath.Walk(from, func(p string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		rel, _ := filepath.Rel(from, p)
+		dst := filepath.Join(to, rel)
+		if info.IsDir() {
+			return os.MkdirAll(dst, 0o755)
+		}
+		raw, err := os.ReadFile(p)
+		if err != nil {
+			return err
+		}
+		return os.WriteFile(dst, raw, info.Mode().Perm())
+	})
+}
+
+// ── the record ──────────────────────────────────────────────────────────────
+
+func TestGrantWithATamperedRunLogIsNoGrant(t *testing.T) {
+	now := time.Now().UTC().Truncate(time.Second)
+	atClock(t, &now)
+	for name, edit := range map[string]func(r *opGrantRec){
+		"the run taken out and the use given back": func(r *opGrantRec) { r.Runs = nil; r.UsesLeft++ },
+		"the run taken out":                        func(r *opGrantRec) { r.Runs = nil },
+		"a use given back":                         func(r *opGrantRec) { r.UsesLeft++ },
+		"the run moved a day back":                 func(r *opGrantRec) { r.Runs[0] = now.Add(-25 * time.Hour).Format(time.RFC3339Nano) },
+		"another approver":                         func(r *opGrantRec) { r.Approver = "console:0000" },
+		"no seal (an older bastion's record)":      func(r *opGrantRec) { r.MAC = "" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			dcn, nonce, ran := grantBox(t, `{"_rate":{"per_day":1}}`, 5, nil)
+			if _, errOut, code := grantApply(t, dcn, nonce); code != 0 {
+				t.Fatalf("the first run: %d %s", code, errOut)
+			}
+			f := opsLoad(dcn)
+			r := f.Grants[nonce]
+			edit(&r)
+			f.Grants[nonce] = r
+			if err := opsSave(dcn, f); err != nil {
+				t.Fatal(err)
+			}
+			_, errOut, code := grantApply(t, dcn, nonce)
+			if code != 126 || (!strings.Contains(errOut, "does not check out") && !strings.Contains(errOut, "approve it again")) {
+				t.Fatalf("an edited record holds no grant: %d %q", code, errOut)
+			}
+			if *ran != 1 {
+				t.Fatalf("nothing ran under it: %d", *ran)
+			}
+		})
+	}
+}
+
+func TestGrantDiesWithTheKeyThatApprovedIt(t *testing.T) {
+	var pub string
+	byDevice := func(_, purpose string) string {
+		var err error
+		if pub, err = deviceInit(); err != nil {
+			t.Fatal(err)
+		}
+		if err := pinDeviceKey(pub); err != nil {
+			t.Fatal(err)
+		}
+		a, err := deviceSign(purpose, time.Minute)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return a
+	}
+	dcn, nonce, ran := grantBox(t, `{"count":{"max":2}}`, 5, byDevice)
+	if rec := opsLoad(dcn).Grants[nonce]; rec.Approver != "device:"+pub {
+		t.Fatalf("the approving key is kept with the grant: %q", rec.Approver)
+	}
+	// The grant as the pairing holds it, in the pairing's own state folder
+	// (unpinning walks every pairing's).
+	cfgs, err := loadPairings()
+	if err != nil {
+		t.Fatal(err)
+	}
+	home := pairingFor(cfgs, tAnchor).dcnDir()
+	if err := copyTree(dcn, home); err != nil {
+		t.Fatal(err)
+	}
+	dcn = home
+	if _, errOut, code := grantApply(t, dcn, nonce); code != 0 {
+		t.Fatalf("a run under it: %d %s", code, errOut)
+	}
+	if err := unpinDeviceKey(pub); err != nil {
+		t.Fatal(err)
+	}
+	if _, errOut, code := grantApply(t, dcn, nonce); code != 126 || !strings.Contains(errOut, "no longer pinned") {
+		t.Fatalf("its key unpinned, the grant is dead: %d %q", code, errOut)
+	}
+	// Unpinning drops what the key approved, so pinning it again does not
+	// bring the grant back.
+	if n := opsDropApprovedBy("device:" + pub); n != 1 {
+		t.Fatalf("one grant dropped with its key: %d", n)
+	}
+	if err := pinDeviceKey(pub); err != nil {
+		t.Fatal(err)
+	}
+	if _, errOut, code := grantApply(t, dcn, nonce); code != 126 || !strings.Contains(errOut, "no such op grant") {
+		t.Fatalf("pinned again, the grant stays dropped: %d %q", code, errOut)
+	}
+	if *ran != 1 {
+		t.Fatalf("one run only: %d", *ran)
+	}
+	// A console approval dies with the factor: re-enrolled is another one.
+	dcn2, nonce2, _ := grantBox(t, `{"count":{"max":2}}`, 5, nil)
+	if err := stepupSave(dcn2, &stepupFile{SecretB32: tSecret, EnrolledAt: "2026-10-29T00:00:00Z", LastCounter: -1}); err != nil {
+		t.Fatal(err)
+	}
+	if _, errOut, code := grantApply(t, dcn2, nonce2); code != 126 || !strings.Contains(errOut, "no longer pinned") {
+		t.Fatalf("its factor re-enrolled, the grant is dead: %d %q", code, errOut)
+	}
+}
+
+// ── taking it back ──────────────────────────────────────────────────────────
+
+func TestGrantDropGoesThroughAQuarantine(t *testing.T) {
+	if !opTightens("op_grant_drop") || !ownApproval("op_grant_drop") {
+		t.Fatal("op_grant_drop is a tighten: no approval, no quarantine")
+	}
+	dcn, nonce, _ := grantBox(t, `{"count":{"max":2}}`, 5, nil)
+	now := time.Now()
+	for i := 0; i < quarantineStrikes; i++ {
+		noteRefusal(tAnchor, "op_apply", "test strike", true, now)
+	}
+	if quarantinedUntil(tAnchor, time.Now()).IsZero() {
+		t.Fatal("the host is quarantined here")
+	}
+	if _, errOut, code := grantApply(t, dcn, nonce); code != 126 || !strings.Contains(errOut, "quarantined") {
+		t.Fatalf("a run while quarantined is refused: %d %q", code, errOut)
+	}
+	out, errOut, code := driveJob(t, tAnchor, mgmtJob{Op: "op_grant_drop", Args: []string{nonce}}, "", dcn)
+	if code != 0 || !strings.Contains(out, nonce) {
+		t.Fatalf("a drop while quarantined goes through: %d %s %s", code, out, errOut)
+	}
+	if _, _, err := opsHeldGrant(dcn, nonce); err == nil {
+		t.Fatal("the grant is gone")
+	}
+	// A drop of what is not held is already done; all takes every one.
+	if out, _, code := driveJob(t, tAnchor, mgmtJob{Op: "op_grant_drop", Args: []string{nonce}}, "", dcn); code != 0 || !strings.Contains(out, `"dropped":[]`) {
+		t.Fatalf("dropping it again: %d %s", code, out)
+	}
+	dcn2, nonce2, _ := grantBox(t, `{"count":{"max":2}}`, 5, nil)
+	for i := 0; i < quarantineStrikes; i++ {
+		noteRefusal(tAnchor, "op_apply", "test strike", true, time.Now())
+	}
+	if out, _, code := driveJob(t, tAnchor, mgmtJob{Op: "op_grant_drop", Args: []string{"all"}}, "", dcn2); code != 0 || !strings.Contains(out, nonce2) {
+		t.Fatalf("drop all: %d %s", code, out)
+	}
+}
+
+// ── interpreter: none ───────────────────────────────────────────────────────
+
+const verbsOnlyManifest = `name: restart-web
+version: 1.0.0
+summary: Restart the web service.
+kind: action
+target: machine
+privilege: root
+interpreter: none
+time_limit: 120
+verbs:
+  - {verb: unit.restart, unit: web.service}
+  - {verb: logs.check, unit: web.service, must_not: "emerg", lines: "200"}
+modes: [dry_run, apply, verify]
+undo: none
+`
+
+func verbsOnlyFiles(withRun bool) []opFile {
+	files := []opFile{{Path: "op.yaml", Mode: 0o644, B64: base64.StdEncoding.EncodeToString([]byte(verbsOnlyManifest))}}
+	if withRun {
+		files = append(files, opFile{Path: "run", Mode: 0o755, B64: base64.StdEncoding.EncodeToString([]byte("#!/bin/sh\nid\n"))})
+	}
+	return files
+}
+
+func TestVerbsOnlyManifest(t *testing.T) {
+	setupBox(t)
+	m, err := parseOpManifest([]byte(verbsOnlyManifest))
+	if err != nil || !m.verbsOnly() {
+		t.Fatalf("a verbs-only op parses: %v", err)
+	}
+	for name, bad := range map[string]string{
+		"interpreter none on a files op": strings.Replace(fmt.Sprintf(opTestManifest, "/srv/optest"), "interpreter: /bin/sh", "interpreter: none", 1),
+		"no verbs":                       strings.Replace(strings.Replace(verbsOnlyManifest, "privilege: root", "privilege: user", 1), "verbs:\n  - {verb: unit.restart, unit: web.service}\n  - {verb: logs.check, unit: web.service, must_not: \"emerg\", lines: \"200\"}\n", "", 1),
+		"a destination":                  strings.Replace(verbsOnlyManifest, "time_limit: 120\n", "time_limit: 120\ndestinations: [\"forge.example.com:443\"]\n", 1),
+		"a builder":                      strings.Replace(verbsOnlyManifest, "time_limit: 120\n", "time_limit: 120\nbuilder: true\n", 1),
+		"a credential no verb names":     strings.Replace(verbsOnlyManifest, "time_limit: 120\n", "time_limit: 120\ncredentials: [forge-read]\n", 1),
+		"a read":                         strings.Replace(verbsOnlyManifest, "time_limit: 120\n", "time_limit: 120\nreads: [\"/srv/data/\"]\n", 1),
+	} {
+		if _, err := parseOpManifest([]byte(bad)); err == nil {
+			t.Errorf("%s must be refused", name)
+		}
+	}
+}
+
+func TestVerbsOnlyOpShippingRunIsRefused(t *testing.T) {
+	dcn, priv := opTestBox(t)
+	files := verbsOnlyFiles(true)
+	sha, _ := opDirDigest(files)
+	run := opTerm(opKindRun, sha, `{}`, "", 1, time.Hour, "root")
+	run["op"] = "restart-web"
+	if _, errOut, code := driveJob(t, tAnchor, mgmtJob{Op: "op_sync", Args: append(signTermsPair(t, priv, run), bundleB64(files))}, "", dcn); code != 126 || !strings.Contains(errOut, "ships no run") {
+		t.Fatalf("a verbs-only op that ships a program is refused: %d %q", code, errOut)
+	}
+	files = verbsOnlyFiles(false)
+	sha, _ = opDirDigest(files)
+	run["sha256"] = sha
+	if out, errOut, code := driveJob(t, tAnchor, mgmtJob{Op: "op_sync", Args: append(signTermsPair(t, priv, run), bundleB64(files))}, "", dcn); code != 0 || !strings.Contains(out, `"held"`) {
+		t.Fatalf("without it, held: %d %s %s", code, out, errOut)
+	}
+	// And a program op without its run is refused, as before.
+	prog := opFixture("/srv/optest", "")[:1]
+	psha, _ := opDirDigest(prog)
+	pr := opTerm(opKindRun, psha, grantParams, "", 1, time.Hour, "root")
+	if _, errOut, code := driveJob(t, tAnchor, mgmtJob{Op: "op_sync", Args: append(signTermsPair(t, priv, pr), bundleB64(prog))}, "", dcn); code != 126 || !strings.Contains(errOut, "needs op.yaml and run") {
+		t.Fatalf("a program op with no run: %d %q", code, errOut)
+	}
+}
+
+func noOverlay(t *testing.T) {
+	ps, pa := opSandboxCheck, opActionCheck
+	opSandboxCheck = func() (bool, string) { return false, "the kernel offers no overlay filesystem" }
+	opActionCheck = func() (bool, string) { return false, "the kernel offers no overlay filesystem" }
+	t.Cleanup(func() { opSandboxCheck, opActionCheck = ps, pa })
+}
+
+func TestProgramOpStillRefusedWithoutTheSandbox(t *testing.T) {
+	noOverlay(t)
+	dcn, priv := opTestBox(t)
+	files := opFixture("/srv/optest", "")
+	sha, _ := opDirDigest(files)
+	pair := signTermsPair(t, priv, opTerm(opKindRun, sha, grantParams, "", 1, time.Hour, "root"))
+	if _, errOut, code := driveJob(t, tAnchor, mgmtJob{Op: "op_sync", Args: append(pair, bundleB64(files))}, "", dcn); code != 0 {
+		t.Fatalf("held: %s", errOut)
+	}
+	if _, errOut, code := driveJob(t, tAnchor, mgmtJob{Op: "op_dry_run", Args: pair}, "", dcn); code != 126 || !strings.Contains(errOut, noSandboxHere) {
+		t.Fatalf("a files op with no sandbox: %d %q", code, errOut)
+	}
+	// An action op with a program and verbs: the program needs the sandbox.
+	man := strings.Replace(verbsOnlyManifest, "interpreter: none", "interpreter: /bin/sh", 1)
+	afiles := []opFile{{Path: "op.yaml", Mode: 0o644, B64: base64.StdEncoding.EncodeToString([]byte(man))},
+		{Path: "run", Mode: 0o755, B64: base64.StdEncoding.EncodeToString([]byte("#!/bin/sh\n"))}}
+	asha, _ := opDirDigest(afiles)
+	at := opTerm(opKindRun, asha, `{}`, "", 1, time.Hour, "root")
+	at["op"] = "restart-web"
+	apair := signTermsPair(t, priv, at)
+	if _, errOut, code := driveJob(t, tAnchor, mgmtJob{Op: "op_sync", Args: append(apair, bundleB64(afiles))}, "", dcn); code != 0 {
+		t.Fatalf("held: %s", errOut)
+	}
+	if _, errOut, code := driveJob(t, tAnchor, mgmtJob{Op: "op_dry_run", Args: apair}, "", dcn); code != 126 || !strings.Contains(errOut, noSandboxHere) {
+		t.Fatalf("an action op with a program and no sandbox: %d %q", code, errOut)
+	}
+}

client-go/ops_verbs_linux.go

@@ -19,10 +19,13 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"net"
+	"net/url"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"regexp"
+	"slices"
 	"strconv"
 	"strings"
 	"sync"
@@ -81,11 +84,17 @@ func opCmd(ctx context.Context, name string, args ...string) (string, error) {
 	return out.String(), err
 }
 
-// opRunAction runs one mode of an action op (ops.go opRunTerms).
+// opRunAction runs one mode of an action op (ops.go opRunTerms). An op with
+// no program (interpreter: none) runs no unit and needs no sandbox: its dry
+// run is the change list its verbs read, its apply the verbs and the log
+// checks, and what it needs of the machine is each verb's own tool
+// (opVerbProbe).
 func opRunAction(opDir string, m *opManifest, t *opTerms, mode, runID string, blobs []string, pc *opPlanCtx) (*opReport, error) {
-	if ok, why := opActionAvailable(); !ok {
+	if !m.verbsOnly() {
+		if ok, why := opActionCheck(); !ok {
 			return nil, errors.New("this machine cannot run an action op: " + why)
 		}
+	}
 	if mode != opModeDryRun && mode != opModeApply {
 		return nil, errors.New("an action op is run as dry_run or apply; its verify runs inside the apply")
 	}
@@ -97,6 +106,11 @@ func opRunAction(opDir string, m *opManifest, t *opTerms, mode, runID string, bl
 	if err != nil {
 		return nil, err
 	}
+	if m.verbsOnly() {
+		if why := opVerbProbe(verbs); why != "" {
+			return nil, errors.New(noVerbToolHere + ": " + why)
+		}
+	}
 	creds, err := opOpenCreds(blobs, m, t.Nonce, mode == opModeDryRun)
 	if err != nil {
 		return nil, err
@@ -108,6 +122,9 @@ func opRunAction(opDir string, m *opManifest, t *opTerms, mode, runID string, bl
 	}
 	planSHA := opChangesDigest(plan)
 	if mode == opModeDryRun {
+		if m.verbsOnly() {
+			return &opReport{Mode: opModeDryRun, Changes: plan, ChangesSHA256: planSHA}, nil
+		}
 		rep, _, err := opRunActionProgram(opDir, m, opModeDryRun, t.Params, nil, runID)
 		if rep != nil {
 			rep.Changes, rep.ChangesSHA256 = plan, planSHA
@@ -122,10 +139,16 @@ func opRunAction(opDir string, m *opManifest, t *opTerms, mode, runID string, bl
 			truncate(planSHA, 12), truncate(t.Changes, 12))
 	}
 	start := time.Now()
-	rep, result, err := opRunActionProgram(opDir, m, opModeApply, t.Params, opProgramCreds(verbs, creds), runID)
+	var rep *opReport
+	var result []byte
+	if m.verbsOnly() {
+		rep = &opReport{Mode: opModeApply}
+	} else {
+		rep, result, err = opRunActionProgram(opDir, m, opModeApply, t.Params, opProgramCreds(verbs, creds), runID)
 		if rep == nil {
 			return nil, err
 		}
+	}
 	rep.Changes, rep.ChangesSHA256 = plan, planSHA
 	if err != nil {
 		return rep, err
@@ -135,6 +158,11 @@ func opRunAction(opDir string, m *opManifest, t *opTerms, mode, runID string, bl
 		if err != nil {
 			return rep, err
 		}
+		for _, im := range images {
+			if err := opRegistryOK(context.Background(), im.Image); err != nil {
+				return rep, err
+			}
+		}
 		receipts, err := opIssueReceipts(runID, t.Op, t.SHA256, t.Params, images)
 		rep.Receipts = receipts
 		if err != nil {
@@ -171,11 +199,13 @@ func opRunAction(opDir string, m *opManifest, t *opTerms, mode, runID string, bl
 	// image), then each log check, reading only what came after the apply
 	// began.
 	var failed []string
+	if !m.verbsOnly() {
 		if ver, _, err := opRunActionProgram(opDir, m, opModeVerify, t.Params, nil, runID); err != nil {
 			failed = append(failed, "verify: "+err.Error())
 		} else if ver.Exit != 0 {
 			failed = append(failed, fmt.Sprintf("verify exited %d", ver.Exit))
 		}
+	}
 	for _, v := range verbs {
 		if v.Verb != opVerbLogs {
 			continue
@@ -508,7 +538,7 @@ func opCredHeaderEnv(creds map[string]string, name string) ([]string, error) {
 	return []string{"GIT_CONFIG_COUNT=1", "GIT_CONFIG_KEY_0=http.extraHeader", "GIT_CONFIG_VALUE_0=Authorization: token " + tok}, nil
 }
 
-func opTreeDo(_ context.Context, v opVerbLine, creds map[string]string, want string) (string, error) {
+func opTreeDo(ctx context.Context, v opVerbLine, creds map[string]string, want string) (string, error) {
 	defer opLockTarget(v)()
 	path, to := v.Args["path"], v.Args["commit"]
 	head, branch, err := opTreeState(v)
@@ -525,7 +555,11 @@ func opTreeDo(_ context.Context, v opVerbLine, creds map[string]string, want str
 	if err != nil {
 		return "", err
 	}
-	if out, err := opTreeGit(path, env, "fetch", "--no-tags", "--quiet", v.Args["repo"], "+refs/heads/*:refs/remotes/origin/*"); err != nil {
+	pin, err := opFetchPin(ctx, v.Args["repo"])
+	if err != nil {
+		return "", err
+	}
+	if out, err := opTreeGit(path, env, append(pin, "fetch", "--no-tags", "--quiet", v.Args["repo"], "+refs/heads/*:refs/remotes/origin/*")...); err != nil {
 		return "", errors.New("fetch failed: " + truncate(out, 300))
 	}
 	if _, err := opTreeGit(path, nil, "cat-file", "-e", to+"^{commit}"); err != nil {
@@ -702,6 +736,9 @@ func opImageCheck(ctx context.Context, v opVerbLine, pc *opPlanCtx) (*opImageFac
 	if rc.Image != a["image"] {
 		return nil, fmt.Errorf("the receipt for %s is for %s, not %s", truncate(a["digest"], 19), rc.Image, a["image"])
 	}
+	if err := opRegistryOK(ctx, a["image"]); err != nil {
+		return nil, err
+	}
 	// The repository ancestry is checked in is the manifest's, never one a
 	// program reported: the check fetches it, with the verb's credential.
 	if rc.Source != a["repo"] {
@@ -806,12 +843,156 @@ func opImageDo(ctx context.Context, v opVerbLine, creds map[string]string, pc *o
 	return truncate(f.liveDigest, 19) + " → " + truncate(a["digest"], 19) + ", rolled out", nil
 }
 
+// opFetchPin is the git options a verb's fetch of repo carries. A verb
+// fetches with the bastion's own root, outside the program's sandbox
+// (tree.checkout its tree's repository, k8s.set_image its source to check
+// ancestry), so it is held to the rule a destination is: the repository's
+// host is resolved here, once, every address it answers must be one an op may
+// reach, and git is held to the first (http.curloptResolve, as the mirror
+// pins its fetch) so a second lookup cannot answer another. On every machine
+// that is never this machine, its loopback, a link-local address or a cloud's
+// metadata service (opForbiddenDest); on a machine no fleet has anchored,
+// never a private network either (opLocalNetworkDest). An anchored machine's
+// ship steps reach its fleet's private forges, so it keeps those.
+func opFetchPin(ctx context.Context, repo string) ([]string, error) {
+	u, err := url.Parse(repo)
+	if err != nil {
+		return nil, errors.New("the repository is not a URL this bastion can read")
+	}
+	if u.Scheme == "file" && slices.Contains(opTreeProtocols, "file") {
+		return nil, nil // a test's own repository: no network
+	}
+	if u.Scheme != "https" || u.Hostname() == "" {
+		return nil, fmt.Errorf("%s: a verb fetches a repository over https from a named host", repo)
+	}
+	host, port := u.Hostname(), u.Port()
+	if port == "" {
+		port = "443"
+	}
+	ips, err := opVerbHostAddrs(ctx, host)
+	if err != nil {
+		return nil, fmt.Errorf("the repository's host %s does not resolve on this machine", host)
+	}
+	own := map[string]bool{}
+	for _, ip := range opActionOwnAddrs() {
+		own[ip.String()] = true
+	}
+	for _, ip := range ips {
+		why := opForbiddenDest(ip)
+		if why == "" {
+			why = opLocalNetworkDest(ip)
+		}
+		if why == "" && own[ip.String()] {
+			why = "it is this machine"
+		}
+		if why != "" {
+			return nil, fmt.Errorf("the repository's host %s resolves to %s: %s", host, ip, why)
+		}
+	}
+	if why := opGitPinnable(); why != "" {
+		return nil, errors.New(why)
+	}
+	addr := ips[0].String()
+	if strings.Contains(addr, ":") {
+		addr = "[" + addr + "]"
+	}
+	return []string{"-c", "http.curloptResolve=" + host + ":" + port + ":" + addr}, nil
+}
+
+// opRegistryOK: nil when the registry an image is pulled from may be
+// reached from this machine, else why not. The bastion never pulls an image
+// itself: k8s.set_image hands the reference to the cluster, and the
+// machine's container runtime pulls it, by the name, with its own lookup and
+// none of the bastion's walls. So on a machine no fleet has anchored the
+// registry is judged where the bastion takes the image, when a program's
+// result names it and again when k8s.set_image would put it live: written as
+// an address or resolving to one that is this machine, its loopback, a
+// link-local address, a cloud's metadata service or a private network, it is
+// refused. A first part with no dot, no port and not localhost is a Docker
+// Hub repository, as the runtime reads it. An anchored machine's fleet pulls
+// from its own private registries, so it keeps them.
+func opRegistryOK(ctx context.Context, image string) error {
+	if currentAnchor() != nil {
+		return nil
+	}
+	ref, _ := opSplitImage(image)
+	first, _, ok := strings.Cut(ref, "/")
+	if !ok || (!strings.ContainsAny(first, ".:") && first != "localhost") {
+		return nil
+	}
+	host := first
+	if h, _, err := net.SplitHostPort(first); err == nil {
+		host = h
+	}
+	ips, err := opVerbHostAddrs(ctx, host)
+	if err != nil {
+		return fmt.Errorf("the image's registry %s does not resolve on this machine", host)
+	}
+	own := map[string]bool{}
+	for _, ip := range opActionOwnAddrs() {
+		own[ip.String()] = true
+	}
+	for _, ip := range ips {
+		why := opForbiddenDest(ip)
+		if why == "" {
+			why = opLocalNetworkDest(ip)
+		}
+		if why == "" && own[ip.String()] {
+			why = "it is this machine"
+		}
+		if why != "" {
+			return fmt.Errorf("the image %s comes from the registry %s, which resolves to %s: %s", truncate(ref, 90), host, ip, why)
+		}
+	}
+	return nil
+}
+
+// opVerbHostAddrs is every address host stands for on this machine: itself
+// when it is one, loopback for localhost and a name under it (which never
+// leave the machine, whatever a resolver says), else what it resolves to.
+func opVerbHostAddrs(ctx context.Context, host string) ([]net.IP, error) {
+	if ip := net.ParseIP(host); ip != nil {
+		return []net.IP{ip}, nil
+	}
+	if l := strings.ToLower(host); l == "localhost" || strings.HasSuffix(l, ".localhost") {
+		return []net.IP{net.IPv4(127, 0, 0, 1)}, nil
+	}
+	rctx, cancel := context.WithTimeout(ctx, 20*time.Second)
+	defer cancel()
+	ips, err := opActionResolve(rctx, host)
+	if err == nil && len(ips) == 0 {
+		err = errors.New("no address")
+	}
+	return ips, err
+}
+
+// opGitPinnable: "" when this machine's git holds a fetch to the address
+// opFetchPin checked, else why not. http.curloptResolve arrived in git 2.37,
+// and an older git ignores it without an error, which would drop the pin; so
+// an older git does not fetch for a verb. A seam for the tests.
+var opGitPinnable = func() string {
+	out, err := runGitEnv(15*time.Second, nil, "version")
+	if err != nil {
+		return "git on this machine did not report its version"
+	}
+	if gitVersionRefusal(out) != "" {
+		return "a verb's fetch is held to the address the bastion checked, " +
+			"which needs git 2.37 or newer, and this machine has " + truncate(strings.TrimSpace(out), 40) +
+			": install git 2.37 or newer"
+	}
+	return ""
+}
+
 // opAncestryByFetch fetches the source repository into the bastion's own
 // cache and asks git whether newer descends from older.
 func opAncestryByFetch(source, older, newer string, env []string) error {
 	if older == newer {
 		return nil
 	}
+	pin, err := opFetchPin(context.Background(), source)
+	if err != nil {
+		return err
+	}
 	d, err := configDir()
 	if err != nil {
 		return err
@@ -826,7 +1007,7 @@ func opAncestryByFetch(source, older, newer string, env []string) error {
 			return errors.New("ancestry cache: " + truncate(out, 200))
 		}
 	}
-	if out, err := opTreeGit(cache, env, "fetch", "--no-tags", "--quiet", source, "+refs/heads/*:refs/heads/*"); err != nil {
+	if out, err := opTreeGit(cache, env, append(pin, "fetch", "--no-tags", "--quiet", source, "+refs/heads/*:refs/heads/*")...); err != nil {
 		return errors.New("fetching the source to check ancestry failed: " + truncate(out, 300))
 	}
 	for _, c := range []string{older, newer} {
@@ -906,6 +1087,95 @@ func opProgramCreds(verbs []opVerbLine, creds map[string]string) map[string]stri
 	return out
 }
 
+// ── what each verb needs of the machine ─────────────────────────────────────
+
+// opLookPath finds a tool a verb runs (a seam for the tests).
+var opLookPath = exec.LookPath
+
+// opVerbProbe: "" when this machine can run every line, else why not. The
+// verbs run with the bastion's own root and each runs one tool. A seam, so a
+// test can stand in for a machine that has them.
+var opVerbProbe = func(lines []opVerbLine) string {
+	if !processIsRoot() {
+		return "the bastion is not root, and a verb runs with its root"
+	}
+	for _, v := range lines {
+		for _, tool := range opVerbTools(v.Verb, v.Args) {
+			if _, err := opLookPath(tool); err != nil {
+				return fmt.Sprintf("%s %s runs %s, which is not installed here", v.Verb, v.target(), tool)
+			}
+		}
+	}
+	return ""
+}
+
+// opVerbTools is the tool one verb line runs (logs.check: the journal for a
+// unit, kubectl for a workload).
+func opVerbTools(verb string, args map[string]string) []string {
+	switch verb {
+	case "unit.reload", "unit.restart":
+		return []string{"systemctl"}
+	case "tree.checkout":
+		return []string{"git"}
+	case "k8s.set_image":
+		// kubectl sets the image; git fetches the source to check the new
+		// commit descends from the live one (opAncestryByFetch).
+		return []string{"kubectl", "git"}
+	case opVerbLogs:
+		if args["unit"] != "" {
+			return []string{"journalctl"}
+		}
+		return []string{"kubectl"}
+	}
+	return nil
+}
+
+// opVerbsReport is the beat's enforcing.verbs: for each verb this bastion
+// runs, whether this machine has what it needs, and why not when it does
+// not. logs.check is ready when either of its tools is (the line decides
+// which it reads).
+func opVerbsReport() map[string]any {
+	root := processIsRoot()
+	out := map[string]any{}
+	for _, verb := range opVerbNames() {
+		var tools [][]string
+		if verb == opVerbLogs {
+			tools = [][]string{{"journalctl"}, {"kubectl"}}
+		} else {
+			tools = [][]string{opVerbTools(verb, nil)}
+		}
+		why := ""
+		if !root {
+			why = "the bastion is not root, and a verb runs with its root"
+		} else {
+			why = "needs " + strings.Join(tools[0], ", ")
+			for _, set := range tools {
+				ok := true
+				for _, tool := range set {
+					if _, err := opLookPath(tool); err != nil {
+						ok = false
+					}
+				}
+				if ok {
+					why = ""
+					break
+				}
+			}
+			if why == "" && verb == "k8s.set_image" {
+				if _, err := os.Stat(opKubeconfig); err != nil {
+					why = "no kubeconfig at " + opKubeconfig
+				}
+			}
+		}
+		if why == "" {
+			out[verb] = map[string]any{"ok": true}
+		} else {
+			out[verb] = map[string]any{"ok": false, "why": why}
+		}
+	}
+	return out
+}
+
 // opVerbTo is the state a verb line moves its target to: a commit, an image
 // reference; "" for a unit, which has no state to move back from.
 func opVerbTo(v opVerbLine) string {

client-go/ops_verbs_only_linux_test.go

@@ -0,0 +1,177 @@
+package main
+
+// ops_verbs_only_linux_test.go — an op with no program (interpreter: none)
+// runs on a machine with no overlay (the edges), through op_dry_run and an
+// approved op_apply, with only the verbs' own tools. Stand-ins for systemd
+// and the probe; nothing here needs root.
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestVerbsOnlyOpRunsWithNoOverlay(t *testing.T) {
+	noOverlay(t)
+	prevProbe := opVerbProbe
+	opVerbProbe = func([]opVerbLine) string { return "" }
+	t.Cleanup(func() { opVerbProbe = prevProbe })
+	var calls []string
+	state := map[string]string{"LoadState": "loaded", "ActiveState": "failed", "SubState": "failed", "MainPID": "0"}
+	prevCtl, prevJournal := opSystemctl, opJournalctl
+	opSystemctl = func(_ context.Context, args ...string) (string, error) {
+		calls = append(calls, strings.Join(args, " "))
+		if args[0] == "show" {
+			var b strings.Builder
+			for k, v := range state {
+				fmt.Fprintf(&b, "%s=%s\n", k, v)
+			}
+			return b.String(), nil
+		}
+		if args[0] == "restart" {
+			state["ActiveState"], state["SubState"], state["MainPID"] = "active", "running", "42"
+		}
+		return "", nil
+	}
+	opJournalctl = func(_ context.Context, _ ...string) (string, error) { return "started\n", nil }
+	t.Cleanup(func() { opSystemctl, opJournalctl = prevCtl, prevJournal })
+
+	dcn, priv := opTestBox(t)
+	enrollFactor(t, dcn)
+	files := verbsOnlyFiles(false)
+	sha, _ := opDirDigest(files)
+	terms := opTerm(opKindRun, sha, `{}`, "", 1, time.Hour, "root")
+	terms["op"] = "restart-web"
+	pair := signTermsPair(t, priv, terms)
+	if _, errOut, code := driveJob(t, tAnchor, mgmtJob{Op: "op_sync", Args: append(pair, bundleB64(files))}, "", dcn); code != 0 {
+		t.Fatalf("held: %s", errOut)
+	}
+	out, errOut, code := driveJob(t, tAnchor, mgmtJob{Op: "op_dry_run", Args: pair}, "", dcn)
+	if code != 0 {
+		t.Fatalf("the dry run on a machine with no overlay: %d %s", code, errOut)
+	}
+	var rep opReport
+	if err := json.Unmarshal([]byte(out), &rep); err != nil || len(rep.Changes) != 2 || rep.ChangesSHA256 == "" ||
+		!strings.Contains(rep.Changes[0].Note, "failed/failed → restarted") {
+		t.Fatalf("the dry run is the verbs' own read: %v %s", err, out)
+	}
+	for _, c := range calls {
+		if strings.HasPrefix(c, "restart") {
+			t.Fatal("a verb never runs in a dry run")
+		}
+	}
+	// The apply, approved for exactly that change list.
+	terms["changes_sha256"] = rep.ChangesSHA256
+	purpose, err := purposeForOpRun(&opTerms{Server: terms["server"].(string), Op: "restart-web", SHA256: sha,
+		Params: `{}`, Expires: terms["expires"].(string), Changes: rep.ChangesSHA256})
+	if err != nil {
+		t.Fatal(err)
+	}
+	raw, _ := b32decode(tSecret)
+	approval, err := stepupIssueApproval(dcn, hotp(raw, time.Now().Unix()/stepupPeriod), purpose)
+	if err != nil {
+		t.Fatal(err)
+	}
+	terms["approval"] = approval
+	out, errOut, code = driveJob(t, tAnchor, mgmtJob{Op: "op_apply", Args: signTermsPair(t, priv, terms)}, "", dcn)
+	if code != 0 {
+		t.Fatalf("the apply: %d %s", code, errOut)
+	}
+	rep = opReport{}
+	_ = json.Unmarshal([]byte(out), &rep)
+	if len(rep.Verbs) != 1 || !rep.Verbs[0].OK || len(rep.Checks) != 1 || !rep.Checks[0].OK || rep.VerifyError != "" {
+		t.Fatalf("the unit restarted and its log checked: %s", out)
+	}
+	if n := countPrefix(calls, "restart web.service"); n != 1 {
+		t.Fatalf("restarted once: %v", calls)
+	}
+
+	// A machine without a verb's tool refuses the run, and that is the
+	// machine's state, never the host's strike.
+	opVerbProbe = func(lines []opVerbLine) string {
+		return "unit.restart web.service runs systemctl, which is not installed here"
+	}
+	pair2 := signTermsPair(t, priv, terms)
+	_, errOut, code = driveJob(t, tAnchor, mgmtJob{Op: "op_dry_run", Args: pair2}, "", dcn)
+	if code != 126 || !strings.Contains(errOut, noVerbToolHere) || refusalCounts("op_dry_run", errOut) {
+		t.Fatalf("a missing tool: %d %q", code, errOut)
+	}
+}
+
+func countPrefix(xs []string, p string) int {
+	n := 0
+	for _, x := range xs {
+		if strings.HasPrefix(x, p) {
+			n++
+		}
+	}
+	return n
+}
+
+func TestVerbsReportNamesEachVerbsTool(t *testing.T) {
+	prev := opLookPath
+	opLookPath = func(file string) (string, error) {
+		if file == "systemctl" || file == "journalctl" {
+			return "/usr/bin/" + file, nil
+		}
+		return "", fmt.Errorf("not found")
+	}
+	t.Cleanup(func() { opLookPath = prev })
+	rep := opVerbsReport()
+	for _, verb := range opVerbNames() {
+		if _, ok := rep[verb]; !ok {
+			t.Fatalf("every verb is on the beat: %v", rep)
+		}
+	}
+	if !processIsRoot() {
+		if v := rep["unit.restart"].(map[string]any); v["ok"] != false {
+			t.Fatalf("a bastion that is not root runs no verb: %v", v)
+		}
+		return
+	}
+	if v := rep["unit.restart"].(map[string]any); v["ok"] != true {
+		t.Fatalf("systemctl here: %v", v)
+	}
+	if v := rep["k8s.set_image"].(map[string]any); v["ok"] != false || !strings.Contains(v["why"].(string), "kubectl") {
+		t.Fatalf("no kubectl here: %v", v)
+	}
+	if v := rep["logs.check"].(map[string]any); v["ok"] != true {
+		t.Fatalf("the journal is enough for a unit's log: %v", v)
+	}
+}
+
+// k8s.set_image runs git as well as kubectl (its ancestry check fetches the
+// source), so a machine with kubectl and no git is told it cannot run the
+// verb, before any run, never by a failed apply.
+//
+// RESULT: red before — k8s.set_image named kubectl alone.
+func TestSetImageNeedsGitForItsAncestryCheck(t *testing.T) {
+	tools := opVerbTools("k8s.set_image", nil)
+	if strings.Join(tools, ",") != "kubectl,git" {
+		t.Fatalf("k8s.set_image runs kubectl and git: %v", tools)
+	}
+	if got := opVerbTools("tree.checkout", nil); strings.Join(got, ",") != "git" {
+		t.Fatalf("tree.checkout runs git: %v", got)
+	}
+	prev := opLookPath
+	opLookPath = func(file string) (string, error) {
+		if file == "kubectl" {
+			return "/usr/bin/kubectl", nil
+		}
+		return "", fmt.Errorf("not found")
+	}
+	t.Cleanup(func() { opLookPath = prev })
+	if !processIsRoot() {
+		return // a bastion that is not root runs no verb at all
+	}
+	line := setImageLine("sha256:" + strings.Repeat("2", 64))
+	if why := opVerbProbe([]opVerbLine{line}); !strings.Contains(why, "git") {
+		t.Fatalf("a machine with kubectl and no git cannot run k8s.set_image: %q", why)
+	}
+	if v := opVerbsReport()["k8s.set_image"].(map[string]any); v["ok"] != false || !strings.Contains(v["why"].(string), "git") {
+		t.Fatalf("the beat says so: %v", v)
+	}
+}

client-go/pair.go

@@ -163,10 +163,12 @@ type redeemResp struct {
 // mode rule, and the anchoring rule. Returns the existing pairing on a
 // --replace and the state the new pairing file must carry.
 //
-//   - LOCAL mode (mode.go): one host, full stop. A second `pair` is refused with
+//   - LOCAL mode (mode.go): one host unless the person says otherwise. A
-//     a plain message; only --replace of the one host is allowed. This is the
+//     second `pair` is refused here with localSecondHostError; `pair` itself
-//     entire protection for a single-user machine — a second host appearing
+//     turns that into a question asked on this machine's terminal
-//     means someone else got a token onto the box.
+//     (pair_terminal.go), and every other caller keeps the refusal. On a
+//     single-user machine a second host appearing unasked means someone else
+//     got a token onto the box, so only a yes typed here adds one.
 //   - NETWORKED + anchored (anchor.go): every pairing after the anchor is written
 //     PENDING. It gets nothing until the anchor host's grant arrives.
 //   - --replace keeps the pairing's current state: rotating credentials is not
@@ -191,11 +193,14 @@ func pairPrecheck(cfgs []*Config, handle string, replace, forceActive bool) (exi
 		return existing, existing.State, nil
 	}
 	if boxMode() == modeLocal && len(cfgs) > 0 {
-		return nil, "", fmt.Errorf("this bastion is in local mode and already serves %s — a local bastion serves one host. "+
+		return nil, "", &localSecondHostError{serving: cfgs[0].HostName}
-			"To rotate that host's credentials: `privatae-bastion pair --replace <token>`. "+
-			"To serve several hosts, reinstall as a networked bastion (install.sh --networked, root) and anchor it",
-			cfgs[0].HostName)
 	}
+	return pairPrecheckState(forceActive)
+}
+
+// pairPrecheckState is the state a new pairing gets once pairPrecheck's walls
+// are passed: active for claim-anchor, pending behind an anchor, else "".
+func pairPrecheckState(forceActive bool) (*Config, string, error) {
 	if forceActive {
 		return nil, pairingActive, nil
 	}
@@ -205,8 +210,73 @@ func pairPrecheck(cfgs []*Config, handle string, replace, forceActive bool) (exi
 	return nil, "", nil
 }
 
+// localSecondHostError is pairPrecheck's refusal on a local machine that
+// already serves a host. cmdPair asks the person instead (confirmAddHost).
+type localSecondHostError struct{ serving string }
+
+func (e *localSecondHostError) Error() string { return localOneHostRefusal(e.serving) }
+
+// localOneHostRefusal says why a second host was not added to a local
+// bastion and what the person can do, in this system's own words. A networked
+// reinstall starts a bastion with its own state, so it says plainly that the
+// host already here would have to be paired again.
+func localOneHostRefusal(serving string) string {
+	networked := "reinstall it as root with install.sh --networked"
+	if runtime.GOOS == "windows" {
+		networked = "reinstall it from an Administrator PowerShell with install.ps1 -Networked"
+	}
+	return fmt.Sprintf("this bastion is in local mode and already serves %s, and it adds another Host only when you "+
+		"answer yes at this computer's terminal. To rotate %s's credentials instead: `privatae-bastion pair --replace <token>`. "+
+		"A machine that other people's Hosts pair to is a networked bastion: %s. That makes a new bastion with "+
+		"state of its own, so %s has to be paired with it again.", serving, serving, networked, serving)
+}
+
+// alreadyPairedError: the host a pair names is already paired here, and
+// nothing was changed. `pair` exits pairExitAlreadyPaired on it, so an
+// installer can tell "already connected" from a failure.
+type alreadyPairedError struct{ host, msg string }
+
+func (e *alreadyPairedError) Error() string { return e.msg }
+
+// pairExitAlreadyPaired is `pair`'s exit status for alreadyPairedError.
+const pairExitAlreadyPaired = 3
+
+// sameNameOtherHost refuses, as a plain failure and never as
+// alreadyPairedError, a pair whose Host has the name of prev but trusts
+// another CA (wantCA, its fingerprint). A Cloud Host's name can repeat; its CA
+// cannot, so that is another Host and never "already connected". nil when
+// prev is nil or holds that same CA.
+func sameNameOtherHost(prev *Config, wantCA string) error {
+	if prev == nil || caSHA256(prev.CACert) == wantCA {
+		return nil
+	}
+	return fmt.Errorf("this computer already serves a different Host named %s (its certificate is not this one's), "+
+		"and one bastion cannot serve two Hosts of the same name yet; nothing was paired", prev.HostName)
+}
+
+func alreadyPairedRefusal(host string) error {
+	return &alreadyPairedError{host: host, msg: fmt.Sprintf("already paired with %s — run `privatae-bastion pair --replace <token>` to rotate its credentials", host)}
+}
+
+// pairOpts are what `pair` brings beyond the token: where to redeem, the
+// Host CA as a file or as a pairing code's fingerprint, and the person to ask
+// before a local machine adds a second host (nil: refuse, as every caller but
+// `pair` does).
+type pairOpts struct {
+	redeemURL   string
+	hostCAFile  string
+	caSHA256    string
+	replace     bool
+	forceActive bool
+	askSecond   func(serving, newHost string) (bool, error)
+}
+
 func cmdPair(token, redeemURL, hostCAFile string, replace bool) error {
-	cfg, all, err := pairWithTokenVia(token, redeemURL, hostCAFile, replace, false)
+	token, opts, err := pairOptsFor(token, redeemURL, hostCAFile, replace)
+	if err != nil {
+		return err
+	}
+	cfg, all, err := pairWith(token, opts)
 	if err != nil {
 		return err
 	}
@@ -236,6 +306,26 @@ func cmdPair(token, redeemURL, hostCAFile string, replace bool) error {
 	return nil
 }
 
+// pairOptsFor is what `pair`'s arguments come to: the token to redeem and
+// the options for it, the person at this machine to ask about a second host
+// among them. A pairing code (pair_code.go) carries the redeem address and the
+// Host CA's fingerprint itself, so it takes neither flag.
+func pairOptsFor(token, redeemURL, hostCAFile string, replace bool) (string, pairOpts, error) {
+	opts := pairOpts{redeemURL: redeemURL, hostCAFile: hostCAFile, replace: replace, askSecond: confirmAddHost}
+	if !isPairCode(token) {
+		return token, opts, nil
+	}
+	if redeemURL != "" || hostCAFile != "" {
+		return "", opts, errors.New("a pairing code (skp_…) carries its own address and certificate; give it alone, without --redeem-url or --host-ca")
+	}
+	pc, err := decodePairCode(token)
+	if err != nil {
+		return "", opts, err
+	}
+	opts.redeemURL, opts.caSHA256 = pc.RedeemURL, pc.CASHA256
+	return pc.Token, opts, nil
+}
+
 // pairReport is what `pair` prints once the pairing stands. Whatever the form
 // (anchored just now, over TCP, over a unix socket, pending, or over the
 // tunnel), it ends by saying to enrol a second factor when this pairing has
@@ -338,6 +428,14 @@ func pairWithTokenAt(token, redeemURL string, replace, forceActive bool) (*Confi
 // redeem URL needs (pair_tcp.go): the Host's enroll port, trusted through
 // that CA alone. A unix:// or platform redeem takes no --host-ca.
 func pairWithTokenVia(token, redeemURL, hostCAFile string, replace, forceActive bool) (*Config, []*Config, error) {
+	return pairWith(token, pairOpts{redeemURL: redeemURL, hostCAFile: hostCAFile, replace: replace, forceActive: forceActive})
+}
+
+// pairWith is every pairing's one path. opts.caSHA256 set (a pairing code)
+// takes the Host CA from the enroll port once the walls below are passed,
+// kept only under that fingerprint (fetchPinnedHostCA).
+func pairWith(token string, opts pairOpts) (*Config, []*Config, error) {
+	redeemURL, hostCAFile, replace, forceActive := opts.redeemURL, opts.hostCAFile, opts.replace, opts.forceActive
 	// ONE BASTION PER MACHINE, and this is the check that matters most.
 	//
 	// It is FIRST on purpose. loadPairings below reaches pairingsDir -> MkdirAll,
@@ -367,12 +465,17 @@ func pairWithTokenVia(token, redeemURL, hostCAFile string, replace, forceActive
 		if err != nil {
 			return nil, nil, err
 		}
-		if hostCAFile == "" {
+		switch {
+		case opts.caSHA256 != "":
+			// A pairing code: the CA comes from the enroll port after the
+			// walls, under the code's fingerprint.
+		case hostCAFile == "":
 			return nil, nil, errors.New("--redeem-url https://… needs --host-ca <the Host's CA, PEM>: it is the only certificate the redeem trusts")
-		}
+		default:
 			if hostCA, err = loadHostCA(hostCAFile); err != nil {
 				return nil, nil, err
 			}
+		}
 		tcpRedeem, transport = u, transportTCP
 	default:
 		s, err := parseUnixRedeemURL(redeemURL)
@@ -397,12 +500,41 @@ func pairWithTokenVia(token, redeemURL, hostCAFile string, replace, forceActive
 		return nil, nil, err
 	}
 	existing, state, err := pairPrecheck(cfgs, handle, replace, forceActive)
+	var second *localSecondHostError
+	if errors.As(err, &second) && opts.askSecond != nil {
+		yes, aerr := opts.askSecond(second.serving, handle)
+		if aerr != nil {
+			return nil, nil, aerr
+		}
+		if !yes {
+			return nil, nil, fmt.Errorf("nothing was paired: %s stays the only Host this computer serves", second.serving)
+		}
+		existing, state, err = pairPrecheckState(forceActive)
+	}
+	// The CA this pair trusts, as a fingerprint: the pairing code's, or that
+	// of the --host-ca file. "" for a platform or unix-socket pairing, whose
+	// CA comes back in the answer.
+	wantCA := opts.caSHA256
+	if wantCA == "" && hostCA != "" {
+		wantCA = caSHA256(hostCA)
+	}
+	var already *alreadyPairedError
+	if errors.As(err, &already) && wantCA != "" {
+		if refusal := sameNameOtherHost(pairingFor(cfgs, handle), wantCA); refusal != nil {
+			return nil, nil, refusal
+		}
+	}
 	if err != nil {
 		return nil, nil, err
 	}
 	if err := replaceKeepsTransport(existing, transport); err != nil {
 		return nil, nil, err
 	}
+	if tcpRedeem != nil && hostCA == "" {
+		if hostCA, err = fetchPinnedHostCA(tcpRedeem, opts.caSHA256); err != nil {
+			return nil, nil, err
+		}
+	}
 	if tcpRedeem != nil {
 		if err := tcpPinRefusal(existing, hostCA); err != nil {
 			return nil, nil, err
@@ -438,7 +570,7 @@ func pairWithTokenVia(token, redeemURL, hostCAFile string, replace, forceActive
 		if prev := pairingFor(cfgs, rr.hostName()); prev != nil && validHostName(rr.hostName()) {
 			existing = prev
 			if !replace {
-				return nil, nil, fmt.Errorf("already paired with %s — run `privatae-bastion pair --replace <token>` to rotate its credentials", prev.HostName)
+				return nil, nil, alreadyPairedRefusal(prev.HostName)
 			}
 			if err := replaceKeepsTransport(existing, transportUnix); err != nil {
 				return nil, nil, err
@@ -463,7 +595,10 @@ func pairWithTokenVia(token, redeemURL, hostCAFile string, replace, forceActive
 		if prev := pairingFor(cfgs, rr.hostName()); prev != nil && validHostName(rr.hostName()) {
 			existing = prev
 			if !replace {
-				return nil, nil, fmt.Errorf("already paired with %s — run `privatae-bastion pair --replace <token>` to rotate its credentials", prev.HostName)
+				if refusal := sameNameOtherHost(prev, caSHA256(hostCA)); refusal != nil {
+					return nil, nil, refusal
+				}
+				return nil, nil, alreadyPairedRefusal(prev.HostName)
 			}
 			if err := replaceKeepsTransport(existing, transportTCP); err != nil {
 				return nil, nil, err
@@ -531,7 +666,7 @@ func pairWithTokenVia(token, redeemURL, hostCAFile string, replace, forceActive
 	if prev := pairingFor(cfgs, rr.HostName); prev != nil {
 		existing = prev
 		if !replace {
-			return nil, nil, fmt.Errorf("already paired with %s — run `privatae-bastion pair --replace <token>` to rotate its credentials", prev.HostName)
+			return nil, nil, alreadyPairedRefusal(prev.HostName)
 		}
 	}
 	opSecret, err := genSecret(24)

client-go/pair_code.go

@@ -0,0 +1,254 @@
+package main
+
+// pair_code.go: the pairing code a Host's "Set up a bastion" card hands out,
+// so pairing a machine is one pasted line.
+//
+//	privatae-bastion pair skp_…        or        … | privatae-bastion pair -
+//
+// The code is the single-use token plus the two things the person used to copy
+// by hand: the Host's enroll address and its CA. The CA does not travel; its
+// fingerprint does. The bastion takes the CA from the enroll port's own TLS
+// chain and keeps it only when its SHA-256 is the one in the code, so the trust
+// is the same as `--host-ca`: the fingerprint comes from the owner's own
+// signed-in card, as the PEM did. From there the pairing is exactly
+// `pair --redeem-url <u> --host-ca <that CA> <t>`.
+//
+// No error here repeats the code, for the reason pair_stdin.go gives: a log of
+// a failed install must not hold the token.
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"encoding/pem"
+	"errors"
+	"fmt"
+	"net"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// pairCodePrefix marks a pairing code; a bare token is skb_….
+const pairCodePrefix = "skp_"
+
+// pairCodeVersion is the one layout this bastion reads.
+const pairCodeVersion = 1
+
+// pairCode is a decoded pairing code: where to redeem, the Host CA's
+// fingerprint, and the token.
+type pairCode struct {
+	RedeemURL string // "u": the Host's enroll port, https://<host>:<port>/<path>
+	CASHA256  string // "ca": SHA-256 of the Host CA certificate's DER, lowercase hex
+	Token     string // "t": the skb_ token
+}
+
+func isPairCode(s string) bool { return strings.HasPrefix(s, pairCodePrefix) }
+
+// decodePairCode reads skp_<base64url(JSON)>: exactly the keys v, u, ca and t,
+// v the one version this bastion knows, u an enroll URL parseTCPRedeemURL
+// takes, ca 64 lowercase hex digits and t a token decodeToken takes.
+func decodePairCode(code string) (pairCode, error) {
+	var pc pairCode
+	bad := func(why string) (pairCode, error) {
+		return pairCode{}, fmt.Errorf("the pairing code is not one this bastion can read (%s); copy the whole line from the card again", why)
+	}
+	raw, err := base64.RawURLEncoding.DecodeString(strings.TrimPrefix(code, pairCodePrefix))
+	if err != nil {
+		return bad("it is not base64url")
+	}
+	var fields map[string]json.RawMessage
+	if err := json.Unmarshal(raw, &fields); err != nil {
+		return bad("it holds no JSON object")
+	}
+	// A map keeps the last of two same-named keys, so "exactly these four"
+	// is counted on the object as written: a key given twice is an extra key.
+	if n, err := jsonObjectKeyCount(raw); err != nil || n != len(fields) {
+		return bad("it names a field twice")
+	}
+	if len(fields) != 4 {
+		return bad(fmt.Sprintf("it has %d fields, and a pairing code has 4", len(fields)))
+	}
+	var v int
+	if err := json.Unmarshal(fields["v"], &v); err != nil {
+		return bad("its version is missing")
+	}
+	if v != pairCodeVersion {
+		return pairCode{}, fmt.Errorf("the pairing code is version %d, and this bastion reads version %d: update the bastion and pair again", v, pairCodeVersion)
+	}
+	for k, dst := range map[string]*string{"u": &pc.RedeemURL, "ca": &pc.CASHA256, "t": &pc.Token} {
+		if err := json.Unmarshal(fields[k], dst); err != nil || *dst == "" {
+			return bad("its " + k + " field is missing")
+		}
+	}
+	if _, err := parseTCPRedeemURL(pc.RedeemURL); err != nil {
+		return bad("its address is not an https enroll address")
+	}
+	if len(pc.CASHA256) != 64 || strings.ToLower(pc.CASHA256) != pc.CASHA256 {
+		return bad("its certificate fingerprint is not 64 lowercase hex digits")
+	}
+	if _, err := hex.DecodeString(pc.CASHA256); err != nil {
+		return bad("its certificate fingerprint is not hex")
+	}
+	if !strings.HasPrefix(pc.Token, "skb_") {
+		return bad("it carries no pairing token")
+	}
+	if _, _, err := decodeToken(pc.Token); err != nil {
+		return bad("its pairing token is malformed")
+	}
+	return pc, nil
+}
+
+// jsonObjectKeyCount counts the keys of the JSON object raw as written,
+// repeats included. raw has already decoded as an object.
+func jsonObjectKeyCount(raw []byte) (int, error) {
+	dec := json.NewDecoder(bytes.NewReader(raw))
+	if _, err := dec.Token(); err != nil { // the opening brace
+		return 0, err
+	}
+	n := 0
+	for dec.More() {
+		if _, err := dec.Token(); err != nil { // the key
+			return 0, err
+		}
+		var v json.RawMessage
+		if err := dec.Decode(&v); err != nil {
+			return 0, err
+		}
+		n++
+	}
+	return n, nil
+}
+
+// pairAnswerTimeout is how long the enroll port has to answer the first
+// connection. A Cloud Host's pairing port drops every address but the one the
+// card opened it to, so a pair from anywhere else gets no answer at all, and
+// without this it would wait for the system's own connect timeout, minutes.
+// A variable so a test can shorten it; nothing else assigns it.
+var pairAnswerTimeout = 10 * time.Second
+
+// pairDial dials the enroll port. A variable so a test can stand in a port
+// that never answers; nothing else assigns it.
+var pairDial = (&net.Dialer{}).DialContext
+
+// pairWindowError is what a pair says when the Host's enroll port did not
+// answer: the plain reason, which is nearly always the pairing window. A type
+// of its own so the redeem's HTTP client, which wraps every dial error in the
+// request's URL, can hand it on as it is.
+type pairWindowError struct{ host string }
+
+func (e *pairWindowError) Error() string {
+	return fmt.Sprintf("%s's pairing port didn't answer within %s. A Cloud Host opens it only to the address "+
+		"your browser used when you opened \"Set up a bastion\", for 15 minutes. Pair from that network, or "+
+		"on the card choose \"Pairing a machine on another network?\" and give this machine's address. Nothing was paired.",
+		e.host, pairAnswerTimeout)
+}
+
+// dialEnrollPort opens a TCP connection to the redeem URL's host and port
+// within pairAnswerTimeout, or says why not in plain words.
+func dialEnrollPort(ctx context.Context, u *url.URL) (net.Conn, error) {
+	addr := u.Host
+	if u.Port() == "" {
+		addr = net.JoinHostPort(u.Hostname(), "443")
+	}
+	ctx, cancel := context.WithTimeout(ctx, pairAnswerTimeout)
+	defer cancel()
+	c, err := pairDial(ctx, "tcp", addr)
+	if err == nil {
+		return c, nil
+	}
+	var ne net.Error
+	if errors.Is(err, context.DeadlineExceeded) || (errors.As(err, &ne) && ne.Timeout()) {
+		return nil, &pairWindowError{host: u.Hostname()}
+	}
+	return nil, fmt.Errorf("could not reach %s's pairing port: %v; nothing was paired", u.Hostname(), err)
+}
+
+// fetchPinnedHostCA takes the Host CA from the enroll port's TLS chain and
+// returns it as PEM, only when it is a CA whose SHA-256 over its DER is
+// wantSHA and the port's own certificate verifies under it alone for
+// tcpServerName, the check hostCATLS makes on every later connection. No
+// system roots are consulted at any point.
+func fetchPinnedHostCA(u *url.URL, wantSHA string) (string, error) {
+	conn, err := dialEnrollPort(context.Background(), u)
+	if err != nil {
+		return "", err
+	}
+	defer conn.Close()
+	var caPEM string
+	tc := &tls.Config{
+		ServerName: tcpServerName, MinVersion: tls.VersionTLS12,
+		// The chain is checked by verifyPinnedChain below, against the pinned
+		// CA alone; the system roots must play no part, so the default
+		// verification is the thing turned off here.
+		InsecureSkipVerify: true,
+		VerifyConnection: func(cs tls.ConnectionState) error {
+			p, err := verifyPinnedChain(cs.PeerCertificates, wantSHA)
+			caPEM = p
+			return err
+		},
+	}
+	_ = conn.SetDeadline(time.Now().Add(30 * time.Second))
+	tlsConn := tls.Client(conn, tc)
+	if err := tlsConn.Handshake(); err != nil {
+		return "", fmt.Errorf("%s's pairing port: %v; nothing was paired", u.Hostname(), err)
+	}
+	_ = tlsConn.Close()
+	return caPEM, nil
+}
+
+// verifyPinnedChain picks the pinned CA out of a presented chain and checks
+// the leaf against it. The leaf is chain[0]; the CA is any later certificate
+// whose SHA-256 is wantSHA.
+func verifyPinnedChain(chain []*x509.Certificate, wantSHA string) (string, error) {
+	if len(chain) == 0 {
+		return "", errors.New("the Host's pairing port presented no certificate")
+	}
+	var ca *x509.Certificate
+	sawCA := false
+	for _, c := range chain[1:] {
+		if !c.IsCA {
+			continue
+		}
+		sawCA = true
+		sum := sha256.Sum256(c.Raw)
+		if hex.EncodeToString(sum[:]) == wantSHA {
+			ca = c
+			break
+		}
+	}
+	if ca == nil {
+		if sawCA {
+			return "", errors.New("the Host's pairing port presented a certificate authority other than the one this pairing code names — refusing")
+		}
+		return "", errors.New("the Host's pairing port did not present its certificate authority, so this pairing code cannot be checked — refusing (the Host needs a newer release, or pair with --host-ca)")
+	}
+	roots := x509.NewCertPool()
+	roots.AddCert(ca)
+	inter := x509.NewCertPool()
+	for _, c := range chain[1:] {
+		if c != ca {
+			inter.AddCert(c)
+		}
+	}
+	if _, err := chain[0].Verify(x509.VerifyOptions{Roots: roots, Intermediates: inter, DNSName: tcpServerName}); err != nil {
+		return "", fmt.Errorf("the Host's pairing port certificate is not signed by the certificate authority this pairing code names: %v — refusing", err)
+	}
+	return string(pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: ca.Raw})), nil
+}
+
+// caSHA256 is the fingerprint a pairing code carries for a PEM CA: SHA-256 of
+// the first certificate's DER, lowercase hex. "" when the PEM holds none.
+func caSHA256(caPEM string) string {
+	certs := pemCerts(caPEM)
+	if len(certs) == 0 {
+		return ""
+	}
+	sum := sha256.Sum256(certs[0].Raw)
+	return hex.EncodeToString(sum[:])
+}

client-go/pair_code_linux_test.go

@@ -0,0 +1,626 @@
+//go:build linux
+
+// The pairing code a Cloud Host's card hands out (pair_code.go): one string
+// carrying the token, the enroll address and the Host CA's fingerprint, and
+// the question a local machine asks before it serves a second Host
+// (pair_terminal.go).
+//
+// Uses the fixtures of local_host_linux_test.go and local_host_tcp_linux_test.go
+// (newTestCA, pairingBox, startTCPEnrollHost, homeToken), so it carries the same
+// build tag.
+
+package main
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/sha256"
+	"crypto/tls"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"math/big"
+	"net"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"testing"
+	"time"
+)
+
+// makePairCode builds a code the way a Host's card does: skp_ and base64url,
+// no padding, of the JSON object fields.
+func makePairCode(t *testing.T, fields map[string]any) string {
+	t.Helper()
+	raw, err := json.Marshal(fields)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return pairCodePrefix + base64.RawURLEncoding.EncodeToString(raw)
+}
+
+func pairCodeFingerprint(ca *testCA) string {
+	sum := sha256.Sum256(ca.cert.Raw)
+	return hex.EncodeToString(sum[:])
+}
+
+// chainWithCA is the enroll port's certificate as a Host from this release
+// serves it: the leaf, then the CA.
+func chainWithCA(t *testing.T, ca *testCA) tls.Certificate {
+	t.Helper()
+	c := ca.serverCert(t, tcpServerName)
+	c.Certificate = append(c.Certificate, ca.cert.Raw)
+	return c
+}
+
+func goodCodeFields(url, fp string) map[string]any {
+	return map[string]any{"v": 1, "u": url, "ca": fp, "t": homeToken()}
+}
+
+// ── decoding ────────────────────────────────────────────────────────────────
+
+func TestAPairingCodeDecodes(t *testing.T) {
+	fp := strings.Repeat("ab", 32)
+	code := makePairCode(t, goodCodeFields("https://maple.example-id.cloud.example:8810/v1/local/redeem", fp))
+	pc, err := decodePairCode(code)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if pc.RedeemURL != "https://maple.example-id.cloud.example:8810/v1/local/redeem" || pc.CASHA256 != fp || pc.Token != homeToken() {
+		t.Fatalf("decoded: %+v", pc)
+	}
+	token, opts, err := pairOptsFor(code, "", "", false)
+	if err != nil || token != homeToken() || opts.redeemURL != pc.RedeemURL || opts.caSHA256 != fp || opts.hostCAFile != "" || opts.askSecond == nil {
+		t.Fatalf("pair's options from a code: %q %+v %v", token, opts, err)
+	}
+	if _, _, err := pairOptsFor(code, "", "host-ca.pem", false); err == nil {
+		t.Fatal("a code carries its own certificate: --host-ca beside it must be refused")
+	}
+	if tok, opts, err := pairOptsFor(homeToken(), "", "", false); err != nil || tok != homeToken() || opts.caSHA256 != "" {
+		t.Fatalf("a bare token passes through as it was: %q %+v %v", tok, opts, err)
+	}
+}
+
+// A code this bastion cannot read is refused with what was wrong, never
+// with its content: a log of a failed install must not hold the token.
+func TestAPairingCodeIsReadStrictly(t *testing.T) {
+	fp := strings.Repeat("0f", 32)
+	u := "https://maple.example-id.cloud.example:8810/v1/local/redeem"
+	with := func(edit func(m map[string]any)) string {
+		m := goodCodeFields(u, fp)
+		edit(m)
+		return makePairCode(t, m)
+	}
+	for name, code := range map[string]string{
+		"garbled":           "skp_%%%not-base64%%%",
+		"not JSON":          pairCodePrefix + base64.RawURLEncoding.EncodeToString([]byte("secret-x home")),
+		"wrong version":     with(func(m map[string]any) { m["v"] = 2 }),
+		"version as text":   with(func(m map[string]any) { m["v"] = "1" }),
+		"extra key":         with(func(m map[string]any) { m["x"] = "y" }),
+		"missing key":       with(func(m map[string]any) { delete(m, "ca") }),
+		"another key":       with(func(m map[string]any) { delete(m, "t"); m["token"] = homeToken() }),
+		"http address":      with(func(m map[string]any) { m["u"] = "http://maple.example-id.cloud.example:8810/v1/local/redeem" }),
+		"address with user": with(func(m map[string]any) { m["u"] = "https://a@maple.example-id.cloud.example/v1/local/redeem" }),
+		"short fingerprint": with(func(m map[string]any) { m["ca"] = fp[:63] }),
+		"upper fingerprint": with(func(m map[string]any) { m["ca"] = strings.ToUpper(fp) }),
+		"not hex":           with(func(m map[string]any) { m["ca"] = strings.Repeat("zz", 32) }),
+		"no skb_ token":     with(func(m map[string]any) { m["t"] = "secret-x" }),
+		"malformed token":   with(func(m map[string]any) { m["t"] = "skb_bm9kb3Q" }), // base64url("nodot")
+	} {
+		_, err := decodePairCode(code)
+		if err == nil {
+			t.Errorf("%s: refused nothing", name)
+			continue
+		}
+		if strings.Contains(err.Error(), "secret-x") || strings.Contains(err.Error(), homeToken()) {
+			t.Errorf("%s: the refusal repeats the token: %v", name, err)
+		}
+	}
+	_, err := decodePairCode(with(func(m map[string]any) { m["v"] = 2 }))
+	if err == nil || !strings.Contains(err.Error(), "update the bastion") {
+		t.Fatalf("a newer code says to update the bastion: %v", err)
+	}
+}
+
+// ── the pinned CA ───────────────────────────────────────────────────────────
+
+// SECURITY: the CA is taken from the enroll port's chain only when its
+// SHA-256 is the code's, and the port's own certificate must verify under it
+// for tcpServerName. A chain without the CA, another CA, or a leaf another CA
+// signed are refused before the token is spent, and nothing is saved.
+func TestAPairingCodePinsTheHostCAByFingerprint(t *testing.T) {
+	ca := newTestCA(t, "maple host CA")
+	impostor := newTestCA(t, "impostor")
+	leafByImpostor := impostor.serverCert(t, tcpServerName)
+	leafByImpostor.Certificate = append(leafByImpostor.Certificate, ca.cert.Raw)
+	for name, c := range map[string]struct {
+		serve tls.Certificate
+		fp    string
+		want  string
+	}{
+		"no CA in the chain":       {ca.serverCert(t, tcpServerName), pairCodeFingerprint(ca), "did not present"},
+		"another CA in the chain":  {chainWithCA(t, impostor), pairCodeFingerprint(ca), "other than"},
+		"another fingerprint":      {chainWithCA(t, ca), pairCodeFingerprint(impostor), "other than"},
+		"a leaf another CA signed": {leafByImpostor, pairCodeFingerprint(ca), "not signed by"},
+		"the CA, under another name": {func() tls.Certificate {
+			c := ca.serverCert(t, "maple.example")
+			c.Certificate = append(c.Certificate, ca.cert.Raw)
+			return c
+		}(), pairCodeFingerprint(ca), "not signed by"},
+	} {
+		t.Run(name, func(t *testing.T) {
+			pairingBox(t)
+			h := startTCPEnrollHost(t, ca, c.serve, "127.0.0.1:18821")
+			token, opts, err := pairOptsFor(makePairCode(t, goodCodeFields(h.url, c.fp)), "", "", false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, _, err = pairWith(token, opts)
+			if err == nil || !strings.Contains(err.Error(), c.want) {
+				t.Fatalf("want a refusal naming %q, got %v", c.want, err)
+			}
+			if h.hits.Load() != 0 {
+				t.Fatal("the token went to an enroll port whose CA was never checked")
+			}
+			if cfgs, _ := loadPairings(); len(cfgs) != 0 {
+				t.Fatalf("a refused pairing saved %d pairings", len(cfgs))
+			}
+		})
+	}
+}
+
+// A good code pairs exactly as --redeem-url u --host-ca <that CA> t does: the
+// same TCP pairing, the same CA pinned.
+func TestAPairingCodePairsAsTheHostCAFileDoes(t *testing.T) {
+	pairingBox(t)
+	ca := newTestCA(t, "maple host CA")
+	h := startTCPEnrollHost(t, ca, chainWithCA(t, ca), "127.0.0.1:18822")
+	token, opts, err := pairOptsFor(makePairCode(t, goodCodeFields(h.url, pairCodeFingerprint(ca))), "", "", false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg, _, err := pairWith(token, opts)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !cfg.tcpTransport() || !sameCAs(cfg.CACert, ca.pem) || cfg.LaneAddr != "127.0.0.1:18822" || cfg.HostName != "home.example.test" {
+		t.Fatalf("the pairing: transport %q lane %q host %q", cfg.Transport, cfg.LaneAddr, cfg.HostName)
+	}
+	h.mu.Lock()
+	req, sni := h.last, h.sni
+	h.mu.Unlock()
+	if req.Secret != "secret-x" || req.Handle != "home" || sni != tcpServerName {
+		t.Fatalf("the redeem is today's: secret %q handle %q sni %q", req.Secret, req.Handle, sni)
+	}
+
+	// The same code again: already paired with this Host, nothing changed,
+	// and the error is the one `pair` exits 3 on.
+	before, _ := os.ReadFile(filepath.Join(mustPairingsDir(t), "home.example.test.json"))
+	token, opts, _ = pairOptsFor(makePairCode(t, goodCodeFields(h.url, pairCodeFingerprint(ca))), "", "", false)
+	_, _, err = pairWith(token, opts)
+	var already *alreadyPairedError
+	if !errors.As(err, &already) {
+		t.Fatalf("pairing the same Host again must be alreadyPairedError (exit %d), got %v", pairExitAlreadyPaired, err)
+	}
+	after, _ := os.ReadFile(filepath.Join(mustPairingsDir(t), "home.example.test.json"))
+	if string(before) != string(after) || h.hits.Load() != 1 {
+		t.Fatal("an already-paired Host must change nothing and spend no token")
+	}
+
+	// Another Host of the same name (Cloud names repeat): a different CA, so
+	// never "already connected".
+	other := newTestCA(t, "another maple")
+	h2 := startTCPEnrollHost(t, other, chainWithCA(t, other), "127.0.0.1:18823")
+	token, opts, _ = pairOptsFor(makePairCode(t, goodCodeFields(h2.url, pairCodeFingerprint(other))), "", "", false)
+	_, _, err = pairWith(token, opts)
+	if err == nil || errors.As(err, &already) || !strings.Contains(err.Error(), "different Host named") {
+		t.Fatalf("a same-named Host under another CA is a plain refusal, not exit 3: %v", err)
+	}
+}
+
+func mustPairingsDir(t *testing.T) string {
+	t.Helper()
+	d, err := pairingsDir()
+	if err != nil {
+		t.Fatal(err)
+	}
+	return d
+}
+
+// ── an enroll port that does not answer ─────────────────────────────────────
+
+// A Cloud Host's pairing port drops every address but the one the card opened
+// it to. A pair from elsewhere says so within pairAnswerTimeout, in plain
+// words, instead of waiting for the system's connect timeout. Both the code
+// and --host-ca paths.
+func TestAnEnrollPortThatDoesNotAnswerNamesThePairingWindow(t *testing.T) {
+	pairingBox(t)
+	oldTimeout, oldDial := pairAnswerTimeout, pairDial
+	t.Cleanup(func() { pairAnswerTimeout, pairDial = oldTimeout, oldDial })
+	pairAnswerTimeout = 150 * time.Millisecond
+	pairDial = func(ctx context.Context, _, _ string) (net.Conn, error) {
+		<-ctx.Done()
+		return nil, ctx.Err()
+	}
+	u := "https://maple.example-id.cloud.example:8810/v1/local/redeem"
+	ca := newTestCA(t, "maple host CA")
+	check := func(name string, err error, took time.Duration) {
+		t.Helper()
+		var we *pairWindowError
+		if !errors.As(err, &we) {
+			t.Fatalf("%s: want the pairing-window message, got %v", name, err)
+		}
+		msg := err.Error()
+		if !strings.Contains(msg, "maple.example-id.cloud.example's pairing port didn't answer") ||
+			!strings.Contains(msg, "15 minutes") || !strings.Contains(msg, "another network") || !strings.Contains(msg, "Nothing was paired") {
+			t.Fatalf("%s: the message: %s", name, msg)
+		}
+		if took > 2*time.Second {
+			t.Fatalf("%s: took %s, the timeout is %s", name, took, pairAnswerTimeout)
+		}
+	}
+	start := time.Now()
+	token, opts, _ := pairOptsFor(makePairCode(t, goodCodeFields(u, pairCodeFingerprint(ca))), "", "", false)
+	_, _, err := pairWith(token, opts)
+	check("pairing code", err, time.Since(start))
+
+	start = time.Now()
+	_, _, err = pairWithTokenVia(homeToken(), u, writeCA(t, ca), false, false)
+	check("--host-ca", err, time.Since(start))
+}
+
+// ── a local machine that already serves a Host ──────────────────────────────
+
+// fakeTerminal stands in a person at this machine: their answer, and what
+// the question said. answer "" with noTerm set is a run with no terminal.
+type fakeTerminal struct {
+	answer string
+	noTerm bool
+	asked  strings.Builder
+	opened int
+}
+
+func (f *fakeTerminal) use(t *testing.T) {
+	t.Helper()
+	old := openTerminal
+	t.Cleanup(func() { openTerminal = old })
+	openTerminal = func() (io.Reader, io.Writer, func(), error) {
+		f.opened++
+		if f.noTerm {
+			return nil, nil, nil, errNoTerminal
+		}
+		return strings.NewReader(f.answer), &f.asked, func() {}, nil
+	}
+}
+
+func otherToken() string { return "skb_b3RoZXIuc2VjcmV0LXk" } // base64url("other.secret-y")
+
+// SECURITY: a local machine that serves a Host adds another only on a yes
+// typed at this machine's terminal. No terminal, or any answer but y or yes,
+// refuses before the token is spent, and the first pairing is untouched.
+// Every caller but `pair` (claim-anchor, the pairing op) keeps the old
+// refusal: it has no person to ask.
+func TestALocalMachineAddsASecondHostOnlyOnAYesTypedHere(t *testing.T) {
+	pairingBox(t)
+	ca := newTestCA(t, "home host CA")
+	home := startTCPEnrollHost(t, ca, ca.serverCert(t, tcpServerName), "127.0.0.1:18831")
+	if _, _, err := pairWithTokenVia(homeToken(), home.url, writeCA(t, ca), false, false); err != nil {
+		t.Fatal(err)
+	}
+	first, _ := os.ReadFile(filepath.Join(mustPairingsDir(t), "home.example.test.json"))
+
+	otherCA := newTestCA(t, "other host CA")
+	other := startTCPEnrollHost(t, otherCA, chainWithCA(t, otherCA), "127.0.0.1:18832")
+	other.set(func(h *tcpEnrollHost) {
+		h.edit = func(ans map[string]any) { ans["host_handle"], ans["host_name"] = "other", "other.example.test" }
+	})
+	code := makePairCode(t, map[string]any{"v": 1, "u": other.url, "ca": pairCodeFingerprint(otherCA), "t": otherToken()})
+	pairOther := func() error {
+		token, opts, err := pairOptsFor(code, "", "", false)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, _, err = pairWith(token, opts)
+		return err
+	}
+	untouched := func(why string) {
+		t.Helper()
+		now, _ := os.ReadFile(filepath.Join(mustPairingsDir(t), "home.example.test.json"))
+		cfgs, _ := loadPairings()
+		if string(now) != string(first) {
+			t.Fatalf("%s: the first pairing changed", why)
+		}
+		if why != "yes" && (len(cfgs) != 1 || other.hits.Load() != 0) {
+			t.Fatalf("%s: %d pairings, %d redeems", why, len(cfgs), other.hits.Load())
+		}
+	}
+
+	// No terminal: refused, and it says where to run it instead.
+	ft := &fakeTerminal{noTerm: true}
+	ft.use(t)
+	if err := pairOther(); err == nil || !strings.Contains(err.Error(), "terminal window on this computer") {
+		t.Fatalf("no terminal must refuse in plain words: %v", err)
+	}
+	untouched("no terminal")
+
+	// Anything but y or yes.
+	for _, a := range []string{"\n", "n\n", "no\n", "yess\n", "sure\n", ""} {
+		ft := &fakeTerminal{answer: a}
+		ft.use(t)
+		if err := pairOther(); err == nil || !strings.Contains(err.Error(), "stays the only Host") {
+			t.Fatalf("answer %q must refuse: %v", a, err)
+		}
+		if !strings.Contains(ft.asked.String(), "already serves your Host home.example.test. Add other as well?") {
+			t.Fatalf("the question: %q", ft.asked.String())
+		}
+		untouched("answer " + a)
+	}
+
+	// The callers with no person to ask keep the refusal, and ask nobody.
+	ft = &fakeTerminal{answer: "y\n"}
+	ft.use(t)
+	var second *localSecondHostError
+	if _, _, err := pairWithTokenVia(otherToken(), other.url, writeCA(t, otherCA), false, false); !errors.As(err, &second) {
+		t.Fatalf("pairWithTokenVia (no person to ask) must keep the refusal: %v", err)
+	}
+	if ft.opened != 0 {
+		t.Fatal("a caller with no person to ask opened the terminal")
+	}
+	untouched("no asker")
+
+	// A typed yes adds it beside the first.
+	ft = &fakeTerminal{answer: "Yes\n"}
+	ft.use(t)
+	if err := pairOther(); err != nil {
+		t.Fatal(err)
+	}
+	cfgs, _ := loadPairings()
+	if len(cfgs) != 2 || pairingFor(cfgs, "other.example.test") == nil {
+		t.Fatalf("after yes: %d pairings", len(cfgs))
+	}
+	untouched("yes")
+}
+
+// secondHostStdinChild set to 1 makes this test binary the child of
+// TestTheSecondHostAnswerIsNeverReadFromStandardInput.
+const secondHostStdinChild = "PRIVATAE_TEST_SECOND_HOST_STDIN_CHILD"
+
+// SECURITY: the answer to the second-Host question comes from the controlling
+// terminal, never from standard input. The installers hand the pairing code to
+// `pair -` on standard input, so a "y" piped in after the code must not add a
+// Host. The real openTerminal runs in a child with no controlling terminal (a
+// session of its own) and "y" waiting on its standard input: it must find no
+// terminal, and leave standard input unread.
+func TestTheSecondHostAnswerIsNeverReadFromStandardInput(t *testing.T) {
+	if os.Getenv(secondHostStdinChild) == "1" {
+		yes, err := confirmAddHost("home.example.test", "other")
+		rest, _ := io.ReadAll(os.Stdin)
+		fmt.Printf("child: yes=%v refused=%v stdin-left=%q\n", yes, err != nil && strings.Contains(err.Error(), "no terminal"), rest)
+		os.Exit(0)
+	}
+	self, err := os.Executable()
+	if err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command(self, "-test.run=^TestTheSecondHostAnswerIsNeverReadFromStandardInput$")
+	cmd.Env = append(os.Environ(), secondHostStdinChild+"=1")
+	cmd.Stdin = strings.NewReader("y\n")
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("the child: %v\n%s", err, out)
+	}
+	if !strings.Contains(string(out), `child: yes=false refused=true stdin-left="y\n"`) {
+		t.Fatalf("a y on standard input must neither answer the question nor be read: %s", out)
+	}
+}
+
+// The refusal names this system's own way to a networked bastion, and says
+// that the Host already here would have to be paired again.
+func TestTheLocalRefusalSaysWhatANetworkedReinstallCosts(t *testing.T) {
+	msg := localOneHostRefusal("home.example.test")
+	if !strings.Contains(msg, "install.sh --networked") || strings.Contains(msg, "install.ps1") {
+		t.Fatalf("on linux it names install.sh: %s", msg)
+	}
+	if !strings.Contains(msg, "home.example.test has to be paired with it again") || !strings.Contains(msg, "answer yes at this computer's terminal") {
+		t.Fatalf("the refusal: %s", msg)
+	}
+}
+
+// ── what the Host's card actually makes ─────────────────────────────────────
+
+// Made by the C-Series Host's own pairing_code (bastion_enroll.py) from the CA
+// below and an invented token, for an invented address: compact JSON with the
+// keys v, u, ca and t in base64url without padding. The bastion must read
+// exactly that, and the fingerprint must be the one caSHA256 computes from
+// the same CA, or a real code would never pin.
+const hostMadePairCode = "skp_eyJ2IjoxLCJ1IjoiaHR0cHM6Ly9tYXBsZS5leGFtcGxlLWlkLmNsb3VkLmV4YW1wbGU6ODgxMC92MS9sb2NhbC9yZWRlZW0iLCJjYSI6IjcyMzNkOWU4ODU5MzIyZjE1YTJiNmMzYWIyMmZiNjMxNGI4M2I0Njg2ZmNhYmZiYjRmNGU1NDE5NDA1MTFkMDciLCJ0Ijoic2tiX2JXRndiR1V1YzJWamNtVjBMV2x1ZG1WdWRHVmtMVEF3TURFIn0"
+
+const hostMadePairCodeCA = `-----BEGIN CERTIFICATE-----
+MIIBTTCB9KADAgECAgIQkjAKBggqhkjOPQQDAjAjMSEwHwYDVQQDDBhleGFtcGxl
+IGludmVudGVkIGhvc3QgQ0EwIBcNMjYwMTAxMDAwMDAwWhgPMjEyNTEyMDgwMDAw
+MDBaMCMxITAfBgNVBAMMGGV4YW1wbGUgaW52ZW50ZWQgaG9zdCBDQTBZMBMGByqG
+SM49AgEGCCqGSM49AwEHA0IABA32JMrh4sMMLvNNoSBq5FgXFgHd/2n71Qk9ayje
+Kj9rdt+Q3CFYWgtCqFHc6ZLUfXexKkdWvnET3px2hGqZWbKjFjAUMBIGA1UdEwEB
+/wQIMAYBAf8CAQAwCgYIKoZIzj0EAwIDSAAwRQIhAIQ6sKtiqxcAQTPq7+toiEl0
+qrWb4CKKB2UtvcQoC9YwAiBYGKbmvG9ZszE8X7uKUGexjP9x6lDOwqfmnLoruuVg
+Kg==
+-----END CERTIFICATE-----
+`
+
+func TestACodeTheHostMadeDecodesAndPins(t *testing.T) {
+	pc, err := decodePairCode(hostMadePairCode)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if pc.RedeemURL != "https://maple.example-id.cloud.example:8810/v1/local/redeem" ||
+		pc.Token != "skb_bWFwbGUuc2VjcmV0LWludmVudGVkLTAwMDE" { // base64url("maple.secret-invented-0001")
+		t.Fatalf("decoded: %+v", pc)
+	}
+	if got := caSHA256(hostMadePairCodeCA); got != pc.CASHA256 {
+		t.Fatalf("the Host's fingerprint %s is not caSHA256 of its CA (%s)", pc.CASHA256, got)
+	}
+	if h, _, err := decodeToken(pc.Token); err != nil || h != "maple" {
+		t.Fatalf("the token's handle: %q %v", h, err)
+	}
+}
+
+// SECURITY: a key given twice is an extra key. A map would keep only the
+// last, so two codes that differ in which token they carry could both read as
+// "exactly v, u, ca and t".
+func TestAPairingCodeWithAKeyGivenTwiceIsRefused(t *testing.T) {
+	fp := strings.Repeat("0f", 32)
+	u := "https://maple.example-id.cloud.example:8810/v1/local/redeem"
+	raw := `{"v":1,"u":"` + u + `","ca":"` + fp + `","t":"` + otherToken() + `","t":"` + homeToken() + `"}`
+	if _, err := decodePairCode(pairCodePrefix + base64.RawURLEncoding.EncodeToString([]byte(raw))); err == nil {
+		t.Fatal("a code naming t twice was read")
+	}
+	once := `{"v":1,"u":"` + u + `","ca":"` + fp + `","t":"` + homeToken() + `"}`
+	if _, err := decodePairCode(pairCodePrefix + base64.RawURLEncoding.EncodeToString([]byte(once))); err != nil {
+		t.Fatalf("the same code with t once: %v", err)
+	}
+}
+
+// pinnedChainCert is a certificate for the pinned-chain cases: signed by
+// parent (self-signed when parent is nil), a CA or not, valid from nb to na.
+func pinnedChainCert(t *testing.T, cn string, isCA bool, nb, na time.Time, parent *x509.Certificate, parentKey *ecdsa.PrivateKey, dns ...string) (*x509.Certificate, *ecdsa.PrivateKey) {
+	t.Helper()
+	key, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	tmpl := &x509.Certificate{SerialNumber: big.NewInt(time.Now().UnixNano()), Subject: pkix.Name{CommonName: cn},
+		NotBefore: nb, NotAfter: na, DNSNames: dns, BasicConstraintsValid: true, IsCA: isCA}
+	if isCA {
+		tmpl.KeyUsage = x509.KeyUsageCertSign | x509.KeyUsageDigitalSignature
+	} else {
+		tmpl.KeyUsage, tmpl.ExtKeyUsage = x509.KeyUsageDigitalSignature, []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}
+	}
+	signer, signKey := tmpl, key
+	if parent != nil {
+		signer, signKey = parent, parentKey
+	}
+	der, err := x509.CreateCertificate(rand.Reader, tmpl, signer, &key.PublicKey, signKey)
+	if err != nil {
+		t.Fatal(err)
+	}
+	c, _ := x509.ParseCertificate(der)
+	return c, key
+}
+
+// SECURITY: the cases of the pinned chain the TLS tests do not reach. A
+// certificate with the code's fingerprint that is not a CA, and a CA that has
+// expired, are refused; the pinned CA anywhere after the leaf, beside other
+// certificates, is the one returned.
+func TestThePinnedChainTakesOnlyAValidCAWithTheFingerprint(t *testing.T) {
+	now := time.Now()
+	fpOf := func(c *x509.Certificate) string { s := sha256.Sum256(c.Raw); return hex.EncodeToString(s[:]) }
+
+	ca, caKey := pinnedChainCert(t, "maple host CA", true, now.Add(-time.Hour), now.Add(24*time.Hour), nil, nil)
+	leaf, _ := pinnedChainCert(t, "leaf", false, now.Add(-time.Hour), now.Add(time.Hour), ca, caKey, tcpServerName)
+	other, _ := pinnedChainCert(t, "another CA", true, now.Add(-time.Hour), now.Add(24*time.Hour), nil, nil)
+	got, err := verifyPinnedChain([]*x509.Certificate{leaf, other, ca}, fpOf(ca))
+	if err != nil || caSHA256(got) != fpOf(ca) {
+		t.Fatalf("the pinned CA after another certificate: %v", err)
+	}
+
+	// A self-signed certificate that is not a CA, signing the leaf.
+	notCA, notCAKey := pinnedChainCert(t, "not a CA", false, now.Add(-time.Hour), now.Add(24*time.Hour), nil, nil)
+	leaf2, _ := pinnedChainCert(t, "leaf", false, now.Add(-time.Hour), now.Add(time.Hour), notCA, notCAKey, tcpServerName)
+	if _, err := verifyPinnedChain([]*x509.Certificate{leaf2, notCA}, fpOf(notCA)); err == nil {
+		t.Fatal("a certificate with the fingerprint that is not a CA was pinned")
+	}
+
+	// An expired CA, with a leaf it signed that is still in its dates.
+	old, oldKey := pinnedChainCert(t, "expired host CA", true, now.Add(-48*time.Hour), now.Add(-time.Hour), nil, nil)
+	leaf3, _ := pinnedChainCert(t, "leaf", false, now.Add(-2*time.Hour), now.Add(time.Hour), old, oldKey, tcpServerName)
+	if _, err := verifyPinnedChain([]*x509.Certificate{leaf3, old}, fpOf(old)); err == nil {
+		t.Fatal("an expired CA was pinned")
+	}
+
+	if _, err := verifyPinnedChain([]*x509.Certificate{leaf}, fpOf(ca)); err == nil {
+		t.Fatal("a chain of the leaf alone was accepted")
+	}
+}
+
+// Exit 3 means the same Host, so the same CA, on every TCP pairing: a
+// --host-ca pair to a Host of a name already paired here under another CA is
+// a plain failure, as the pairing code's is.
+func TestHostCAFileWithASameNamedHostUnderAnotherCAIsNotAlreadyPaired(t *testing.T) {
+	pairingBox(t)
+	ca := newTestCA(t, "home host CA")
+	h := startTCPEnrollHost(t, ca, ca.serverCert(t, tcpServerName), "127.0.0.1:18841")
+	if _, _, err := pairWithTokenVia(homeToken(), h.url, writeCA(t, ca), false, false); err != nil {
+		t.Fatal(err)
+	}
+	var already *alreadyPairedError
+	if _, _, err := pairWithTokenVia(homeToken(), h.url, writeCA(t, ca), false, false); !errors.As(err, &already) {
+		t.Fatalf("the same Host under its own CA is already paired (exit 3): %v", err)
+	}
+	other := newTestCA(t, "another home")
+	h2 := startTCPEnrollHost(t, other, other.serverCert(t, tcpServerName), "127.0.0.1:18842")
+	_, _, err := pairWithTokenVia(homeToken(), h2.url, writeCA(t, other), false, false)
+	if err == nil || errors.As(err, &already) || !strings.Contains(err.Error(), "different Host named") {
+		t.Fatalf("a same-named Host under another CA is a plain refusal, not exit 3: %v", err)
+	}
+	if h2.hits.Load() != 0 {
+		t.Fatal("the refusal spent the other Host's token")
+	}
+}
+
+// SECURITY: the name in the question is the token's handle, which whoever
+// made the token chose. A control character or escape sequence in it reaches
+// the person's screen escaped, so it cannot rewrite the question.
+func TestTheSecondHostQuestionEscapesTheTokensName(t *testing.T) {
+	ft := &fakeTerminal{answer: "n\n"}
+	ft.use(t)
+	if _, err := confirmAddHost("home.example.test", "evil\r\x1b[2K\x1b[1Ainnocent"); err != nil {
+		t.Fatal(err)
+	}
+	q := ft.asked.String()
+	if strings.ContainsAny(q, "\x1b\r") {
+		t.Fatalf("the question carries the handle's control bytes raw: %q", q)
+	}
+	if !strings.Contains(q, `Add "evil\r\x1b[2K\x1b[1Ainnocent" as well?`) {
+		t.Fatalf("the question: %q", q)
+	}
+	ft = &fakeTerminal{answer: "n\n"}
+	ft.use(t)
+	if _, err := confirmAddHost("home.example.test", "maple"); err != nil || !strings.Contains(ft.asked.String(), "Add maple as well?") {
+		t.Fatalf("a plain name is shown as it is: %q %v", ft.asked.String(), err)
+	}
+}
+
+// The name the redeem answers with is checked again after the redeem (the
+// token's handle can differ from it). There too, the same name under another
+// CA is a plain failure, never exit 3.
+func TestARedeemAnsweringAPairedNameUnderAnotherCAIsNotAlreadyPaired(t *testing.T) {
+	pairingBox(t)
+	ca := newTestCA(t, "home host CA")
+	h := startTCPEnrollHost(t, ca, ca.serverCert(t, tcpServerName), "127.0.0.1:18843")
+	if _, _, err := pairWithTokenVia(homeToken(), h.url, writeCA(t, ca), false, false); err != nil {
+		t.Fatal(err)
+	}
+	other := newTestCA(t, "another home")
+	h2 := startTCPEnrollHost(t, other, chainWithCA(t, other), "127.0.0.1:18844")
+	// otherToken's handle is "other"; the Host answers home.example.test.
+	token, opts, err := pairOptsFor(makePairCode(t, map[string]any{"v": 1, "u": h2.url, "ca": pairCodeFingerprint(other), "t": otherToken()}), "", "", false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	opts.askSecond = func(string, string) (bool, error) { return true, nil }
+	_, _, err = pairWith(token, opts)
+	var already *alreadyPairedError
+	if err == nil || errors.As(err, &already) || !strings.Contains(err.Error(), "different Host named home.example.test") {
+		t.Fatalf("a redeem naming a paired Host under another CA is a plain refusal, not exit 3: %v", err)
+	}
+	if cfgs, _ := loadPairings(); len(cfgs) != 1 {
+		t.Fatalf("%d pairings after the refusal", len(cfgs))
+	}
+}

client-go/pair_tcp.go

@@ -149,11 +149,19 @@ func redeemOverTCP(u *url.URL, caPEM string, body []byte) (tcpRedeemResp, error)
 	if err != nil {
 		return rr, fmt.Errorf("--host-ca: %w", err)
 	}
+	// The dial is dialEnrollPort's: an enroll port that does not answer in
+	// pairAnswerTimeout gets the pairing window's plain message, not a wait
+	// for the system's connect timeout.
 	httpc := &http.Client{Timeout: 30 * time.Second, Transport: &http.Transport{
 		Proxy: nil, TLSClientConfig: tc, ForceAttemptHTTP2: false,
+		DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) { return dialEnrollPort(ctx, u) },
 	}, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
 	resp, err := httpc.Post(u.String(), "application/json", bytes.NewReader(body))
 	if err != nil {
+		var we *pairWindowError
+		if errors.As(err, &we) {
+			return rr, we
+		}
 		return rr, fmt.Errorf("redeem: %w", err)
 	}
 	defer resp.Body.Close()

client-go/pair_terminal.go

@@ -0,0 +1,66 @@
+package main
+
+// pair_terminal.go: the one question `pair` asks a person, on a local machine
+// that already serves a Host: whether to add another.
+//
+// A local bastion used to serve one Host, full stop, because on a single-user
+// machine a second Host appearing meant someone else had got a token onto the
+// box. A person who uses two Hosts (a Cloud machine beside the platform one)
+// could not pair the second at all. Now the second is added when the person at
+// this machine says so, and only then: the answer is read from the controlling
+// terminal, never from standard input, so a token piped in by a script or an
+// installer (which feeds the pairing code through standard input) cannot add a
+// Host by itself. With no terminal there is nobody to ask, and the pair is
+// refused.
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+)
+
+// errNoTerminal: this process has no controlling terminal to ask on.
+var errNoTerminal = errors.New("no terminal")
+
+// openTerminal opens the controlling terminal for one question: a reader for
+// the answer, a writer for the question, and a close. A variable so a test can
+// stand in a person; nothing else assigns it.
+var openTerminal = openControllingTerminal
+
+// terminalSafeName is a Host name as the question shows it. newHost is the
+// handle the token carries, which nothing has checked yet: whoever made the
+// token chose it, and a control character or an escape sequence in it could
+// rewrite the question on the person's screen. A plain host name is shown as
+// it is; anything else is quoted, every such byte escaped.
+func terminalSafeName(name string) string {
+	if validHostName(name) {
+		return name
+	}
+	return strconv.QuoteToASCII(name)
+}
+
+// confirmAddHost asks whether to add newHost beside serving, the Host this
+// local machine already serves. True only for a typed y or yes.
+func confirmAddHost(serving, newHost string) (bool, error) {
+	in, out, closeTerm, err := openTerminal()
+	if err != nil {
+		return false, fmt.Errorf("this computer already serves your Host %s, and adding another needs a yes typed "+
+			"at this computer, but this run has no terminal to ask in. Run the same command in a terminal "+
+			"window on this computer; nothing was paired", serving)
+	}
+	defer closeTerm()
+	fmt.Fprintf(out, "This computer already serves your Host %s. Add %s as well? It gets a pairing of its own,\n"+
+		"and `privatae-bastion ui` shows what each Host may do here. [y/N] ", terminalSafeName(serving), terminalSafeName(newHost))
+	line, err := bufio.NewReader(io.LimitReader(in, 256)).ReadString('\n')
+	if err != nil && !errors.Is(err, io.EOF) {
+		return false, fmt.Errorf("could not read the answer (%v); nothing was paired", err)
+	}
+	switch strings.ToLower(strings.TrimSpace(line)) {
+	case "y", "yes":
+		return true, nil
+	}
+	return false, nil
+}

client-go/pair_terminal_unix.go

@@ -0,0 +1,19 @@
+//go:build !windows
+
+package main
+
+import (
+	"io"
+	"os"
+)
+
+// openControllingTerminal opens /dev/tty, this process's controlling terminal
+// whatever its standard input is. It fails with no terminal (a service, a
+// pipe from `ssh host cmd` without -t, cron).
+func openControllingTerminal() (io.Reader, io.Writer, func(), error) {
+	f, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
+	if err != nil {
+		return nil, nil, nil, errNoTerminal
+	}
+	return f, f, func() { _ = f.Close() }, nil
+}

client-go/pair_terminal_windows.go

@@ -0,0 +1,26 @@
+//go:build windows
+
+package main
+
+import (
+	"io"
+	"os"
+)
+
+// openControllingTerminal opens the console this process is attached to,
+// CONIN$ for the answer and CONOUT$ for the question, whatever its standard
+// input is: install.ps1 pipes the pairing code into `pair -`, and the person
+// still answers in the PowerShell window. It fails with no console (a
+// service, a scheduled task with no window).
+func openControllingTerminal() (io.Reader, io.Writer, func(), error) {
+	in, err := os.OpenFile("CONIN$", os.O_RDWR, 0)
+	if err != nil {
+		return nil, nil, nil, errNoTerminal
+	}
+	out, err := os.OpenFile("CONOUT$", os.O_RDWR, 0)
+	if err != nil {
+		_ = in.Close()
+		return nil, nil, nil, errNoTerminal
+	}
+	return in, out, func() { _ = in.Close(); _ = out.Close() }, nil
+}

client-go/quarantine.go

@@ -113,7 +113,7 @@ func refusalCounts(op, why string) bool {
 		return false
 	}
 	if strings.Contains(why, noWayToApprove) || strings.HasSuffix(why, "not permitted on this host") ||
-		strings.Contains(why, noSandboxHere) {
+		strings.Contains(why, noSandboxHere) || strings.Contains(why, noVerbToolHere) {
 		return false
 	}
 	return true

client-go/service.go

@@ -288,17 +288,40 @@ func serviceArgs(spec harnessSpec) []string {
 
 // serviceOwnerRefusal: on an anchored box a member pairing may not replace or
 // stop a slot another host built. The anchor pairing may (its user is the
-// machine's admin), and an unanchored local box serves one host.
+// machine's admin). A local box has no anchor to be that admin, and serves a
+// second host only on its person's yes (pair_terminal.go); once it serves two,
+// each host changes only the slots it built. With one host there is nobody to
+// keep apart (a host renamed since it built a slot still owns it), and
+// pairings that cannot be read are treated as two.
 func serviceOwnerRefusal(self string, r *serviceRecord) string {
 	if r == nil || r.Owner == "" || r.Owner == self {
 		return ""
 	}
+	if boxMode() == modeLocal {
+		if !localServesSeveralHosts() {
+			return ""
+		}
+		return "refused: slot '" + r.Name + "' was built by " + r.Owner + "; on a local machine that serves several Hosts each changes only the servers it built"
+	}
 	if why := anchorOnly(self, "changing a server another host built"); why != "" {
 		return "refused: slot '" + r.Name + "' was built by " + r.Owner + "; " + why
 	}
 	return ""
 }
 
+// localServesSeveralHosts: this is a local machine that serves more than one
+// Host (the second added on its person's yes, pair_terminal.go), so what one
+// Host built or started here is kept from the others. Pairings that cannot be
+// read count as several. False on a networked machine, whose anchor rule
+// (anchorOnly) keeps its Hosts apart.
+func localServesSeveralHosts() bool {
+	if boxMode() != modeLocal {
+		return false
+	}
+	cfgs, err := loadPairings()
+	return err != nil || len(cfgs) > 1
+}
+
 func serviceFail(res map[string]interface{}, msg string) ([]byte, int) {
 	res["ok"], res["error"] = false, msg
 	b, _ := json.Marshal(res)

client-go/service_test.go

@@ -495,10 +495,24 @@ func TestServiceOwnerRuleOnAnAnchoredBox(t *testing.T) {
 	if why := serviceOwnerRefusal(tMember, &serviceRecord{Name: "forge", Owner: tMember}); why != "" {
 		t.Fatalf("the builder may change its own server: %s", why)
 	}
-	// Local box: one host, no owner rule to apply.
+	// Local box with one host: nobody to keep apart, as before.
 	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	if err := (&Config{HostName: tMember, ListenAddr: "127.0.0.1:7878"}).save(); err != nil {
+		t.Fatal(err)
+	}
 	if why := serviceOwnerRefusal(tMember, r); why != "" {
-		t.Fatalf("a local bastion serves one host: %s", why)
+		t.Fatalf("a local machine with one host applies no owner rule: %s", why)
+	}
+	// Local box serving a second host (added on its person's yes): each host
+	// changes only the servers it built.
+	if err := (&Config{HostName: tAnchor, ListenAddr: "127.0.0.1:7879"}).save(); err != nil {
+		t.Fatal(err)
+	}
+	if why := serviceOwnerRefusal(tMember, r); why == "" || !strings.Contains(why, "built by "+tAnchor) {
+		t.Fatalf("on a local machine serving two hosts one must not change the other's server: %q", why)
+	}
+	if why := serviceOwnerRefusal(tMember, &serviceRecord{Name: "forge", Owner: tMember}); why != "" {
+		t.Fatalf("on a local machine a host changes its own server: %s", why)
 	}
 }
 
@@ -852,3 +866,28 @@ func TestSpliceUnixCarriesBothWays(t *testing.T) {
 	}
 	_ = a.Close()
 }
+
+// A coder run on a local machine that serves two Hosts is stopped only by
+// the Host that started it, as a server is changed only by the Host that
+// built it. With one Host there is nobody to keep apart.
+func TestCoderRunOwnerRuleOnALocalBoxServingTwoHosts(t *testing.T) {
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	if err := (&Config{HostName: tMember, ListenAddr: "127.0.0.1:7878"}).save(); err != nil {
+		t.Fatal(err)
+	}
+	if why := coderOwnerRefusal(tMember, tAnchor); why != "" {
+		t.Fatalf("a local machine with one host applies no owner rule: %s", why)
+	}
+	if err := (&Config{HostName: tAnchor, ListenAddr: "127.0.0.1:7879"}).save(); err != nil {
+		t.Fatal(err)
+	}
+	if why := coderOwnerRefusal(tMember, tAnchor); why == "" || !strings.Contains(why, "started by "+tAnchor) {
+		t.Fatalf("on a local machine serving two hosts one must not stop the other's run: %q", why)
+	}
+	if why := coderOwnerRefusal(tMember, ""); why == "" {
+		t.Fatal("on a local machine serving two hosts a run of unknown owner proves nothing about self")
+	}
+	if why := coderOwnerRefusal(tMember, tMember); why != "" {
+		t.Fatalf("a host stops its own run: %s", why)
+	}
+}

client-go/testdata/install_ps1_pair.ps1

@@ -0,0 +1,58 @@
+# Runs install.ps1's -Pair block against a stand-in bastion, with the Windows
+# cmdlets it calls stood in by functions that log their call. pwsh on Linux:
+#   pwsh -NoProfile -File testdata/install_ps1_pair.ps1 ../deploy/install.ps1
+# Exits 0 when every case holds, and prints the first that does not.
+param([string]$Script)
+$ErrorActionPreference = 'Stop'
+$src = Get-Content -Raw $Script
+$m = [regex]::Match($src, '(?ms)^if \(\$Pair\) \{\r?\n.*?^\}\r?\n')
+if (-not $m.Success) { Write-Output 'FAIL: install.ps1 has no top-level if ($Pair) { … } block'; exit 1 }
+$block = [scriptblock]::Create($m.Value)
+
+$dir = Join-Path ([IO.Path]::GetTempPath()) ([guid]::NewGuid().ToString())
+New-Item -ItemType Directory -Path $dir | Out-Null
+$log = Join-Path $dir 'log'
+$exe = Join-Path $dir 'privatae-bastion'
+Set-Content -Path $exe -Value ("#!/bin/sh`necho ""ARGV `$*"" >> '$log'`n" +
+    "if [ ""`$1"" = pair ]; then sed 's/^/STDIN /' >> '$log'; exit `$FAKE_RC; fi`necho status-ok`n")
+chmod 755 $exe
+
+function Stop-ScheduledTask { $script:calls += 'stop-task' }
+function Start-ScheduledTask { $script:calls += 'start-task' }
+function Restart-Service { $script:calls += 'restart-service' }
+function Start-Process { $script:calls += 'start-process' }
+function Stop-Process { $script:calls += 'stop-process' }
+function Get-Process { @() }
+function Start-Sleep { }
+function Write-Host { param($Object) $script:out += "$Object`n" }
+
+function Run-Case([string]$rc, [bool]$networked) {
+    $script:calls = @(); $script:out = ''
+    if (Test-Path $log) { Remove-Item $log }
+    $env:FAKE_RC = $rc
+    $Pair = 'skp_INVENTEDCODE'; $Networked = $networked
+    $threw = $null
+    try { . $block } catch { $threw = $_.Exception.Message }
+    $l = if (Test-Path $log) { Get-Content -Raw $log } else { '' }
+    return @{ log = $l; calls = ($script:calls -join ','); out = $script:out; threw = $threw }
+}
+function Fail([string]$why) { Write-Output "FAIL: $why"; exit 1 }
+
+$r = Run-Case '0' $false
+if ($r.threw) { Fail "rc 0 threw: $($r.threw)" }
+if ($r.log -notmatch '(?m)^ARGV pair -$' -or $r.log -match 'ARGV .*skp_') { Fail "the code must reach 'pair -' on stdin, never argv: $($r.log)" }
+if ($r.log -notmatch '(?m)^STDIN skp_INVENTEDCODE\r?$') { Fail "pair's stdin: $($r.log)" }
+if ($r.calls -ne 'stop-task,start-task') { Fail "per-user: stop, then start the logon task: $($r.calls)" }
+if ($r.out -notmatch 'This computer is paired\. The bastion is running, and starts again each time you sign in to Windows\.') { Fail "the ending: $($r.out)" }
+
+$r = Run-Case '3' $false
+if ($r.threw -or $r.out -notmatch 'already paired with this Host') { Fail "exit 3 is success: $($r.threw) $($r.out)" }
+
+$r = Run-Case '1' $false
+if (-not $r.threw -or $r.calls -ne '') { Fail "a failed pair must throw before starting anything: $($r.threw) $($r.calls)" }
+
+$r = Run-Case '0' $true
+if ($r.threw -or $r.calls -ne 'restart-service' -or $r.out -notmatch 'Windows service PrivataeBastion') { Fail "networked restarts the service: $($r.threw) $($r.calls)" }
+
+Remove-Item -Recurse -Force $dir
+Write-Output 'ok: install.ps1 -Pair pairs over stdin, treats exit 3 as success, stops on a failure, restarts task or service'

client-go/uisetup.go

@@ -888,7 +888,7 @@ func (s *uiSetup) anchorChoose(w http.ResponseWriter, r *http.Request) {
 			Class:   "bad",
 			Command: setModeCommandHint(),
 			How:     adminHowTo() + ", then claim the anchor.",
-			Why: "This machine is in local mode, where it serves one host and needs no anchor. " +
+			Why: "This machine is in local mode, where it serves only the Hosts you said yes to here and needs no anchor. " +
 				"An anchor only means something on a networked bastion.",
 		})
 		return

client-go/writes.go

@@ -69,7 +69,7 @@ func opWrites(op string) bool {
 // approval. A lost device must not keep a revoked grant alive.
 func opTightens(op string) bool {
 	return op == "dcn_grant_drop" || op == "pairing_grant_drop" || op == "service_grant_drop" ||
-		op == "coder_grant_drop"
+		op == "coder_grant_drop" || op == "op_grant_drop"
 }
 
 // ownApproval reports whether a WRITE op already carries its own proof of the

deploy/VERSION

@@ -1 +1 @@
-0.56.0
+0.58.0

deploy/install.ps1

@@ -21,7 +21,17 @@
 # OWN account keeps the same profile — but "Run as different user" does not, and
 # the bastion would then read an empty directory and refuse to see its pairings.
 # This is the Windows shape of the same trap `sudo -H` exists for on Unix.
-param([switch]$Networked)
+#
+# -Pair '<code>': pair as well, with the code from your Host's "Set up a
+# bastion" card, and start the bastion so it serves now and at every sign-in.
+# The one line the card gives is
+#     & ([scriptblock]::Create((irm https://privatae.ai/bastion/install.ps1))) -Pair 'skp_…'
+# The code reaches the bastion on standard input, never as an argument, so it
+# is not in the process list. On a machine whose bastion is already the
+# Windows service (installed with -Networked, or by `npx cseries`), -Pair pairs
+# that service from an Administrator PowerShell instead of installing a second
+# bastion beside it.
+param([switch]$Networked, [string]$Pair)
 #
 # Brought into the repo (this file previously existed ONLY as bytes in the
 # edge webroot, so what customers piped to `iex` had no review history) and
@@ -35,6 +45,18 @@ $base = 'https://dl.privatae.ai'
 $arch = if ([System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture -eq 'Arm64') {'arm64'} else {'amd64'}
 $key  = "windows-$arch.exe"
 
+# Checked before anything is downloaded. Never echoed: it holds the token.
+if ($Pair -and -not $Pair.StartsWith('skp_')) {
+    throw "-Pair takes the pairing code from your Host's card, which starts skp_. Nothing was installed."
+}
+# A machine whose bastion already runs as the Windows service is paired
+# through that service. A per-user install beside it would be a second
+# bastion, which the service's own guard refuses to pair anyway.
+if ($Pair -and -not $Networked -and (Get-Service -Name 'PrivataeBastion' -ErrorAction SilentlyContinue)) {
+    $Networked = $true
+    Write-Host "This computer's bastion runs as the Windows service PrivataeBastion; pairing that service."
+}
+
 if ($Networked) {
     # Checked before anything is downloaded, so a refusal leaves nothing behind
     # and is one clear sentence at the moment it can be acted on.
@@ -43,7 +65,7 @@ if ($Networked) {
     if (-not $isAdmin) {
         throw ("-Networked needs an elevated terminal. A networked bastion runs as a Windows service, " +
                "and whoever administers the machine is what stands behind it.`n" +
-               "Close this window, right-click your terminal, choose 'Run as administrator', and run it again.")
+               "Close this window, right-click your terminal, choose 'Run as administrator', and run the same line again.")
     }
 }
 
@@ -223,11 +245,54 @@ if ($Networked) {
     Write-Host ""
     Write-Host "The bastion runs as the Windows service 'PrivataeBastion' (LocalSystem). It starts"
     Write-Host "serving as soon as this machine is paired."
+    if (-not $Pair) {
     Write-Host "Next, anchor this machine to the Host that should govern it:"
     Write-Host "  privatae-bastion claim-anchor"
     Write-Host "  (add --host <name> if this machine already serves several Hosts)"
     Write-Host "Every host paired after the anchor waits, pending, until that Host approves it."
-} else {
+    }
+} elseif (-not $Pair) {
     Write-Host "Open a NEW terminal, then:  privatae-bastion pair <token>"
 }
+
+if ($Pair) {
+    Write-Host ""
+    # The full path, never the name on PATH, which this window may not have
+    # picked up yet. The code goes on standard input: `pair -` reads its first
+    # line. `pair` exits 3 when this computer is already paired with that Host,
+    # which is success here too. On a computer that already serves another
+    # Host, `pair` asks in this window whether to add this one.
+    $Pair | & $exe pair -
+    $rc = $LASTEXITCODE
+    if ($rc -eq 0) { $done = 'This computer is paired.' }
+    elseif ($rc -eq 3) { $done = 'This computer was already paired with this Host; nothing changed there.' }
+    else { throw "Pairing did not finish (the reason is above). The bastion is installed; nothing else changed." }
+
+    # A running bastion reads a new pairing at its next start, so it is
+    # restarted, not just started.
+    if ($Networked) {
+        Restart-Service -Name 'PrivataeBastion'
+        $how = 'The bastion runs as the Windows service PrivataeBastion, and starts with Windows.'
+    } else {
+        # Every copy is stopped first, from wherever it was started (a terminal,
+        # an older install, a detached copy after a self-update): each would
+        # hold this machine's first control port, 127.0.0.1:7878, and the new
+        # one would fail to start beside it.
+        Stop-ScheduledTask -TaskName 'PrivataeBastion' -ErrorAction SilentlyContinue
+        Get-Process -Name 'privatae-bastion' -ErrorAction SilentlyContinue | ForEach-Object {
+            Stop-Process -Id $_.Id -Force -ErrorAction SilentlyContinue
+        }
+        try {
+            Start-ScheduledTask -TaskName 'PrivataeBastion'
+            $how = 'The bastion is running, and starts again each time you sign in to Windows.'
+        } catch {
+            Start-Process -FilePath $exe -ArgumentList 'run' -WindowStyle Hidden
+            $how = "The bastion is running until you sign out (its sign-in task could not be started: $($_.Exception.Message))."
+        }
+    }
+    Start-Sleep -Seconds 3
+    & $exe status
+    Write-Host ""
+    Write-Host "$done $how"
+}
 Write-Host "privatae-bastion is free software under the GNU GPL v3 or later: https://privatae.ai/bastion/LICENSE.txt"

deploy/install.sh

@@ -6,7 +6,33 @@
 #   sudo -H privatae-bastion pair <token>
 # Run as your own user (a desktop), it installs the LOCAL bastion for that user.
 #
+# PRIVATAE_PAIR_CODE='<code>' pairs as well, with the code from your Host's "Set
+# up a bastion" card, and starts the bastion so it serves now and after a
+# restart. The one line the card gives is
+#   curl -fsSL https://privatae.ai/bastion/install.sh | PRIVATAE_PAIR_CODE='skp_…' sh
+#
 set -e
+# The pairing code comes from the environment, never from an argument: an
+# argument sits in this shell's command line for the whole install, where any
+# user of this machine can read it with ps, and one at the same address could
+# redeem it first. A process's environment is readable only by its owner and
+# root. It is read here, before this script starts any program, and unset at
+# once, so no program it starts inherits it. Never echoed: it holds the token.
+pair_code=${PRIVATAE_PAIR_CODE-}
+pair_given=${PRIVATAE_PAIR_CODE+1}
+unset PRIVATAE_PAIR_CODE
+if [ -n "$pair_given" ]; then
+  # skp_ and base64url: anything else is a line that lost part of the code.
+  case "$pair_code" in
+    skp_*[!A-Za-z0-9_-]* | skp_) pair_code="" ;;
+    skp_?*) ;;
+    *) pair_code="" ;;
+  esac
+  if [ -z "$pair_code" ]; then
+    echo "ERROR: PRIVATAE_PAIR_CODE is not a pairing code. Copy the whole line from your Host's card again (the code starts skp_). Nothing was installed." >&2
+    exit 2
+  fi
+fi
 # dl.privatae.ai, not privatae.ai/bastion: the download host is served from each
 # edge's OWN local disk, so installs survive losing the platform datacentre, and
 # DNS points it at the edge with the bandwidth for an install wave (~15MB a
@@ -33,7 +59,9 @@ for a in "$@"; do
   case "$a" in
     --networked) networked=1 ;;
     --local) local=1 ;;
-    *) echo "unknown option: $a" >&2; exit 2 ;;
+    # An unknown argument is never echoed: it may be a pairing code given in
+    # the wrong place, and a log of the failed install must not hold it.
+    *) echo "ERROR: unknown option. This installer takes --networked or --local; a pairing code goes in PRIVATAE_PAIR_CODE, as your Host's card shows. Nothing was installed." >&2; exit 2 ;;
   esac
 done
 if [ "$networked" = 1 ] && [ "$local" = 1 ]; then
@@ -54,6 +82,179 @@ paired_local() {
   return 1
 }
 
+# pair_as ROOT OS BIN ARGS...: run the bastion as the state it serves. As
+# root that is the service's HOME (the unit's /root, launchd's /var/root),
+# whatever HOME `sudo` left behind; as yourself it is your own.
+pair_as() {
+  pa_root=$1; pa_os=$2; shift 2
+  if [ "$pa_root" = 1 ]; then
+    if [ "$pa_os" = darwin ]; then HOME=/var/root "$@"; else HOME=/root "$@"; fi
+  else
+    "$@"
+  fi
+}
+
+# bastion_copy PID: 0 when PID is a process of this user running a program
+# named privatae-bastion, from any path, including one replaced on disk since
+# it started. A process that has exited, or another user's, is not.
+bastion_copy() {
+  [ -O "/proc/$1" ] || return 1
+  bc_exe=$(readlink "/proc/$1/exe" 2>/dev/null) || return 1
+  case "${bc_exe##*/}" in
+    "privatae-bastion" | "privatae-bastion (deleted)") return 0 ;;
+  esac
+  return 1
+}
+
+# stop_user_copies: stop every copy of this user's bastion (Linux), as
+# install.ps1 does on Windows: one left running in a terminal, from an older
+# install or another path. `run` holds the machine's run lock, so the copy the
+# service starts would only wait behind it, and that copy never reads the new
+# pairing; an older build would fail on 127.0.0.1:7878 and restart for ever.
+# Asked to stop, then killed after 10 seconds. Says on stderr how many.
+stop_user_copies() {
+  suc_pids=""
+  for suc_d in /proc/[0-9]*; do
+    suc_pid=${suc_d#/proc/}
+    bastion_copy "$suc_pid" || continue
+    kill "$suc_pid" 2>/dev/null && suc_pids="$suc_pids $suc_pid"
+  done
+  [ -n "$suc_pids" ] || return 0
+  set -- $suc_pids
+  echo "Stopped $# copy(ies) of the bastion running outside its service (a terminal, or another install)." >&2
+  for suc_i in 1 2 3 4 5 6 7 8 9 10; do
+    suc_left=""
+    for suc_pid in $suc_pids; do bastion_copy "$suc_pid" && suc_left="$suc_left $suc_pid"; done
+    [ -n "$suc_left" ] || return 0
+    sleep 1
+  done
+  for suc_pid in $suc_left; do kill -9 "$suc_pid" 2>/dev/null || true; done
+}
+
+# user_unit_stays_up: 0 when the user unit privatae-bastion is running and
+# has kept the same process across a few seconds, longer than its
+# RestartSec, so a copy that fails at start and is restarted is caught.
+# Otherwise says what systemd shows, on stderr.
+user_unit_stays_up() {
+  sleep 1
+  uu_first=$(systemctl --user show -p MainPID --value privatae-bastion 2>/dev/null) || uu_first=""
+  sleep 4
+  uu_pid=$(systemctl --user show -p MainPID --value privatae-bastion 2>/dev/null) || uu_pid=""
+  uu_state=$(systemctl --user show -p ActiveState --value privatae-bastion 2>/dev/null) || uu_state=""
+  uu_sub=$(systemctl --user show -p SubState --value privatae-bastion 2>/dev/null) || uu_sub=""
+  if [ "$uu_state" = active ] && [ "$uu_sub" = running ] && [ -n "$uu_pid" ] && [ "$uu_pid" != 0 ] && [ "$uu_pid" = "$uu_first" ]; then
+    return 0
+  fi
+  echo "The bastion's user service privatae-bastion is not staying up (systemd shows it ${uu_state:-unknown}/${uu_sub:-unknown}, and it has restarted)." >&2
+  echo "Its log says why:  journalctl --user -u privatae-bastion" >&2
+  return 1
+}
+
+# start_bastion BIN ROOT OS: start, or restart, the bastion so it serves every
+# pairing now and starts again by itself. A running bastion reads a new
+# pairing at its next start, so a restart is what a fresh pairing needs.
+# Prints one plain sentence saying how it will run.
+start_bastion() {
+  sb_bin=$1; sb_root=$2; sb_os=$3
+  if [ "$sb_root" = 1 ] && [ "$sb_os" = linux ] && command -v systemctl >/dev/null 2>&1; then
+    systemctl restart privatae-bastion || return 1
+    echo "The bastion runs as the system service privatae-bastion, and starts at boot."
+    return 0
+  fi
+  if [ "$sb_root" = 1 ] && [ "$sb_os" = darwin ] && [ -f /Library/LaunchDaemons/ai.privatae.bastion.plist ]; then
+    /bin/launchctl kickstart -k system/ai.privatae.bastion || return 1
+    echo "The bastion runs as the system service ai.privatae.bastion, and starts at boot."
+    return 0
+  fi
+  if [ "$sb_root" != 1 ] && [ "$sb_os" = linux ] && command -v systemctl >/dev/null 2>&1 && systemctl --user show-environment >/dev/null 2>&1; then
+    # A systemd user unit: yours, no root. It starts when you sign in; with
+    # lingering on, at boot and after you sign out as well.
+    sb_dir="${XDG_CONFIG_HOME:-$HOME/.config}/systemd/user"
+    mkdir -p "$sb_dir"
+    cat > "$sb_dir/privatae-bastion.service" <<UNIT
+[Unit]
+Description=Privatae bastion - serves this machine to your Hosts (tunnel + lanes)
+[Service]
+Type=simple
+ExecStart=$sb_bin run
+Restart=always
+RestartSec=2
+[Install]
+WantedBy=default.target
+UNIT
+    systemctl --user daemon-reload && systemctl --user enable privatae-bastion >/dev/null 2>&1 || return 1
+    # Its own copy first, then every other: what is left running after this
+    # is only what the unit starts.
+    systemctl --user stop privatae-bastion >/dev/null 2>&1 || true
+    stop_user_copies
+    systemctl --user restart privatae-bastion || return 1
+    user_unit_stays_up || return 1
+    if loginctl enable-linger "$(id -un)" >/dev/null 2>&1; then
+      echo "The bastion runs as your systemd user service privatae-bastion, and starts at boot."
+    else
+      echo "The bastion runs as your systemd user service privatae-bastion while you are signed in."
+      echo "To keep it running at boot and after you sign out:  sudo loginctl enable-linger $(id -un)"
+    fi
+    return 0
+  fi
+  if [ "$sb_root" != 1 ] && [ "$sb_os" = darwin ]; then
+    # A LaunchAgent: yours, no root, started each time you log in.
+    sb_plist="$HOME/Library/LaunchAgents/ai.privatae.bastion.user.plist"
+    mkdir -p "$HOME/Library/LaunchAgents"
+    cat > "$sb_plist" <<PLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>ai.privatae.bastion.user</string>
+  <key>ProgramArguments</key><array><string>$sb_bin</string><string>run</string></array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+</dict>
+</plist>
+PLIST
+    /bin/launchctl bootout "gui/$(id -u)/ai.privatae.bastion.user" >/dev/null 2>&1 || true
+    /bin/launchctl bootstrap "gui/$(id -u)" "$sb_plist" || return 1
+    echo "The bastion runs as your LaunchAgent ai.privatae.bastion.user, and starts each time you log in."
+    return 0
+  fi
+  # No service manager this script can use: run it now, detached, once every
+  # other copy of it has stopped (stop_user_copies says why).
+  if [ "$sb_os" = linux ] && [ "$sb_root" != 1 ]; then stop_user_copies; fi
+  nohup "$sb_bin" run >/dev/null 2>&1 &
+  sb_pid=$!
+  sleep 3
+  if [ "$sb_os" = linux ] && ! bastion_copy "$sb_pid"; then
+    echo "The bastion stopped as soon as it started. Run it in a terminal to see why:  $sb_bin run" >&2
+    return 1
+  fi
+  echo "The bastion is running, until this machine restarts. Start it again with:  $sb_bin run"
+}
+
+# pair_and_start BIN CODE ROOT OS: pair with CODE, handed to `pair -` on
+# standard input and never as an argument, where the process list would show
+# it. Then start the bastion and show its status. `pair` exits 3 when this
+# machine is already paired with that Host, which is success here too.
+pair_and_start() {
+  ps_bin=$1; ps_code=$2; ps_root=$3; ps_os=$4
+  ps_rc=0
+  printf '%s\n' "$ps_code" | pair_as "$ps_root" "$ps_os" "$ps_bin" pair - || ps_rc=$?
+  case "$ps_rc" in
+    0) ps_done="This machine is paired." ;;
+    3) ps_done="This machine was already paired with this Host; nothing changed there." ;;
+    *) echo "ERROR: pairing did not finish (the reason is above). The bastion is installed; nothing else changed." >&2
+       return 1 ;;
+  esac
+  ps_how=$(start_bastion "$ps_bin" "$ps_root" "$ps_os") || {
+    echo "ERROR: $ps_done But the bastion did not start. Start it with:  $ps_bin run" >&2
+    return 1
+  }
+  sleep 2
+  pair_as "$ps_root" "$ps_os" "$ps_bin" status || true
+  echo ""
+  echo "$ps_done $ps_how"
+}
+
 if [ "$root" = 1 ] && [ "$local" != 1 ]; then
   case "$(uname -s)" in
     Linux) if command -v systemctl >/dev/null 2>&1; then networked=1; fi ;;
@@ -199,7 +400,9 @@ UNIT
   systemctl enable --now privatae-bastion >/dev/null 2>&1 || true
   echo "Service installed + enabled (it restarts until you pair, then connects automatically)."
   echo ""
-  if [ "$networked" = 1 ]; then
+  if [ -n "$pair_code" ]; then
+    :
+  elif [ "$networked" = 1 ]; then
     echo "Networked bastion. Pair it with YOUR host; the first host paired becomes its anchor:"
     echo "  sudo -H privatae-bastion pair <token>"
     echo "Then enrol your second factor, so you can approve here:"
@@ -224,6 +427,7 @@ elif [ "$darwin_service" = 1 ]; then
   HOME=/var/root "$bin" set-mode networked || die "could not set networked mode"
   "$bin" service install || die "could not register the system service"
   echo ""
+  if [ -z "$pair_code" ]; then
   echo "Networked bastion, running as a system service (launchd, as root)."
   echo "Pair it with YOUR host; the first host paired becomes its anchor:"
   # The full path, not the name on PATH: /usr/local/bin may belong to the
@@ -234,6 +438,7 @@ elif [ "$darwin_service" = 1 ]; then
   echo "  sudo -H '$bin' stepup-enroll"
   echo "Every terminal and write waits for your approval, and every later host for your host's."
   echo "(Already paired before this install? Anchor with: sudo -H '$bin' claim-anchor)"
+  fi
 elif [ "$networked" = 1 ]; then
   die "--networked needs a system service manager: systemd on Linux, launchd on macOS"
 else
@@ -243,7 +448,13 @@ else
     echo "This machine is already paired as a LOCAL bastion, and reinstalling keeps it local."
     echo "To make it a networked server instead, run the installer again with --networked."
   fi
+  if [ -z "$pair_code" ]; then
   echo "Now pair:   privatae-bastion pair <token>"
   echo "Run it:     privatae-bastion run    (Linux non-root: 'loginctl enable-linger \$USER' + a --user unit for boot persistence)"
+  fi
+fi
+if [ -n "$pair_code" ]; then
+  echo ""
+  pair_and_start "$bin" "$pair_code" "$root" "$os" || exit 1
 fi
 echo "privatae-bastion is free software under the GNU GPL v3 or later: https://privatae.ai/bastion/LICENSE.txt"

docs/claims.md

@@ -62,6 +62,14 @@ says so. Those parts are enforced only by the code as written.
 | | `localdeny_test.go`: `TestTheLocalSwitchCanOnlyEverRemoveReach` | Switching a capability off on this machine never turns a refusal into an allow. |
 | Fixed argv | `observe_ops_test.go`: `TestObserveArgsNeverReachArgv` | Shell metacharacters and flags sent as arguments to every observe op are refused or never reach a command line, and each op runs only its pinned argv. Linux only. |
 | | `contextextract_test.go`: `TestCtxExtractRefusesAnUnknownTool` | Text extraction runs only tool names from its fixed table. |
+| | `observe_reads_linux_test.go`: `TestObserveJournalRunsOnlyItsPinnedArgv` | `observe:journal` runs `systemctl list-units`, `systemctl list-unit-files` and one pinned `journalctl`; the unit reaches `journalctl` only as `--unit=` with a name one of those lists holds, and a unit this machine does not have, or knows only as not found, is refused before `journalctl` runs. Linux only. |
+| | `observe_reads_linux_test.go`: `TestObserveLoginsRunsItsPinnedArgv` | `observe:logins` runs one pinned `journalctl` whose only caller value is a whole number of hours; without access to the system journal it runs nothing and its counts read -1, never 0. Linux only. |
+| | `observe_reads_linux_test.go`: `TestObserveLoginsCountsOnlyRootsSSHDLines` | Every match `observe:logins` gives `journalctl` also needs `_UID=0`, so a line another account wrote under a process named sshd, or from a shell left in ssh.service, is never counted. Linux only. |
+| | `observe_reads_linux_test.go`: `TestObserveFoldersReadsOnlyTheFolderItStatd` | A folder swapped for a link between the walk's stat and its open, or reached through a folder above it that was, is not read and is listed as changed. Linux only. |
+| | `observe_reads_linux_test.go`: `TestObserveFoldersStartsNoWalkPastTheStuckOnes` | Past four walks still inside a read that has not returned, `observe:folders` answers at once and starts no walk; a walk that comes back frees its place. Linux only. |
+| | `observe_reads_test.go`: `TestObserveReadsRefuseBadValuesWithTheRule` | A relative folder path, one with `..` or under `/proc`, a unit name outside systemd's alphabet, shaped like a flag or naming a template, and a depth, window or port out of range are refused at exit 2 with the rule broken, without repeating the value. |
+| | `fuzz_observe_test.go`: `FuzzFolderPathIsAbsoluteCleanAndOffTheKernelTrees` | Whatever the input, a folder path that passes is absolute and clean, holds no `..` and no control character, and is outside `/proc`, `/sys` and `/dev`. |
+| | `fuzz_observe_test.go`: `FuzzUnitNameIsSystemdsAlphabet` | Whatever the input, a unit name that passes is in systemd's unit-name alphabet, at most 255 characters, ends in a unit type, does not start with `-`, `.` or `@`, and is the input itself or the input with `.service`. |
 | | `claims_unix_test.go`: `TestTheAllowlistedOpIgnoresTheCallersArguments` | `uptime`, sent through the management lane with hostile arguments, runs its program with none. |
 | | `claims_static_test.go`: `TestTheAllowlistedOpRunsItsTableArgvOnly` | The allowlisted table is exactly `uptime` with no arguments, and the one command the lane starts is built from the table's argv alone. |
 | | `claims_static_test.go`: `TestFileHandlersStartNoShell` | Nothing a context, store or backup handler can reach runs a shell; the one process any of them can start is the local search agent's Python, which `dcn_grant_sync` brings up. |
@@ -101,6 +109,24 @@ says so. Those parts are enforced only by the code as written.
 | | `ops_action_linux_test.go`: `TestActionApplyOfAnotherChangeListRunsNothing` | An apply whose change list differs from the approved one is refused before the program starts. Skipped where action ops cannot run. |
 | | `ops_action_test.go`: `TestActionManifestRefusesWhatIsNotDeclaredOrNotBounded` | An unknown verb or argument, a workload, container, unit or tree named by a parameter, an undeclared credential, verbs without root, a destination on loopback, link-local or a metadata service (also inside NAT64 or IPv4-mapped IPv6), the bastion's own unit, a tree on a credential store, a tree or container moved twice by one op, and more, are each refused when the op arrives. |
 | | `ops_action_test.go`: `TestSealedCredentialsOpenOnlyForThisRunAndThisOp` | A credential sealed for another run, to another machine, tampered, expired, undeclared, missing or sent twice is refused. |
+| A standing grant holds to its bounds on the machine | `ops_skill_bounds_test.go`: `TestGrantOutsideItsWindowIsNotNowAndSpendsNothing` | An apply outside the grant's window (days, hours, zone, read on the machine's clock) does not run, spends no use and is no strike, and says when the window opens; a dry run is not held; arguments outside the op are still refused. Inside the window it runs and spends one use. |
+| | `ops_skill_bounds_test.go`: `TestGrantInsideItsMinIntervalDoesNotRun` | An apply inside the approved interval since the last one does not run, spends nothing and is no strike; past it, it runs. |
+| | `ops_skill_bounds_test.go`: `TestGrantPerDayHoldsAcrossARestart` | The runs are logged in the grant's record on disk, and another process reading that record holds the third run in 24 hours as the first did. |
+| | `ops_skill_bounds_test.go`: `TestGrantWithATamperedRunLogIsNoGrant` | A record whose run log, uses, approver or seal was edited outside the bastion, or that carries no seal, holds no grant. |
+| | `ops_skill_bounds_test.go`: `TestGrantDiesWithTheKeyThatApprovedIt` | A grant keeps the key that approved it; with that device key unpinned, or the console factor enrolled again, it is refused, and unpinning drops it so pinning the key again does not bring it back. |
+| | `ops_skill_bounds_test.go`: `TestGrantDropGoesThroughAQuarantine` | `op_grant_drop`, of one grant or all, goes through while the host's writes are quarantined, with no approval. |
+| | `fuzz_grants_test.go`: `FuzzAGrantsRunBoundsHoldWhateverTheHostSends` | A window or rate the machine accepts is one it can hold, and no run inside an interval or past a day's count is let through. |
+| An op with no program needs no sandbox, and a program still does | `ops_skill_bounds_test.go`: `TestProgramOpStillRefusedWithoutTheSandbox` | On a machine with no overlay, a files op and an action op with a program are refused before anything runs. |
+| | `ops_skill_bounds_test.go`: `TestVerbsOnlyOpShippingRunIsRefused` | An op with `interpreter: none` that ships a `run` file is refused at sync; without one it is held. |
+| | `ops_verbs_only_linux_test.go`: `TestVerbsOnlyOpRunsWithNoOverlay` | On a machine with no overlay, an op with no program dry-runs as its verbs' own read, applies its verbs once under an approval bound to that list, and is refused, as the machine's own state and no strike, where a verb's tool is missing. |
+| On your own machine, an action op reaches the internet, never your network | `ops_action_local_test.go`: `TestALocalBoxRefusesAnActionOpThatDeclaresAPrivateNetwork` | Through `op_sync` on a local, unanchored machine: an op declaring `10.0.0.2:80`, a `192.168.0.0/16`, `172.16.0.0/12`, CGNAT, ULA or benchmarking address, or `10.0.0.2` inside NAT64 or 6to4, is refused with the reason and what to do instead, and nothing is held; a public address and a name are held. |
+| | `ops_action_local_linux_test.go`: `TestALocalBoxRefusesANameThatResolvesToAPrivateNetworkAtApply` | On a local machine a name that resolves to a private address, alone or beside a public one, is refused when an apply resolves its destinations; a public name resolves to its address; on an anchored machine the private name resolves. |
+| | `ops_action_local_linux_test.go`: `TestAPrivateDestinationHeldWhileAnchoredIsRefusedAtApplyOnceTheAnchorIsGone` | An op whose destination is `10.0.0.2:80` or its IPv4-mapped form resolves at apply on an anchored machine; once the machine is local, the same destinations are refused at apply. |
+| | `ops_action_local_linux_test.go`: `TestALocalBoxNeverFetchesAVerbsRepositoryFromAPrivateNetwork` | On a local machine a verb's fetch (the ancestry check `k8s.set_image` makes) of a repository whose host resolves to a private address, to a public and an IPv4-mapped private one, or to a link-local one is refused with the reason before git runs; a public host is fetched with git pinned to the checked address (IPv6 bracketed, the URL's port kept), a git that would drop the pin is refused, and an anchored machine fetches from its private forge unpinned. |
+| | `ops_action_local_linux_test.go`: `TestAnAnchoredBoxNeverFetchesAVerbsRepositoryFromItselfOrTheMetadataService` | On an anchored machine a verb's fetch (the ancestry check `k8s.set_image` makes) of a repository whose host resolves to loopback, to a public address beside an IPv4-mapped loopback one, to a link-local address, to a metadata service or to this machine's own address is refused with the reason before git runs; a private forge is fetched pinned to its address. |
+| | `ops_action_local_linux_test.go`: `TestALocalBoxNeverPutsLiveAnImageFromARegistryOnItsNetwork` | On a local machine `k8s.set_image`'s plan and apply refuse an image whose registry is a name resolving to a private address, a private address, `localhost` or a link-local address, with the reason, and set nothing; a public registry and a Docker Hub repository pass the registry check; an anchored machine keeps its private registry. |
+| | `ops_verbs_only_linux_test.go`: `TestSetImageNeedsGitForItsAncestryCheck` | `k8s.set_image` names kubectl and git as the tools it runs, and `tree.checkout` git; as root, a machine with kubectl and no git is told by the verb check and the beat that it cannot run `k8s.set_image`. |
+| | `ops_action_local_test.go`: `TestAnAnchoredFleetKeepsItsPrivateDestinations` | Through `op_sync` on an anchored machine: ops declaring a private, CGNAT or ULA address are held; loopback is still refused. |
 | Root verbs move only forward | `ops_verbs_linux_test.go`: `TestSetImageTouchesOnlyTheNamedContainerAndOnlyForward` | Against a stand-in kubectl: a digest with no receipt, a receipt from another repository, a container the workload lacks, a live image this machine never rolled (a receipt for it included), another image and a backward commit are each refused with nothing set; a forward roll sets exactly the named container and records it; an image already set still waits for its rollout, and fails when it does not finish. The ancestry answer is a stand-in here. |
 | | `ops_verbs_linux_test.go`: `TestAncestryByFetchRefusesABackwardOrSidewaysCommit` | With real git, the ancestry check `k8s.set_image` makes accepts a forward commit or the same one, and refuses a backward, sideways or unknown commit. |
 | | `ops_verbs_linux_test.go`: `TestTreeCheckoutMovesOnlyForward` | With real git: a tree moves forward to the exact commit, runs none of its own hooks, leaves untracked files and nested repositories alone, and refuses a backward or sideways commit, another origin, local changes and a config that could run a program. |
@@ -174,6 +200,24 @@ says so. Those parts are enforced only by the code as written.
 | A networked machine is anchored to its first host | `pair_anchor_test.go`: `TestPairAnchorsANetworkedMachineToItsFirstHost` | On a networked machine with no anchor, the first pairing made with machine authority anchors it and is active; a local machine, an anchored one (a new host stays pending), a second pairing, and a caller without machine authority are left as they were. `claim-anchor` afterwards succeeds and changes nothing. Called directly, not through `pair`'s redeem. |
 | | `anchor_test.go`: `TestClaimAnchorWithNoToken` | `claim-anchor` with no token on a machine anchored to that host succeeds and changes nothing, the host named in full, by handle or not at all; when the anchor's pairing is pending or revoked it is refused and the state is left as it was; another host is refused without `--rotate`. |
 | A root reinstall keeps a paired local machine local | `install_sh_test.go`: `TestInstallShKeepsAPairedLocalMachineLocal` | `install.sh`'s check finds a pairing in a folder whose mode is local (or unset), in either folder it looks in; a networked folder, or one with no pairing, gets the networked default. The rest of the installer is not run by a test. |
+| A pairing code pins the Host's CA by its fingerprint | `pair_code_linux_test.go`: `TestAPairingCodePinsTheHostCAByFingerprint` | A pairing code whose enroll port presents no CA, another CA, a CA under another fingerprint, a leaf another CA signed, or a leaf without the name `host.cseries.internal` is refused before the token is spent, and nothing is saved. |
+| | `pair_code_linux_test.go`: `TestAPairingCodePairsAsTheHostCAFileDoes` | A good code makes the same TCP pairing `--redeem-url` and `--host-ca` make, with that CA pinned; the same code again is "already paired" (exit 3) and changes nothing; a Host of the same name under another CA is a plain refusal. |
+| | `pair_code_linux_test.go`: `TestAPairingCodeIsReadStrictly` | A code that is garbled, another version, or has an extra, missing or malformed field is refused, and no refusal repeats the token. |
+| | `pair_code_linux_test.go`: `TestACodeTheHostMadeDecodesAndPins` | A code made by the C-Series Host's own `pairing_code` decodes to its address and token, and its fingerprint is the one `caSHA256` computes from the same CA. |
+| | `pair_code_linux_test.go`: `TestAPairingCodeWithAKeyGivenTwiceIsRefused` | A code that names a field twice is refused. |
+| | `pair_code_linux_test.go`: `TestThePinnedChainTakesOnlyAValidCAWithTheFingerprint` | A certificate with the fingerprint that is not a CA, an expired CA, or a chain of the leaf alone is refused; the pinned CA after other certificates is the one kept. Called directly, not through TLS. |
+| | `pair_code_linux_test.go`: `TestHostCAFileWithASameNamedHostUnderAnotherCAIsNotAlreadyPaired` | With `--host-ca` too, a Host of the same name under another CA is a plain refusal, not exit 3, and its token is not spent; the same Host under its own CA is exit 3. |
+| | `pair_code_linux_test.go`: `TestARedeemAnsweringAPairedNameUnderAnotherCAIsNotAlreadyPaired` | When the redeem answers with a paired name the token's handle did not show, a Host of that name under another CA is a plain refusal, not exit 3, and nothing is saved. |
+| A local machine adds a second host only on a yes typed there | `pair_code_linux_test.go`: `TestALocalMachineAddsASecondHostOnlyOnAYesTypedHere` | With no terminal, or any answer but y or yes, the second host is refused before its token is spent and the first pairing is unchanged; callers with no person to ask keep the refusal and open no terminal; a typed yes adds it beside the first. |
+| | `pair_code_linux_test.go`: `TestTheSecondHostAnswerIsNeverReadFromStandardInput` | The answer is read from the controlling terminal, never from standard input: with no terminal and a y waiting on standard input, the question finds no terminal, refuses, and leaves standard input unread. |
+| | `service_test.go`: `TestServiceOwnerRuleOnAnAnchoredBox` | On a local machine that serves two hosts, a host may not replace or stop a server the other built, and may change its own; with one host no owner rule applies. |
+| | `service_test.go`: `TestCoderRunOwnerRuleOnALocalBoxServingTwoHosts` | On a local machine that serves two hosts, a host may not stop a coder run the other started, or one of unknown owner, and may stop its own; with one host nothing changes. |
+| | `pair_code_linux_test.go`: `TestTheSecondHostQuestionEscapesTheTokensName` | The second-host question shows a token's name that is not a plain host name quoted, with its control bytes escaped. |
+| The installers keep the pairing code out of every process's arguments | `install_sh_test.go`: `TestInstallShTakesTheCodeOnlyFromTheEnvironment` | `install.sh` takes the code only from `PRIVATAE_PAIR_CODE` and unsets it before it starts any program: no program it starts, the downloaded bastion included, has the code in its arguments, its shell's command line or its environment, and the code reaches `pair -` on standard input. Run on stand-in programs; nothing is downloaded. |
+| | `install_sh_test.go`: `TestInstallShRefusesABadPairCodeBeforeDownloading` | An empty or partial `PRIVATAE_PAIR_CODE`, and any unknown argument (the removed `--pair` and a bare code included), are refused before the download and never echoed. |
+| | `install_sh_test.go`: `TestInstallShPairsOverStdinAndStartsAUserUnit` | The pairing functions hand the code to `pair -` on standard input, then start the bastion; a failed pair starts nothing. Run on stand-in programs, not on a real systemd. |
+| | `install_sh_test.go`: `TestInstallShStopsAnOutsideCopyAndChecksTheUnitStaysUp` | On Linux as yourself, a copy of the bastion running outside the user unit is stopped before the unit starts, and a unit that keeps restarting is reported as not running, with a failure. Run on a stand-in systemd, in a PID namespace of its own. |
+| | `install_ps1_test.go`: `TestInstallPs1PairShape` | `install.ps1` pipes the code to `pair -`, never into an argument or the output, and checks it before downloading. Read from the file; `TestInstallPs1PairBlockRunsUnderPwsh` runs the block where pwsh is installed. Not run on Windows. |
 | A terminal is checked here and logged | `session_test.go`: `TestSessionOpensWithoutAGrantOnALocalBox` | On a local machine a terminal with no grant and no approval opens and is audited. The same test calls `sessionPinOfferedKey` directly: the first key offered is pinned and a different one is refused. |
 | | `session_test.go`: `TestSessionRefusedWithoutGrantIs126` | A grant that is sent is verified: a bad signature, an op not listed, or an op the grant denies is refused and audited. |
 | | `fuzz_grants_test.go`: `FuzzEachOpIsAllowedOnlyByItsOwnFamily` | On an anchored machine the family check (`capsAllow`) lets a host other than the anchor run an op, the session ops included, only if its pairing grant names that op's family. Called directly, not through the terminal handler. |
@@ -219,6 +263,7 @@ says so. Those parts are enforced only by the code as written.
 | Observation changes nothing on the machine | `observe_endpoints_test.go`: `TestObserveEndpointAllowedIsTheInverseOfObserveNet` | The monitoring ops may reach only private addresses, exactly the ones `observe:net` refuses. |
 | | `observe_endpoints_test.go`: `TestObserveDialControlRefusesPublicAtConnectTime` | A public address is refused at the socket, so a DNS answer cannot move a query outside. |
 | | `observe_endpoints_test.go`: `TestObserveNeverFollowsARedirect` | A redirect from a monitoring endpoint is reported as a failure, and its target is never fetched. |
+| | `observe_reads_linux_test.go`: `TestObserveCertReadsOnlyThisMachinesListener` | `observe:cert` is refused for a port no listener on this machine holds, and never dials an address a listener is bound to that this machine does not hold. Linux only. |
 | | `claims_static_test.go`: `TestObserveOpsWriteNothing` | Nothing an observe or computer op can reach writes, removes, renames, changes permissions on, mounts or signals anything, apart from the bastion's own audit line and its journal of observe results; the programs those ops run are a fixed list of reads. |
 | | `claims_static_test.go`: `TestNoInputInjection` | No input-injection program is run, no Windows input API is loaded, and no script the computer ops run asks for a keystroke, a click or an accessibility action. |
 | A backup's key goes to a host only when you approve it here | `backupreseal_test.go`: `TestBackupResealWaitsForThePersonThenDeliversToTheHostOnly` | Through the management lane: a request is filed pending and hands out nothing; another pairing cannot read it; after approval here the host receives the record sealed to its key only; a refusal hands over nothing; a decided request cannot be decided again. |

docs/commands.md

@@ -7,6 +7,9 @@
 | `pair --replace <token>` | Re-pair an existing host: rotates its credentials, keeps its port, context store and DCN state. |
 | `pair [--replace] --redeem-url unix:///<socket> <token>` | Pair with a Host on this machine over its enroll socket. Its CA is pinned for life. See [A Host on this machine](host-on-this-machine.md). |
 | `pair [--replace] --redeem-url https://<host>:<port>/<path> --host-ca <pem> <token>` | Pair with a Host in a VM on this machine over its enroll port, trusting that CA alone. Its CA is pinned for life. See [A Host in a VM on this machine](host-on-this-machine.md#a-host-in-a-vm-on-this-machine). |
+| `pair <pairing code>` | Pair with the one code (`skp_…`) a Cloud Host's "Set up a bastion" card gives: it carries the enroll address and the fingerprint of the Host's CA, and the CA is taken from the enroll port only under that fingerprint. On a local machine that already serves a Host it asks, on this machine's terminal, whether to add this one; only a yes adds it. |
+| | The card's one line installs the bastion, pairs it with that code and starts it: `curl -fsSL https://privatae.ai/bastion/install.sh \| PRIVATAE_PAIR_CODE='skp_…' sh` on macOS and Linux (the code goes in the environment, never in an argument, which the process list would show), and `& ([scriptblock]::Create((irm https://privatae.ai/bastion/install.ps1))) -Pair 'skp_…'` on Windows. Either hands the code to `pair -` on standard input. |
+| | `pair` exits 0 when it paired, 3 when this machine is already paired with that Host (nothing changed), and anything else on a failure. |
 | `run` | Bring up the tunnel and lanes for every paired host. |
 | `status` | Show every pairing and its tunnel status. |
 | `ui` | Open the local console in your browser. |

docs/observe.md

@@ -61,10 +61,51 @@ Read-only, and reported so the host can show **why** rather than a verdict.
   the host. Alert counts also ride the heartbeat, refreshed on their own
   interval, and are absent — not zero — whenever no Alertmanager is
   configured.
+- **Machine questions** (Linux: `observe:folders`, `observe:journal`,
+  `observe:logins`, `observe:cert`). What a host would otherwise ask the
+  person to run a command for, answered here. Each value is checked against
+  its written rule before anything is read or run, and a refusal says which
+  rule it broke.
+  - `observe:folders <absolute path> [depth 1-3, default 2]`: the 25 largest
+    folders under the path, down to the depth, and the total, on the path's
+    own filesystem only, counted as `du -x` counts (disk blocks, a file with
+    several links once). Only folders are named, never files. What could not
+    be read, and filesystems mounted under the path, are listed against the
+    folder that holds them, with a reason and a count. A relative path, one
+    containing `..`, and `/proc`, `/sys` and `/dev` (or a link leading into
+    them) are refused. The walk shares the 20-second op budget; one that runs
+    out answers with what it measured, marked incomplete. It follows no link,
+    and a folder swapped for one while it reads is listed as changed. While
+    four earlier walks are still inside a read that has not returned, no new
+    walk starts.
+  - `observe:journal <unit> [minutes 1-60, default 15]`: one systemd unit's
+    journal over the window, up to 5000 lines and 200 KB, newest kept. A name
+    with no type is a service. The unit must be in systemd's unit-name
+    alphabet and one this machine has, loaded or installed; otherwise it is
+    refused, with the units whose names come close.
+  - `observe:logins [hours 1-168, default 24]`: sshd's failed logins counted
+    and ranked by source address and by user name (20 each), and the last 20
+    accepted logins with user, source, method and time. A user name the other
+    side sent is cut to 32 characters, and anything outside the characters
+    account names use reads `?`. No raw line, key fingerprint or password is
+    returned. Only lines sshd wrote as root are read (`_UID=0`), so another
+    account cannot add login lines or bury the real ones.
+  - `observe:cert <port> [server name]`: the certificate this machine's own
+    TCP listener on the port serves: subject, names, issuer, dates, days left,
+    and whether the chain verifies against this machine's roots for that name.
+    The port must be one `ss` shows listening here.
+
+  `observe:journal` and `observe:logins` first check that the bastion can read
+  the system journal (root, as the networked install runs it, or a member of
+  `systemd-journal`). An account that cannot is shown only its own lines by
+  `journalctl`, which would read as a quiet machine, so they answer with the
+  reason instead, and `observe:logins` reports its counts as -1.
 
 The observe ops that send traffic are `observe:net`, `observe:k8s` (a
-read-only query of a cluster API) and the three monitoring ops above (private
+read-only query of a cluster API), the three monitoring ops above (private
 addresses only, refused at the socket if a redirect or a DNS answer would move
-the destination after validation). A build with no enumerator for its
+the destination after validation) and `observe:cert`, which connects only to
+this machine: loopback first, then an address of this machine the listener is
+bound to. A build with no enumerator for its
 platform **withholds** the capability, so the host can tell a machine that is
 quiet apart from one that is blind.

docs/ops.md

@@ -49,7 +49,22 @@ a dry run first, then an apply bound to the change list the dry run showed.
   - UDP is held to the declared addresses but not to their ports, and a port
     declared for one address is open on every declared address;
   - a destination on this machine, a link-local address, or a cloud's
-    metadata service is refused, as written and as resolved.
+    metadata service is refused, as written and as resolved;
+  - on a machine no fleet has anchored (your own machine), so is a private,
+    ULA, CGNAT or reserved address: one written as an address is refused when
+    the op arrives, and a name is refused at apply if any address it resolves
+    to is one. A verb's fetch (`tree.checkout`, and `k8s.set_image`'s
+    ancestry check) is held the same way, its host checked once and git held
+    to that address, which needs git 2.37 or newer; on an anchored machine
+    that fetch is held to its checked address too, and is never this
+    machine, its loopback, a link-local address or a metadata service. An
+    image whose registry is on your network or this machine is never put
+    live: it is refused when a program reports it and when `k8s.set_image`
+    would set it. To reach another computer
+    on your network, install a bastion on that computer and run the op there.
+    An anchored machine keeps private
+    destinations, because a fleet's ship steps reach its private control
+    planes.
 
   **A dry run has no network at all,** because nobody approved it.
 - **Memory: no ceiling, and the op goes first.** A run may use whatever

docs/security-model.md

@@ -94,6 +94,41 @@
   changes anything outside its declared file effects. A one-time apply lands
   only the change list you saw; a run under a standing grant is held to the
   grant's bounds.
+- **A standing grant is held here to its window and rate, and dies with the
+  key that approved it.** The machine reads the window on its own clock and
+  counts the rate from the runs it logged in the grant's record in `ops.json`,
+  which it seals with a key derived from its own encryption key. A record
+  edited by hand or by a program without that key, or copied from another
+  machine, holds no grant. The seal does not stop the bastion's own account:
+  it can read the key, so it can write a new record or put back an older
+  sealed copy with fewer runs logged and more uses left. That account is root
+  on a networked install, and root on the machine is outside what this model
+  defends. A grant taken back while the machine is offline stops at the Host
+  at once, which routes no run through it; the machine keeps its own record
+  until the drop is sent again or the grant expires (30 days at most). The
+  heartbeat does not yet carry the grants the Host still holds, which would let
+  the machine drop the rest itself as it does for coder grants. `ops drop
+  --all` at the machine takes every one back there.
+- **On your own machine, an action op reaches the internet, never your
+  network.** On a machine no fleet has anchored, an action op's destination
+  is never a private, ULA, CGNAT or reserved address, also inside a NAT64 or
+  6to4 address: one written as an address is refused when the op arrives
+  (`op_sync`), and a name is refused at apply if any address it resolves to
+  is one. A verb's fetch (`tree.checkout`'s repository, `k8s.set_image`'s
+  ancestry check), which runs with the bastion's root outside the sandbox,
+  is held to the same rule: its host is resolved once, every address checked,
+  and git held to that address (git 2.37 or newer); on an anchored machine
+  that fetch is still never this machine, its loopback, a link-local address
+  or a cloud's metadata service. An image `k8s.set_image` puts live is
+  pulled by the machine's container runtime, by name, outside the bastion's
+  walls, so on your own machine its registry is judged where the bastion
+  takes the image (a program's result, and the verb) and refused on your
+  network or this machine; the runtime's own later lookup is not the
+  bastion's to hold. Another computer of yours
+  is reached through a bastion on that computer. An anchored machine keeps
+  private destinations, since a fleet's ship steps reach its own private
+  control planes. (Before this, a local machine held an op whose destination
+  was on your LAN, and its apply reached it.)
 - **A server in the service slot has no network.** The host's tunnel is its
   only way in, and it cannot reach this machine, your network or the
   internet.
@@ -189,7 +224,9 @@
   (`observe:alerts`, `observe:metrics`, `observe:logs`), read-only HTTP
   against an Alertmanager/Prometheus/Loki on the box's own network —
   private addresses only, re-checked at the socket so neither a redirect nor
-  a DNS answer can walk a query out of that neighbourhood.
+  a DNS answer can walk a query out of that neighbourhood; and
+  `observe:cert`, a TLS handshake with a listener on this machine, at
+  loopback or an address this machine holds, never one another machine could.
 - **A backup's key goes to a host only when you approve it here.** A host's
   request to restore files a request and gets nothing until you approve it
   on this machine; the key sealed to the host then opens that one backup and