You are given part of a draft protocol's vocabulary: its vocabulary section and its summary for a reader. Answer from the text alone. Answer each question by number. Where the text does not say, say so.

=== TEXT ===

## 1. Vocabulary

### 1.1 Every naming word today, and the word it becomes

"Fossil" means Fossil's own term, with where Fossil uses it. "Kept" means
the word stays as it is, in one sense.

| Today | What it means | Fossil term, or NEW TERM | Version 2 |
| --- | --- | --- | --- |
| repository | one Fossil database file holding a project's history | Fossil (glossary.md) | kept |
| clone (a repository) | a repository made by `fossil clone` | Fossil (`fossil clone`; concepts.wiki) | kept, this sense only |
| server-code | 40 random hex digits that identify one repository file | Fossil: config row `server-code`, "the repository ID" (sync.wiki 3.4) | kept; the key is `server_code` |
| project code | 40 hex digits every repository of a project shares | Fossil (sync.wiki 3.4, `projectcode`) | kept |
| artifact, hash, check-in, checkout, branch, tag, wiki page, forum post, thread, ticket, ticket change, unversioned file, tech-note | Fossil's records | Fossil | kept |
| user | Fossil's account (`fossil user`, the U card) | Fossil | kept, this sense only |
| login | a user's name | Fossil (the Login page; the user table's login) | kept, this sense only |
| password, capability, admin (`a`), setup (`s`), default user, self-registration, login group | Fossil's accounts and their rights | Fossil (caps/ref.html; `fossil user default`; selfreg.wiki) | kept |
| receipt | the server's record of who sent an artifact, and when | Fossil (`/rcvfromlist`, "Artifact Receipts") | kept |
| sync, push, pull | moving artifacts between repositories | Fossil (concepts.wiki) | kept |
| backoffice, after-receive hook | Fossil's work after a page answers; the command it runs | Fossil (backoffice.md, hooks.md) | kept |
| server | "a publicly hosted Fossil server providing synchronization" (the maintainer) | Fossil (`fossil server`; concepts.wiki "central server") | kept, this sense only: the Fossil server at the project's URL |
| the server (meaning its repository), the served repository | the repository the server serves for the project | Fossil: every clone's "parent repository" | **the server's repository** |
| the server's host, staging server | the computer the server runs on | none needed: plain "host" | **the server's host**, **the staging host** |
| node | OCX acting on a repository: the server's, through its hook, or a clone, through `poll` | none; Fossil names the repository, and OCX is what acts | **dropped**: "OCX on the run's repository" |
| nodes on other hosts, build machine, lab board | a computer holding a clone that OCX acts on | none needed | **a host** with a clone |
| the node's login, node user | the Fossil user OCX acts as on that repository, chosen by whoever has its command line | Fossil: **default user**, "the user for command-line interaction"; `-U` makes it | **the repository's default user** |
| key `node` | a login, naming which OCX acts and whose reports count | Fossil: default user | **`repository.default_user`** |
| key `clone` (in a run, and in reports) | a server-code or its prefix, naming the repository to act | Fossil: server-code | **`repository.server_code`**, in full |
| run user, `process.user` | the Fossil user a run's process acts as | Fossil: user | **the process user**, `process.user` |
| person, "the user with cli access" | a human | none needed | **person** |
| the node's own account, the server's account, sandbox `uid` "user" | a Linux account on the host | none (Linux's) | **host account**; sandbox `uid` and `gid` are Linux account and group IDs |
| the node's owner (of `r-senders.json`) | whoever may write the node directory | none (Linux file owner) | **the owner of `ROOT/settings`** |
| layer | one level of a run's message | none | **dropped**: each is named by its key |
| envelope, value, step, process, kept logs, manual run, session, objective, in its care, works for | approved protocol words | none | kept; "in its care" and "works for" now have OCX on a repository as their subject |
| run (the message) | an OCX message whose `kind` is `run` | none | kept, this sense only |
| run (the tool) | starts a manual run by hand | none | **`start`** (NEW TERM, needs approval) |
| stop, started, ended | the other message kinds | none | kept |
| the node's check, deliberate check | OCX reading every run for it that has no `ended`, as at its start | none | **dropped as a noun**: "reading every open run"; option `--all` |
| watcher | the OCX process that holds one run, from before its workspace to its `ended` | none | kept, NEW TERM, needs approval (the maintainer used it, KEEP.md, 2026-10-16) |
| hook (OCX's) | `ocx2-hook`, OCX's after-receive hook | Fossil: after-receive hook (hooks.md) | kept |
| `R` | a capability letter Fossil does not define; OCX reads it as "may send runs" | Fossil: capability (caps/ref.html defines no `R`) | kept |
| sender | the user the server received an artifact from | Fossil: receipt's user | kept, defined by the receipt |
| pattern | a wiki page `run/NAME` (or a URL) holding a run's keys | Fossil: wiki page; the word "pattern" is OCX's | kept |
| subscription, delivery, `hears`, `checkins` | what a session is given | none | kept |
| file of passwords | the passwords OCX on a clone's host holds | none | **passwords file**; its keys `user`, `runs` become `default_user`, `process_users` |
| node directory `ROOT/node/` | what OCX keeps on the host, and the owner's settings | none | **`ROOT/state/`** (OCX writes it) and **`ROOT/settings/`** (its owner writes it) |
| `r-senders.json` | what a run from a user holding `R` may ask on this host | Fossil: capability `R` | **`ROOT/settings/capability-R.json`** |
| `unconfined` | the file allowing runs with no sandbox | none | **`ROOT/settings/unconfined`** |
| `hook.log` | the hook's log, a line per call | Fossil: hook | **`ROOT/state/hook.log`** |
| `runs/RUN.lock`, `.inbox`, `.workspace`, `.log`; `round.lock` | locks and pipes of runs in OCX's care | none | **`ROOT/state/care/RUN.lock`** and the rest beside it; `ROOT/state/round.lock` |
| `users/USER.lock` | a process user with a run in OCX's care | Fossil: user | **`ROOT/state/process-users/LOGIN.lock`** |
| config rows `ocx-node-key-LOGIN` | the code `register` asked with | none | **`ocx-register-key-LOGIN`** |
| `shares` | files a run's process leaves, which OCX sends as unversioned files | Fossil: unversioned file (unvers.wiki) | **`unversioned_files`** |
| sandbox `capabilities` | the Linux capabilities the process keeps | none (Linux's) | **`linux_capabilities`** |
| sandbox `own_session` | it runs in a Linux session of its own, so it cannot reach a terminal outside | none (Linux's) | **`detach_terminal`** |
| sandbox `ends_with_node` | it ends when its watcher ends | none | **`ends_with_watcher`** |
| sandbox `files` | files made for the process alone | none | **`made_files`** |
| limits `files` | the largest file a process may write | none | **`file_size`** |
| step `files` | writes a check-in's files | Fossil: a check-in's files | kept, this sense only |
| step `clone`, value `$$clone$$` | the run's clone, made with `fossil clone`, and its path | Fossil: clone | kept: one sense, Fossil's |
| value `$$node$$` | the node's login | Fossil: default user | **`$$default_user$$`** |
| value `$$user$$` | the run's `process.user` | Fossil: user | **`$$process_user$$`** |
| remote agent | an agent on another host | Fossil: "remote" is a remote repository's URL (`fossil remote`) | **an agent on another host** |
| `post` (the tool) | writes a plain forum post, or a ticket change | Fossil: forum post, ticket change | kept: the verb "to post"; the noun "post" is only a forum post |

### 1.2 Overloads today, and how each is removed

| Word | Its senses today | Version 2 |
| --- | --- | --- |
| node | the actor (OCX on a repository); a login (key `node`); "a node's login"; the machine ("nodes on other hosts"); `$$node$$`; `ROOT/node/`; options `--node` (create, the hook's command, the watcher); `ends_with_node`; the old tool `node` and pages `node_user`, `node_password`; config `ocx-node-key-` | the word is gone. The actor is "OCX on the run's repository"; the login is the repository's default user; the machine is a host; the rest are renamed in sections 2 and 3 |
| clone | a repository made by `fossil clone`; the key `clone` (a server-code, naming the server's repository or a clone); the same key in reports (the writer's server-code); the step `clone`; the value `$$clone$$` | only Fossil's sense: the key becomes `repository.server_code`; the step `clone` makes a clone and `$$clone$$` is its path |
| user | Fossil's account; `process.user` ("run user"); "the node user"; a person ("the user with cli access"); a Linux account (sandbox `uid`, "the node's own account"); the CLI's global `--user` and `create`'s `--user` | only Fossil's account. Roles are named by their owner: the repository's default user, the process user. A human is a person; a Linux account is a host account. `create`'s option becomes `--process-user` |
| login | a user's name; "the node's login" (a user); `hook --login`; `poll --login`; to sign in | only a user's name. "Sign in" is the act. `hook --login` becomes `--default-user`; `register --login` and `poll --login` keep it, since they ask for a user by its name |
| layer | a level of a run's message; OCX as a layer over Fossil; "our persistent messaging layer" (the maintainer) | the protocol no longer says it: a run's parts are its keys. The word is left to the maintainer's sense, OCX over Fossil |
| check | "the node's check" (reading every open run); a `ci` verdict, "a program's check"; the gate's checks; "a check of a branch"; Fossil's check-in | "check" is never a noun of the protocol: reading every open run (`--all`); a `ci` verdict is a program's judgement; "check-in" stays Fossil's |
| server | the Fossil server; its repository ("the server", "the served repository"); its host ("the server's host", "staging server") | the Fossil server only; the server's repository; the server's host; the staging host |
| run | the message; the tool `run`; "run user"; a call of the hook ("the hook's last run") | the message only. The tool is `start`; the run user is the process user; the hook has calls |
| files | step `files`; sandbox `files`; limits `files` | step `files` only; `made_files`; `file_size` |
| capabilities | Fossil's letters; the sandbox's Linux capabilities | Fossil's only; `linux_capabilities` |
| session | a run with `process.session` true; the sandbox's Linux session (`own_session`) | the run only; `detach_terminal` |
| owner | "the node's owner"; the maintainer's "a clone to have an owner" | the host account that owns `ROOT/settings`; a clone's owner is a person, who chooses its default user |
| remote | Fossil's remote repository (`fossil remote`); "remote agent", "remote nodes" | Fossil's only; "on another host" |

## 4. What changes for a reader

1. A person or a program asks for work by posting a run, a JSON block in a
   forum post or ticket change, as a Fossil user holding admin or setup, or
   holding `R` within what the acting host's owner allows.
2. The run names one repository of the project by its server-code, and the
   default user OCX acts as there; only OCX on that repository, the server's
   through its hook or a clone through `poll`, acts on it, and only if both
   match its own.
3. The run's process acts as its own Fossil user, `process.user`, never a
   default user and never one holding admin or setup, inside the workspace,
   sandbox and limits the run states in full.
4. OCX writes the run's `started` and `ended` as the repository's default
   user, whose capabilities on the server, chosen by whoever has that
   repository's command line, are the most OCX can do there.
5. Who sent anything is the user the server received it from, and a report
   counts only if the server received it from the run's default user, it
   names the run's repository, and that user did not send the run.

=== QUESTIONS ===

1. What is the thing that acts on a run, and how does a run name it?
2. Which user's reports count for a run, and why?
3. What is the difference between the user a run's process acts as and the user that writes the reports?
4. What does each of these words mean: the server's repository; the server's host; the staging host; OCX on the run's repository; host; default user; the repository's default user; `repository.default_user`; `repository.server_code`; the process user; person; host account; the owner of `ROOT/settings`; `start`; reading every open run (`--all`); watcher; passwords file (its keys `default_user`, `process_users`); `ROOT/state/`; `ROOT/settings/`; `ROOT/settings/capability-R.json`; `ROOT/settings/unconfined`; `ROOT/state/hook.log`; `ROOT/state/care/RUN.lock`; `ROOT/state/round.lock`; `ROOT/state/process-users/LOGIN.lock`; `ocx-register-key-LOGIN`; `unversioned_files`; `linux_capabilities`; `detach_terminal`; `ends_with_watcher`; `made_files`; `file_size`; `$$default_user$$`; `$$process_user$$`; an agent on another host; `--process-user`; `--default-user`.
5. Is any word used in two senses?
