lab: clone the forge with the credential the mesh binds and seals to the lab (issue 624) #272

Merged
mesh-admin merged 2 commits from fix/624-lab-reads-the-forge-with-its-credential into main 2026-10-13 12:07:06 +00:00
Contributor

Issue 624, reopened. mesh-tools-go is a private repository. Run run-2026-10-13T11-37-35-441Z failed at checkout: "fatal: could not read Username for 'http://novox.internal:20000'".

The mesh's way, as the build agent does it (mesh-controller cmd/mesh-builder forgeFrom): the forge that answers npm is the forge that hosts the repositories, and its provisioner binds a consumer an account (as) and seals that account's password.

  • modules/lab/module.json: requires: ["npm-package-registry"], with its binds and secrets in the lab's state directory. The runtime env-file names both files: MESH_LAB_FORGE_BINDING, MESH_LAB_FORGE_SECRET.
  • forgeCredential turns them into a git credential-store line for the forge setting's own origin (scheme, host, port). The tools read it at each call.
  • lab_run writes the line 0600 to <work>/.<run>.git-credentials, beside the run's directory and not in it. Every clone runs git -c credential.helper= -c 'credential.helper=store --file=…' clone, and the wrapper removes the file when the run ends. The secret is in no URL, argument, run.sh, status or log. GIT_TERMINAL_PROMPT=0 makes an unreadable repository fail at once instead of prompting.
  • lab_check's setupProblems reads every repository a run clones with the same credential, in a temporary store removed after. It names a repository it cannot read with git's first line, and says when the lab holds no credential at all.

Tests (modules/lab/test/runs.test.ts, 10 pass; the 3 new ones fail on main):

  • the credential line from a binding and a secret, and undefined when either is missing;
  • the script clones through the store and does not contain the secret, and the credential file is outside the run's directory;
  • git itself (git credential fill) is offered the stored credential for the forge's origin and not for another host.

Strict tsc passes on runs.ts and the tests, and on index.ts against a stub of the SDK's tool types. merge-check.sh (MESH_CHECK_MODULES=lab) passes its Go parts; its TypeScript part and the controller's manifest read run on the build seat.

After merge and delivery to shanks, the lab is assigned a requirement: its account is bound on the next composition, through gitea's provisioner, with no person's act. I did not check that this account's team may read every private repository. The build agent's account reads them through the same provisioner, and lab_check will show it.

Fixes issue 624.

Issue 624, reopened. mesh-tools-go is a private repository. Run run-2026-10-13T11-37-35-441Z failed at checkout: "fatal: could not read Username for 'http://novox.internal:20000'". **The mesh's way, as the build agent does it** (mesh-controller cmd/mesh-builder `forgeFrom`): the forge that answers npm is the forge that hosts the repositories, and its provisioner binds a consumer an account (`as`) and seals that account's password. - `modules/lab/module.json`: `requires: ["npm-package-registry"]`, with its `binds` and `secrets` in the lab's state directory. The runtime env-file names both files: `MESH_LAB_FORGE_BINDING`, `MESH_LAB_FORGE_SECRET`. - `forgeCredential` turns them into a git credential-store line for the forge setting's own origin (scheme, host, port). The tools read it at each call. - `lab_run` writes the line 0600 to `<work>/.<run>.git-credentials`, beside the run's directory and not in it. Every clone runs `git -c credential.helper= -c 'credential.helper=store --file=…' clone`, and the wrapper removes the file when the run ends. The secret is in no URL, argument, run.sh, status or log. `GIT_TERMINAL_PROMPT=0` makes an unreadable repository fail at once instead of prompting. - `lab_check`'s `setupProblems` reads every repository a run clones with the same credential, in a temporary store removed after. It names a repository it cannot read with git's first line, and says when the lab holds no credential at all. **Tests** (`modules/lab/test/runs.test.ts`, 10 pass; the 3 new ones fail on main): - the credential line from a binding and a secret, and undefined when either is missing; - the script clones through the store and does not contain the secret, and the credential file is outside the run's directory; - git itself (`git credential fill`) is offered the stored credential for the forge's origin and not for another host. Strict tsc passes on runs.ts and the tests, and on index.ts against a stub of the SDK's tool types. merge-check.sh (MESH_CHECK_MODULES=lab) passes its Go parts; its TypeScript part and the controller's manifest read run on the build seat. After merge and delivery to shanks, the lab is assigned a requirement: its account is bound on the next composition, through gitea's provisioner, with no person's act. I did not check that this account's team may read every private repository. The build agent's account reads them through the same provisioner, and lab_check will show it. Fixes issue 624.
mesh-admin added 1 commit 2026-10-13 11:54:28 +00:00
lab: clone the forge with the credential the mesh binds and seals to the lab (hq issue 624)
mesh/merge-gate out of date: judged against trunk 19ecad261cf2, the trunk is now 8922c890595b; judged again on a recheck or when it is merged
mesh/repo-check out of date: judged against trunk 19ecad261cf2, the trunk is now 8922c890595b; judged again on a recheck or when it is merged
mesh/delivery superseded: a newer head of the same pull request
789d2d9d64
mesh-tools-go is private, and the lab cloned over HTTP with no credential: a run failed at its checkout,
"could not read Username". The lab now requires the package registry, as the build agent does; the
forge's provisioner binds it an account and seals that account's password, and a run offers them to
the forge's own origin through git's credential store, from a file beside the run and removed when it
ends: never in a URL, the run's script, an argument or the log. lab_check reads every repository a run
clones with that same credential and names one it cannot read.
Author
Contributor

Delivery novox/mesh-catalog@8d8dcd5ebb86 — delivered since 2026-10-13T12:09:35Z

Delivery plan — builds gitea, lab → novox, shanks; no bus step

  • tier 0: gitea, lab
  • novox: receives gitea
  • shanks: receives lab
  • gitea provides npm-package-registry, git: its consumers are sent again after it
  • gitea keeps data (ADR 0233): what it holds is backed up before it moves
  • lab keeps data (ADR 0233): what it holds is backed up before it moves
  • grants step: if this changes what the bus's user list says (a new tool, subject or user), novox is sent that list alone, every build there kept, before lab is judged on its first machine

Machines

  • gitea on novox: passed — healthy 1 times over 29s
  • lab on shanks: passed — healthy 1 times over 51s
  • gitea on the rest running it: sent
  • lab on the rest running it: sent

Transitions

  • 2026-10-13 12:01 (new) → proposed (announced): novox/mesh-catalog#272's head announced
  • 2026-10-13 12:03 proposed → checked (checked): a verdict names this commit and the trunk's head as its trunk commit
  • 2026-10-13 12:03 checked → ready (accepted): the gate passed or warned, and the repository's own check did not fail
  • 2026-10-13 12:07 ready → published (merged): on the trunk its modules follow: merged there, and its walk opened — or nothing for a walk to move
  • 2026-10-13 12:07 published → delivering (go): its walk started: let go by this owner in its group's order, by a person, or on the controller's own path — not a failed walk that carried a later commit for it, after which it waits for a walk of its own commit
  • 2026-10-13 12:09 delivering → delivered (done): its walk is done, carrying its own commit: every machine of its deploy plan passed, or was left as its policy says

The commit's note under refs/notes/mesh-plan keeps every transition: git log --notes=mesh-plan.

<!-- mesh-delivery:view --> **Delivery** `novox/mesh-catalog@8d8dcd5ebb86` — **delivered** since 2026-10-13T12:09:35Z **Delivery plan** — builds gitea, lab → novox, shanks; no bus step - tier 0: gitea, lab - novox: receives gitea - shanks: receives lab - gitea provides npm-package-registry, git: its consumers are sent again after it - gitea keeps data (ADR 0233): what it holds is backed up before it moves - lab keeps data (ADR 0233): what it holds is backed up before it moves - grants step: if this changes what the bus's user list says (a new tool, subject or user), novox is sent that list alone, every build there kept, before lab is judged on its first machine **Machines** - gitea on novox: passed — healthy 1 times over 29s - lab on shanks: passed — healthy 1 times over 51s - gitea on the rest running it: sent - lab on the rest running it: sent **Transitions** - 2026-10-13 12:01 (new) → proposed (announced): novox/mesh-catalog#272's head announced - 2026-10-13 12:03 proposed → checked (checked): a verdict names this commit and the trunk's head as its trunk commit - 2026-10-13 12:03 checked → ready (accepted): the gate passed or warned, and the repository's own check did not fail - 2026-10-13 12:07 ready → published (merged): on the trunk its modules follow: merged there, and its walk opened — or nothing for a walk to move - 2026-10-13 12:07 published → delivering (go): its walk started: let go by this owner in its group's order, by a person, or on the controller's own path — not a failed walk that carried a later commit for it, after which it waits for a walk of its own commit - 2026-10-13 12:09 delivering → delivered (done): its walk is done, carrying its own commit: every machine of its deploy plan passed, or was left as its policy says The commit's note under `refs/notes/mesh-plan` keeps every transition: `git log --notes=mesh-plan`.
Author
Contributor

Merge check at 789d2d9d
Judged: head 789d2d9d649f merged into trunk 19ecad261cf2; read beside it: mesh-controller 584aa2d7d7a5, mesh-controller-main 584aa2d7d7a5, mesh-host 7a41e120635b, mesh-tools 954e1a53eef9

  • mesh/merge-gate: PASS — every machine composes with the change as it did without (4 of 4 compose) (modules: lab)
  • mesh/repo-check: PASS — its merge-check.sh passed, each part in its toolchain: merge-check.sh (go), merge-check-typescript.sh (typescript)

Delivery plan — builds lab → shanks; no bus step

  • tier 0: lab
  • shanks: receives lab
  • lab keeps data (ADR 0233): what it holds is backed up before it moves
  • grants step: if this changes what the bus's user list says (a new tool, subject or user), novox is sent that list alone, every build there kept, before lab is judged on its first machine

Run by the build seat on ace as build-1791892485276999974 (builds --log build-1791892485276999974).

--- the gate: lab
lab: ok, keeps work (cache); WARNING: runtime-env ask(s) for a setting and do(es) not say whether it is trusted, so it counts as trusted: set at the terminal alone; say "trusted" false where nothing trusts it (novox/hq issue 339)
long-running resources without health: 0
files asking for a setting without saying whether it is trusted: 1
1 manifest(s) checked. Judged against the seats this binary carries; a claim on one of the mesh's own seats is judged fully at registration, and a seat declared by a module not given here reads as unknown. Identities judged on a 6-character machine name, against the bounds of the providers given here
judging 1 module(s) changed against 4 machine(s), as the snapshot of 2026-10-13T11:13:29Z says they run
composing every machine as the mesh is
the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued
the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued
composing every machine with the change
the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued
the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued
merge gate: PASS — every machine composes with the change as it did without (4 of 4 compose)
judged by controller development build against the facts of 2026-10-13T11:13:29Z

modules the change moves:
  - lab (changed)

machines:
  - a machine (f35): composes
  - holds mesh-dns-resolver (idt): composes
  - holds git, holds mesh-artifact-store, holds mesh-broker, holds mesh-catalog, holds mesh-delivery, holds mesh-dns-resolver, holds mesh-store, holds mesh-vault, holds npm-package-registry, the control node, the hub (ygcyr): composes; the change adds 1 resource(s) and removes 0 (+file:gitea.grant-npm-package-registry-yvbpsm.lab)
  - a machine (yvbpsm): composes; the change adds 2 resource(s) and removes 0 (+file:lab.bound-npm-package-registry, +file:lab.secret-npm-package-registry)

a merge would rebuild 1 module(s) in 1 tier(s): lab
--- its merge-check.sh (go toolchain)
ok  	git.novox.be/novox/mesh-catalog/checks/words	0.002s
words: 12 retired words and 70 daemons' lines, none in the 46280 strings of 714 files
ok  	git.novox.be/novox/mesh-catalog/checks/agenthome	0.012s
agent-home: no archive and no file written into under the agent's home
ok  	git.novox.be/novox/mesh-catalog/checks/secrets	0.011s
secrets: no setting can replace a vault secret in a mergeable file (1 known, nested)
ok  	git.novox.be/novox/mesh-catalog/checks/paths	0.006s
paths: no module names another's state on its machine (3 known, listed to go)
long-running resources without health: 66, as kept
ok  	git.novox.be/novox/mesh-catalog/checks/deps	0.210s
modules/lab is TypeScript: merge-check-typescript.sh type-checks and tests it
--- its merge-check-typescript.sh (typescript toolchain)
type-checking modules/lab (TypeScript)
testing modules/lab (TypeScript)
✔ a checkout with a lock file at its root is installed there (2.067321ms)
✔ a checkout whose package lives one directory down is installed there, as mesh-tools' node-tools (0.915183ms)
✔ a package.json with no lock file is named, never installed (0.43045ms)
✔ a run installs and builds mesh-tools in node-tools, where its lock file is (11.515778ms)
✔ a run installs a checkout with its lock file at the root there, and builds only when asked (4.740961ms)
✔ a run fails at its setup, naming the checkout, when nothing of it can be installed (10.028179ms)
✔ a run checks out mesh-tools-go and says where its checkouts are (0.717951ms)
✔ the forge credential is the bound account and its sealed secret, for the forge's own origin (0.657468ms)
✔ a run clones through git's credential store, and its script carries no secret (0.717942ms)
✔ git presents the stored credential to the forge, and only when one is given (19.974546ms)
ℹ tests 10
ℹ suites 0
ℹ pass 10
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 135.526967

Out of date when it landed: out of date: judged against trunk 19ecad261c, the trunk is now 8922c890595b; judged again on a recheck or when it is merged

**Merge check** at `789d2d9d` Judged: head `789d2d9d649f` merged into trunk `19ecad261cf2`; read beside it: mesh-controller `584aa2d7d7a5`, mesh-controller-main `584aa2d7d7a5`, mesh-host `7a41e120635b`, mesh-tools `954e1a53eef9` - `mesh/merge-gate`: **PASS** — every machine composes with the change as it did without (4 of 4 compose) (modules: lab) - `mesh/repo-check`: **PASS** — its merge-check.sh passed, each part in its toolchain: merge-check.sh (go), merge-check-typescript.sh (typescript) **Delivery plan** — builds lab → shanks; no bus step - tier 0: lab - shanks: receives lab - lab keeps data (ADR 0233): what it holds is backed up before it moves - grants step: if this changes what the bus's user list says (a new tool, subject or user), novox is sent that list alone, every build there kept, before lab is judged on its first machine Run by the build seat on ace as `build-1791892485276999974` (`builds --log build-1791892485276999974`). ``` --- the gate: lab lab: ok, keeps work (cache); WARNING: runtime-env ask(s) for a setting and do(es) not say whether it is trusted, so it counts as trusted: set at the terminal alone; say "trusted" false where nothing trusts it (novox/hq issue 339) long-running resources without health: 0 files asking for a setting without saying whether it is trusted: 1 1 manifest(s) checked. Judged against the seats this binary carries; a claim on one of the mesh's own seats is judged fully at registration, and a seat declared by a module not given here reads as unknown. Identities judged on a 6-character machine name, against the bounds of the providers given here judging 1 module(s) changed against 4 machine(s), as the snapshot of 2026-10-13T11:13:29Z says they run composing every machine as the mesh is the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued composing every machine with the change the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued merge gate: PASS — every machine composes with the change as it did without (4 of 4 compose) judged by controller development build against the facts of 2026-10-13T11:13:29Z modules the change moves: - lab (changed) machines: - a machine (f35): composes - holds mesh-dns-resolver (idt): composes - holds git, holds mesh-artifact-store, holds mesh-broker, holds mesh-catalog, holds mesh-delivery, holds mesh-dns-resolver, holds mesh-store, holds mesh-vault, holds npm-package-registry, the control node, the hub (ygcyr): composes; the change adds 1 resource(s) and removes 0 (+file:gitea.grant-npm-package-registry-yvbpsm.lab) - a machine (yvbpsm): composes; the change adds 2 resource(s) and removes 0 (+file:lab.bound-npm-package-registry, +file:lab.secret-npm-package-registry) a merge would rebuild 1 module(s) in 1 tier(s): lab --- its merge-check.sh (go toolchain) ok git.novox.be/novox/mesh-catalog/checks/words 0.002s words: 12 retired words and 70 daemons' lines, none in the 46280 strings of 714 files ok git.novox.be/novox/mesh-catalog/checks/agenthome 0.012s agent-home: no archive and no file written into under the agent's home ok git.novox.be/novox/mesh-catalog/checks/secrets 0.011s secrets: no setting can replace a vault secret in a mergeable file (1 known, nested) ok git.novox.be/novox/mesh-catalog/checks/paths 0.006s paths: no module names another's state on its machine (3 known, listed to go) long-running resources without health: 66, as kept ok git.novox.be/novox/mesh-catalog/checks/deps 0.210s modules/lab is TypeScript: merge-check-typescript.sh type-checks and tests it --- its merge-check-typescript.sh (typescript toolchain) type-checking modules/lab (TypeScript) testing modules/lab (TypeScript) ✔ a checkout with a lock file at its root is installed there (2.067321ms) ✔ a checkout whose package lives one directory down is installed there, as mesh-tools' node-tools (0.915183ms) ✔ a package.json with no lock file is named, never installed (0.43045ms) ✔ a run installs and builds mesh-tools in node-tools, where its lock file is (11.515778ms) ✔ a run installs a checkout with its lock file at the root there, and builds only when asked (4.740961ms) ✔ a run fails at its setup, naming the checkout, when nothing of it can be installed (10.028179ms) ✔ a run checks out mesh-tools-go and says where its checkouts are (0.717951ms) ✔ the forge credential is the bound account and its sealed secret, for the forge's own origin (0.657468ms) ✔ a run clones through git's credential store, and its script carries no secret (0.717942ms) ✔ git presents the stored credential to the forge, and only when one is given (19.974546ms) ℹ tests 10 ℹ suites 0 ℹ pass 10 ℹ fail 0 ℹ cancelled 0 ℹ skipped 0 ℹ todo 0 ℹ duration_ms 135.526967 ``` **Out of date when it landed**: out of date: judged against trunk 19ecad261cf2, the trunk is now 8922c890595b; judged again on a recheck or when it is merged
mesh-admin left a comment
Author
Contributor

Verdict: request changes at 789d2d9d64

Statuses at this head when reviewed: mesh/merge-gate "pending" ("building on ace since 13:54", after "waiting in the build queue since 13:54"), mesh/delivery "pending" ("checking"). No mesh/repo-check status was posted yet. Neither required check was green, so this could not be merged on this head as things stand, independent of the findings below.

BLOCKING

  1. The credential file is not removed when a run is stopped, crashes or the machine restarts. The only removal is the rm -f line in the wrapper after bash run.sh returns. stop sends SIGTERM to the whole process group (process.kill(-s.pid, "SIGTERM")), which kills the wrapper bash itself, so the line after it never runs. I reproduced this with the same shape (a detached bash -c running a child, then rm -f, killed by SIGTERM to the group): the file was left on disk. A runtime restart leaves a run "lost" with its file in place, and a reboot does the same. Nothing removes files that are left behind, because no code looks for old .run-*.git-credentials files. The fix I suggest: (a) remove the file in run.sh right after the last clone, because nothing after checkout needs it; (b) put trap 'rm -f <file>' EXIT INT TERM HUP at the top of the wrapper and of run.sh; (c) have start and lab_check delete every .run-*.git-credentials under the work directory whose run is not running. Add a test that kills a run through stop and checks the file is gone.

  2. The account is not read-only, but the description says it is. The gitea provisioner puts every npm-package-registry consumer on the org's packages team. GiteaAdmin.ensureTeam(ORG, "packages", true) gives repo.code: read and repo.packages: write, with includes_all_repositories: true. The lab would therefore hold a credential that can publish under the @novox npm scope, which every TypeScript module build installs from. This matters more because of finding 1 and because of what a lab run executes. The file stays on disk, at 0600 but owned by the same user, for the whole run, and that run builds and runs code from branches nobody has reviewed yet (that is the lab's purpose). A branch under test can read the file and publish a package. This raises a lab run from "runs untrusted branch code in throwaway machines" to "can write the mesh's package supply". Either the lab gets a read-only binding (see point 3), or the operator accepts the write scope explicitly and it is written down. The second option is a decision for the operator, not something to settle in review.

NOT BLOCKING, ON THE CHOICE OF ACCOUNT

  1. Reusing npm-package-registry has a precedent: the build agent clones private repositories with this binding (the comment in ensureTeam about "the builder's first credentialed clone" records it). The build agent needs package write and the lab does not. Nothing has been decided about a clone credential yet. The header of modules/gitea/provisioner/index.ts still says "the mesh's own repositories are public, and a clone credential is not yet decided (ADR 0111)", and ADR 0111 (a build source is on the git seat or external) has no clause about credentials. ensureTeam already takes packageWrite, so a read-only team (code read, packages read) is a small change in the gitea module. Giving it to the lab, through its own provision or a binding option, is the right shape. It could be a follow-up issue if finding 1 is fixed and the operator accepts the write scope for now. That header comment is out of date either way, because mesh-tools-go is private.

SECURITY CHECKS THAT HOLD

  1. The secret is not in any URL, argument, run.sh, status file or log. forgeCredential builds the store line, writeCredential writes it with mode 0600 (a new path for each run, so the mode set at creation always applies), and credentialArgs passes only the file path. The clones get the helper through git -c, which is not saved into the clone's .git/config. The checkouts the bed pushes onward therefore carry no credential, and I found no path in mesh-lab (incus file push of chosen files only) by which the file reaches a bed's machines. Git's stderr, which lab_check quotes, contains the URL without the credential. GIT_TERMINAL_PROMPT=0 is set both in the run and in lab_check. lab_check keeps its copy in an mkdtemp directory (0700) and removes it in a finally, which is correct. A SIGKILL of the tool runner during a check would still leave it in /tmp. That is a small window, but the cleanup in 1(c) could cover it as well.

  2. The store line is limited to the forge setting's scheme, host and port, and the git-level test proves that the credential is not offered to another host. The forge setting is http://, so git sends the password as basic auth in cleartext. I assume this is acceptable only because the forge is reached over the mesh's own tunnel. Please say so in the doc comment or confirm it.

THE GRANT IN THE MANIFEST

  1. The requires / binds / secrets entries have the same provision name and shape as the build agent's. They use ${dir:state} where the build agent uses ${dir:mesh-state}, which matches other modules (gitea, baserow, keycloak). The env-file is 0600 and names only the paths. One difference: the build agent declares the requirement optional: true, and the lab's is required. The code already handles a missing credential (public repositories still clone, and lab_check says the lab holds none). If the lab should stay assignable on a mesh where the registry is not yet bound, make the requirement optional too. If required is meant, say why.

TESTS AND CHECKS, RUN HERE

  1. At the head, node --test in modules/lab passes 10 of 10. On main (19ecad2) with the head's test file, the file fails to load with "SyntaxError: The requested module '../tools/runs.ts' does not provide an export named 'credentialArgs'". The new tests fail on main as the brief says, but as a load error that also takes down the 7 old tests, not as 3 separate assertion failures. MESH_CHECK_MODULES=lab sh merge-check.sh passes its Go parts and prints "NOT CHECKED: no controller was built beside this check". merge-check-typescript.sh, run against a toolchain directory with mesh-sdk 0.1.14 built from main, typescript and @types/node, type-checks modules/lab with no errors and passes 10 of 10 tests.

  2. Not covered: whether the bound account can in fact read mesh-tools-go once the binding exists. The team has includes_all_repositories, so it should, and lab_check will show it after delivery. That also means the lab can read every private repository in the novox org, not only the ones it clones.

Verdict: request changes at 789d2d9d649f6fdaa6ab2aa04e8301d18ba2b78d Statuses at this head when reviewed: mesh/merge-gate "pending" ("building on ace since 13:54", after "waiting in the build queue since 13:54"), mesh/delivery "pending" ("checking"). No mesh/repo-check status was posted yet. Neither required check was green, so this could not be merged on this head as things stand, independent of the findings below. BLOCKING 1. The credential file is not removed when a run is stopped, crashes or the machine restarts. The only removal is the `rm -f` line in the wrapper after `bash run.sh` returns. `stop` sends SIGTERM to the whole process group (`process.kill(-s.pid, "SIGTERM")`), which kills the wrapper bash itself, so the line after it never runs. I reproduced this with the same shape (a detached `bash -c` running a child, then `rm -f`, killed by SIGTERM to the group): the file was left on disk. A runtime restart leaves a run "lost" with its file in place, and a reboot does the same. Nothing removes files that are left behind, because no code looks for old `.run-*.git-credentials` files. The fix I suggest: (a) remove the file in run.sh right after the last clone, because nothing after checkout needs it; (b) put `trap 'rm -f <file>' EXIT INT TERM HUP` at the top of the wrapper and of run.sh; (c) have `start` and `lab_check` delete every `.run-*.git-credentials` under the work directory whose run is not running. Add a test that kills a run through `stop` and checks the file is gone. 2. The account is not read-only, but the description says it is. The gitea provisioner puts every npm-package-registry consumer on the org's `packages` team. `GiteaAdmin.ensureTeam(ORG, "packages", true)` gives `repo.code: read` and `repo.packages: write`, with `includes_all_repositories: true`. The lab would therefore hold a credential that can publish under the `@novox` npm scope, which every TypeScript module build installs from. This matters more because of finding 1 and because of what a lab run executes. The file stays on disk, at 0600 but owned by the same user, for the whole run, and that run builds and runs code from branches nobody has reviewed yet (that is the lab's purpose). A branch under test can read the file and publish a package. This raises a lab run from "runs untrusted branch code in throwaway machines" to "can write the mesh's package supply". Either the lab gets a read-only binding (see point 3), or the operator accepts the write scope explicitly and it is written down. The second option is a decision for the operator, not something to settle in review. NOT BLOCKING, ON THE CHOICE OF ACCOUNT 3. Reusing npm-package-registry has a precedent: the build agent clones private repositories with this binding (the comment in `ensureTeam` about "the builder's first credentialed clone" records it). The build agent needs package write and the lab does not. Nothing has been decided about a clone credential yet. The header of `modules/gitea/provisioner/index.ts` still says "the mesh's own repositories are public, and a clone credential is not yet decided (ADR 0111)", and ADR 0111 (a build source is on the git seat or external) has no clause about credentials. `ensureTeam` already takes `packageWrite`, so a read-only team (code read, packages read) is a small change in the gitea module. Giving it to the lab, through its own provision or a binding option, is the right shape. It could be a follow-up issue if finding 1 is fixed and the operator accepts the write scope for now. That header comment is out of date either way, because mesh-tools-go is private. SECURITY CHECKS THAT HOLD 4. The secret is not in any URL, argument, run.sh, status file or log. `forgeCredential` builds the store line, `writeCredential` writes it with mode 0600 (a new path for each run, so the mode set at creation always applies), and `credentialArgs` passes only the file path. The clones get the helper through `git -c`, which is not saved into the clone's `.git/config`. The checkouts the bed pushes onward therefore carry no credential, and I found no path in mesh-lab (`incus file push` of chosen files only) by which the file reaches a bed's machines. Git's stderr, which `lab_check` quotes, contains the URL without the credential. `GIT_TERMINAL_PROMPT=0` is set both in the run and in `lab_check`. `lab_check` keeps its copy in an mkdtemp directory (0700) and removes it in a `finally`, which is correct. A SIGKILL of the tool runner during a check would still leave it in /tmp. That is a small window, but the cleanup in 1(c) could cover it as well. 5. The store line is limited to the forge setting's scheme, host and port, and the git-level test proves that the credential is not offered to another host. The forge setting is `http://`, so git sends the password as basic auth in cleartext. I assume this is acceptable only because the forge is reached over the mesh's own tunnel. Please say so in the doc comment or confirm it. THE GRANT IN THE MANIFEST 6. The `requires` / `binds` / `secrets` entries have the same provision name and shape as the build agent's. They use `${dir:state}` where the build agent uses `${dir:mesh-state}`, which matches other modules (gitea, baserow, keycloak). The env-file is 0600 and names only the paths. One difference: the build agent declares the requirement `optional: true`, and the lab's is required. The code already handles a missing credential (public repositories still clone, and lab_check says the lab holds none). If the lab should stay assignable on a mesh where the registry is not yet bound, make the requirement optional too. If required is meant, say why. TESTS AND CHECKS, RUN HERE 7. At the head, `node --test` in modules/lab passes 10 of 10. On main (19ecad2) with the head's test file, the file fails to load with "SyntaxError: The requested module '../tools/runs.ts' does not provide an export named 'credentialArgs'". The new tests fail on main as the brief says, but as a load error that also takes down the 7 old tests, not as 3 separate assertion failures. `MESH_CHECK_MODULES=lab sh merge-check.sh` passes its Go parts and prints "NOT CHECKED: no controller was built beside this check". `merge-check-typescript.sh`, run against a toolchain directory with mesh-sdk 0.1.14 built from main, typescript and @types/node, type-checks modules/lab with no errors and passes 10 of 10 tests. 8. Not covered: whether the bound account can in fact read mesh-tools-go once the binding exists. The team has `includes_all_repositories`, so it should, and lab_check will show it after delivery. That also means the lab can read every private repository in the novox org, not only the ones it clones.
jschoubben added 1 commit 2026-10-13 12:01:02 +00:00
lab: a read-only forge account of its own, and no credential left on disk after a stop (hq issue 624, review 196)
mesh/merge-gate head 8d8dcd5ebb86 merged into trunk cd239283207a — pass: builds gitea, lab → novox, shanks; no bus step; every machine composes with the ch…
mesh/repo-check head 8d8dcd5ebb86 merged into trunk cd239283207a — pass: its merge-check.sh passed, each part in its toolchain: merge-check.sh (go), merge-…
mesh/delivery delivered
8d8dcd5ebb
The lab's credential came from the package team, which also writes the @novox packages, and the
branches a run clones are not reviewed yet. The lab now contributes {"access": "read"} to its
npm-package-registry requirement, and gitea's provisioner puts such a consumer on a team of its own,
readers: code read on the org's repositories, package read, no write, and off the package team. The
build agent, which publishes, stays on packages.

A stop's SIGTERM to the run's process group killed the wrapper before it removed the credential file.
The run's script now removes it as soon as its clones are done and traps every way it ends, and a run's
start and lab_check remove what a crash or a reboot left.
Author
Contributor

New head 8d8dcd5ebb answers both blocking points of review 196.

1. The credential is not left on disk.

  • run.sh traps EXIT, TERM, INT and HUP to remove the credential file, and removes it as soon as the clones are done, before anything is built or run.
  • The next run's start removes files a crash or reboot left behind (cleanCredentials). So does lab_check, which keeps a running run's file and says what it removed.
  • Tests: SIGTERM, SIGINT and SIGHUP to a script with the guard each leave no file; the removal sits between the clones and the first npm ci; a crash's leftovers are cleaned but the running run's file is kept.

2. The lab's own read-only account.

  • The lab contributes {"access": "read"} to its npm-package-registry requirement.
  • gitea's provisioner (new provisioner/teams.ts) puts such a consumer on the team readers: ensureTeam("novox", "readers", packageWrite=false), giving code read on all of the org's repositories, package read and no write. It takes the consumer off packages, through the new removeUserFromTeam. holds checks membership of readers.
  • The build agent, and any consumer that asks for nothing or for write, stays on packages as before; any other access value is refused.
  • The account is provisioned the way build-agent's is: the mesh derives its login (as), mints and seals its password, and gitea's provisioner creates it.
  • Tests (gitea test/teams.test.ts): the team for each access, a reader made on readers and taken off packages, a publisher unchanged. The lab's test holds that its manifest asks for read.

For the account to exist on the live forge, nothing is done by hand. Merging delivers the gitea module (its provisioner bundle) and the lab module, and the lab's requirement then binds on the next composition. gitea's provisioner then creates the readers team and the lab's user on its next reconcile, within a minute, and the lab's binding and sealed secret reach shanks on that push. The operator needs to do nothing. If holds reports otherwise, lab_check names the repository it cannot read.

lab: 14 tests pass. gitea teams: 4 pass. Strict tsc passes on runs.ts, teams.ts and their tests, and on lab/tools/index.ts and gitea/provisioner/index.ts against stubs of the SDK's types.

New head 8d8dcd5ebb8688621292db699b5e375d2b115e72 answers both blocking points of review 196. **1. The credential is not left on disk.** - run.sh traps EXIT, TERM, INT and HUP to remove the credential file, and removes it as soon as the clones are done, before anything is built or run. - The next run's start removes files a crash or reboot left behind (`cleanCredentials`). So does lab_check, which keeps a running run's file and says what it removed. - Tests: SIGTERM, SIGINT and SIGHUP to a script with the guard each leave no file; the removal sits between the clones and the first npm ci; a crash's leftovers are cleaned but the running run's file is kept. **2. The lab's own read-only account.** - The lab contributes `{"access": "read"}` to its `npm-package-registry` requirement. - gitea's provisioner (new `provisioner/teams.ts`) puts such a consumer on the team `readers`: `ensureTeam("novox", "readers", packageWrite=false)`, giving code read on all of the org's repositories, package read and no write. It takes the consumer off `packages`, through the new `removeUserFromTeam`. `holds` checks membership of `readers`. - The build agent, and any consumer that asks for nothing or for `write`, stays on `packages` as before; any other access value is refused. - The account is provisioned the way build-agent's is: the mesh derives its login (`as`), mints and seals its password, and gitea's provisioner creates it. - Tests (gitea `test/teams.test.ts`): the team for each access, a reader made on `readers` and taken off `packages`, a publisher unchanged. The lab's test holds that its manifest asks for read. **For the account to exist on the live forge**, nothing is done by hand. Merging delivers the gitea module (its provisioner bundle) and the lab module, and the lab's requirement then binds on the next composition. gitea's provisioner then creates the `readers` team and the lab's user on its next reconcile, within a minute, and the lab's binding and sealed secret reach shanks on that push. The operator needs to do nothing. If `holds` reports otherwise, `lab_check` names the repository it cannot read. lab: 14 tests pass. gitea teams: 4 pass. Strict tsc passes on runs.ts, teams.ts and their tests, and on lab/tools/index.ts and gitea/provisioner/index.ts against stubs of the SDK's types.
mesh-admin left a comment
Author
Contributor

Verdict: approve at 8d8dcd5ebb

Statuses at this head when reviewed (12:01 UTC): mesh/merge-gate "pending" ("building on ace since 14:01"), mesh/delivery "pending" ("checking"), combined state "pending". No mesh/repo-check status was posted yet. This approval covers the code only. Do not merge until both required checks are green at this head and have been read.

Both blocking findings of review 196 are fixed. Nothing below blocks.

  1. The credential no longer outlives a stop. run.sh sets traps on EXIT, TERM, INT and HUP at its top and removes the file straight after the last clone, before npm ci or any code under test runs. I reproduced the case review 196 found, this time with the traps: a detached wrapper running a script with this guard, then SIGTERM to the whole process group while the script waits on a child. The file was removed. Before this change it stayed. start removes any .run-*.git-credentials left in the work directory before it writes its own. lab_check does the same, but keeps the file of a running run, and says what it removed. A SIGKILL or a reboot during checkout is the only way a file stays on disk, and it then stays only until the next run starts or lab_check is called, at 0600 in a 0700 directory. That is acceptable.

  2. The lab's account can no longer write. The lab contributes {"access": "read"} to npm-package-registry. I followed that value through the controller: ContributionsFrom reads it from the consumer's resolution, it is carried on the grant's values, and the SDK's runProvisioner passes it in Provision.values. A change in it also changes the grant's hash, so the grant is applied again. teamFor puts it on readers, created through ensureTeam(ORG, "readers", false). That team gets permission: read, units_map with repo.code: read and repo.packages: read, and can_create_org_repo: false. units_map lists every unit the team has, so the team has no write on any unit. The lab's login is its own identity, derived per module and node, so it is not the build agent's.

  3. No existing account's rights change. A consumer that contributes no access, which is the build agent's case and the only other consumer, gets exactly the calls it got before, in the same order: ensureOrg, ensureTeam("novox", "packages", true), ensureUser, addUserToTeam. The new teams test asserts that sequence. The packages team is patched with the same units as on main. removeUserFromTeam is called only for a consumer that asked for read, and only for that consumer's own login on packages, so no write account can be narrowed. An unknown access value throws, so the grant fails loudly rather than defaulting to write. holds for a reader checks membership of readers.

  4. Tests and checks, run niced here. merge-check-typescript.sh with MESH_CHECK_MODULES=lab,gitea, against a toolchain directory with mesh-sdk 0.1.14 built from main, typescript and @types/node, type-checks both modules with no errors. gitea passes 89 of 89 tests and lab passes 14 of 14. On main (19ecad2) with the head's tests, lab's test file fails to load ("does not provide an export named 'cleanCredentials'") and gitea's teams.test.ts fails with ERR_MODULE_NOT_FOUND for provisioner/teams.ts, so the new tests fail on main. MESH_CHECK_MODULES=lab,gitea sh merge-check.sh passes its Go parts (including gitea/cmd/forge and gitea/cmd/npm-registry) and prints "NOT CHECKED: no controller was built beside this check".

NOT BLOCKING

  1. holds for a reader does not check that the login is off packages. If someone added it there by hand, the harness would not notice until the next create. A check in holds that a reader is not on packages would close that gap. A follow-up is enough.

  2. A reader is still an ordinary gitea user, so it can create repositories and publish packages under its own user namespace. Neither is consumed by the mesh, and it cannot touch the novox org or the @novox scope. If that matters, the gitea module could create these users with max_repo_creation: 0.

  3. Unchanged since review 196: readers has includes_all_repositories, so the lab can read every repository in the novox org, not only the 7 it clones. The forge setting is still http://, so the password travels as basic auth, which relies on the mesh's tunnel.

Verdict: approve at 8d8dcd5ebb8688621292db699b5e375d2b115e72 Statuses at this head when reviewed (12:01 UTC): mesh/merge-gate "pending" ("building on ace since 14:01"), mesh/delivery "pending" ("checking"), combined state "pending". No mesh/repo-check status was posted yet. This approval covers the code only. Do not merge until both required checks are green at this head and have been read. Both blocking findings of review 196 are fixed. Nothing below blocks. 1. The credential no longer outlives a stop. run.sh sets traps on EXIT, TERM, INT and HUP at its top and removes the file straight after the last clone, before `npm ci` or any code under test runs. I reproduced the case review 196 found, this time with the traps: a detached wrapper running a script with this guard, then SIGTERM to the whole process group while the script waits on a child. The file was removed. Before this change it stayed. `start` removes any `.run-*.git-credentials` left in the work directory before it writes its own. `lab_check` does the same, but keeps the file of a running run, and says what it removed. A SIGKILL or a reboot during checkout is the only way a file stays on disk, and it then stays only until the next run starts or lab_check is called, at 0600 in a 0700 directory. That is acceptable. 2. The lab's account can no longer write. The lab contributes `{"access": "read"}` to npm-package-registry. I followed that value through the controller: `ContributionsFrom` reads it from the consumer's resolution, it is carried on the grant's values, and the SDK's `runProvisioner` passes it in `Provision.values`. A change in it also changes the grant's hash, so the grant is applied again. `teamFor` puts it on `readers`, created through `ensureTeam(ORG, "readers", false)`. That team gets `permission: read`, `units_map` with `repo.code: read` and `repo.packages: read`, and `can_create_org_repo: false`. `units_map` lists every unit the team has, so the team has no write on any unit. The lab's login is its own identity, derived per module and node, so it is not the build agent's. 3. No existing account's rights change. A consumer that contributes no `access`, which is the build agent's case and the only other consumer, gets exactly the calls it got before, in the same order: ensureOrg, `ensureTeam("novox", "packages", true)`, ensureUser, addUserToTeam. The new teams test asserts that sequence. The `packages` team is patched with the same units as on main. `removeUserFromTeam` is called only for a consumer that asked for read, and only for that consumer's own login on `packages`, so no write account can be narrowed. An unknown `access` value throws, so the grant fails loudly rather than defaulting to write. `holds` for a reader checks membership of `readers`. 4. Tests and checks, run niced here. `merge-check-typescript.sh` with MESH_CHECK_MODULES=lab,gitea, against a toolchain directory with mesh-sdk 0.1.14 built from main, typescript and @types/node, type-checks both modules with no errors. gitea passes 89 of 89 tests and lab passes 14 of 14. On main (19ecad2) with the head's tests, lab's test file fails to load ("does not provide an export named 'cleanCredentials'") and gitea's teams.test.ts fails with ERR_MODULE_NOT_FOUND for provisioner/teams.ts, so the new tests fail on main. `MESH_CHECK_MODULES=lab,gitea sh merge-check.sh` passes its Go parts (including gitea/cmd/forge and gitea/cmd/npm-registry) and prints "NOT CHECKED: no controller was built beside this check". NOT BLOCKING 5. `holds` for a reader does not check that the login is off `packages`. If someone added it there by hand, the harness would not notice until the next create. A check in `holds` that a reader is not on `packages` would close that gap. A follow-up is enough. 6. A reader is still an ordinary gitea user, so it can create repositories and publish packages under its own user namespace. Neither is consumed by the mesh, and it cannot touch the `novox` org or the `@novox` scope. If that matters, the gitea module could create these users with `max_repo_creation: 0`. 7. Unchanged since review 196: `readers` has `includes_all_repositories`, so the lab can read every repository in the novox org, not only the 7 it clones. The forge setting is still `http://`, so the password travels as basic auth, which relies on the mesh's tunnel.
Author
Contributor

Merge check at 8d8dcd5e
Judged: head 8d8dcd5ebb86 merged into trunk cd239283207a; read beside it: mesh-controller 584aa2d7d7a5, mesh-controller-main 584aa2d7d7a5, mesh-host 7a41e120635b, mesh-tools 954e1a53eef9

  • mesh/merge-gate: PASS — every machine composes with the change as it did without (4 of 4 compose) (modules: gitea, lab)
  • mesh/repo-check: PASS — its merge-check.sh passed, each part in its toolchain: merge-check.sh (go), merge-check-typescript.sh (typescript)

Delivery plan — builds gitea, lab → novox, shanks; no bus step

  • tier 0: gitea, lab
  • novox: receives gitea
  • shanks: receives lab
  • gitea provides npm-package-registry, git: its consumers are sent again after it
  • gitea keeps data (ADR 0233): what it holds is backed up before it moves
  • lab keeps data (ADR 0233): what it holds is backed up before it moves
  • grants step: if this changes what the bus's user list says (a new tool, subject or user), novox is sent that list alone, every build there kept, before lab is judged on its first machine

Run by the build seat on ace as build-1791892909885250099 (builds --log build-1791892909885250099).

--- the gate: gitea, lab
gitea: ok, keeps data (valuable); WARNING: server stay(s) up and say(s) not how it is ready — judged by liveness alone, refused from 2026-11-18 (ADR 0240 rule 8)
lab: ok, keeps work (cache); WARNING: runtime-env ask(s) for a setting and do(es) not say whether it is trusted, so it counts as trusted: set at the terminal alone; say "trusted" false where nothing trusts it (novox/hq issue 339)
long-running resources without health: 1
files asking for a setting without saying whether it is trusted: 1
2 manifest(s) checked. Judged against the seats this binary carries; a claim on one of the mesh's own seats is judged fully at registration, and a seat declared by a module not given here reads as unknown. Identities judged on a 6-character machine name, against the bounds of the providers given here
judging 2 module(s) changed against 4 machine(s), as the snapshot of 2026-10-13T11:13:29Z says they run
composing every machine as the mesh is
the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued
the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued
composing every machine with the change
the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued
the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued
merge gate: PASS — every machine composes with the change as it did without (4 of 4 compose)
judged by controller development build against the facts of 2026-10-13T11:13:29Z

modules the change moves:
  - gitea (changed)
  - lab (changed)

machines:
  - a machine (f35): composes
  - holds mesh-dns-resolver (idt): composes
  - holds git, holds mesh-artifact-store, holds mesh-broker, holds mesh-catalog, holds mesh-delivery, holds mesh-dns-resolver, holds mesh-store, holds mesh-vault, holds npm-package-registry, the control node, the hub (ygcyr): composes; the change adds 1 resource(s) and removes 0 (+file:gitea.grant-npm-package-registry-yvbpsm.lab)
  - a machine (yvbpsm): composes; the change adds 2 resource(s) and removes 0 (+file:lab.bound-npm-package-registry, +file:lab.secret-npm-package-registry)

a merge would rebuild 2 module(s) in 1 tier(s): gitea, lab
--- its merge-check.sh (go toolchain)
ok  	git.novox.be/novox/mesh-catalog/checks/words	0.002s
words: 12 retired words and 70 daemons' lines, none in the 46320 strings of 716 files
ok  	git.novox.be/novox/mesh-catalog/checks/agenthome	0.012s
agent-home: no archive and no file written into under the agent's home
ok  	git.novox.be/novox/mesh-catalog/checks/secrets	0.012s
secrets: no setting can replace a vault secret in a mergeable file (1 known, nested)
ok  	git.novox.be/novox/mesh-catalog/checks/paths	0.005s
paths: no module names another's state on its machine (3 known, listed to go)
long-running resources without health: 66, as kept
ok  	git.novox.be/novox/mesh-catalog/checks/deps	0.212s
testing modules/gitea
ok  	gitea/cmd/forge	1.406s
ok  	gitea/cmd/npm-registry	1.747s
?   	gitea/internal/forgehttp	[no test files]
modules/lab is TypeScript: merge-check-typescript.sh type-checks and tests it
--- its merge-check-typescript.sh (typescript toolchain)
type-checking modules/gitea (TypeScript)
testing modules/gitea (TypeScript)
✔ a pull request opened after the margin is looked at, by its own update time (10.12756ms)
✔ every open pull request is read with what its base requires and what its head has (gitea_open_pulls) (45.457514ms)
✔ a pull request or issue number that is not one is refused before the forge is asked (1.108956ms)
✔ a merged pull request whose branch was deleted is announced with its branch, not its pull ref (7.895742ms)
✔ the newest status of each context is kept, with what it said, when and by whom (86.894713ms)
✔ a commit merges only when every required status is a success; a warning blocks (0.644452ms)
✔ no rule requires nothing; a rule that cannot be read says nothing, never yes (0.307248ms)
✔ a commit is contained in another when the compare finds nothing on it the other lacks (0.825994ms)
✔ a note line is appended once, as the forge's user, in its own repository (34.061987ms)
✔ a note that cannot be written is said, never read as written (0.30834ms)
✔ one view per pull request, found by its marker; only the mesh's statuses (0.468091ms)
✔ a build machine taking the check is said on the head: building on which machine, since the local time (59.07054ms)
✔ the verdict heard while a 'building' write is in flight lands last and stays (5.863099ms)
[gitea] novox/hq@a6b08de8: the verdict of build-1791680941000000000 is an older run's than the check now pending; not written
✔ the verdict written while a start's read of the forge is in flight stays the newest status (0.865237ms)
✔ the verdict heard while a 'building' write still waits its turn: the 'building' is never written (0.458993ms)
✔ a start heard after the verdict writes nothing (0.524797ms)
✔ a start from before the check now pending (a run before a recheck, the stream's history) writes nothing (0.411744ms)
✔ an old run's verdict redelivered after a recheck's pending is not written over it (0.730364ms)
[gitea] novox/hq@a6b08de8: the verdict of build-1791680941000000000 is an older run's than the check the forge holds pending; not written
[gitea] novox/hq@a6b08de8: the verdict of build-1791680941000000000 is an older run's than the check now pending; not written
✔ an old run's verdict in flight when the recheck comes lands before the recheck's pending (1.466589ms)
✔ a rechecked head says where its new run is: building on which machine (0.599227ms)
✔ the recheck's own verdict is written, even asked a little before the pending by another machine's clock (0.476196ms)
✔ after a restart, an old run's verdict is weighed against the check the forge's history holds open (0.413818ms)
✔ a recheck the forge does not take fails its caller, and the head is as it was (0.409971ms)
✔ the status tool writes the merge check's pending through the writer, and the mesh's other statuses as they were (3.644365ms)
✔ when a check was asked is read from its id; the opening of the check now pending from the gate's history (0.169268ms)
✔ a head this process did not announce (it restarted) is said only while the forge holds its gate pending (0.244691ms)
✔ a repository as the mesh clones it is told from another (0.199765ms)
✔ gitea_api refuses the forge's administration, a branch's protection and the merge check's status, and sends nothing (5.13527ms)
✔ gitea_api refuses a file written to the default branch or one a rule guards, and writes one on a branch of its own (43.294053ms)
✔ a protection rule covers a branch as the forge decides it: classes, alternatives, a plain name in any case (issue 539) (17.029666ms)
✔ gitea_api still writes what an author writes (5.242711ms)
✔ gitea_branch_protection_set only strengthens (13.667572ms)
✔ gitea_merge_pull_request merges only a head whose required statuses all succeeded, and only that head (39.585547ms)
✔ gitea_merge_pull_request refuses a verdict judged against an earlier trunk, and asks the check once (138.645954ms)
✔ gitea_merge_pull_request merges only the head it is named, and refuses one that is not the head (16.677102ms)
✔ gitea_merge_pull_request is loud when the forge merged a head other than the one it was handed (12.340295ms)
✔ gitea_merge_pull_request says the merge happened when reading back what landed fails (23.771277ms)
✔ gitea_merge_pull_request reads back a fast-forward, and says it cannot read back a squash or a rebase (54.186043ms)
✔ gitea_delete_repo deletes only the tools' own user's repository, unguarded, untouched for 30 days, named in full (22.92728ms)
✔ gitea_api sends the path it judged, and refuses moving a pull request's base (3.920074ms)
✔ gitea_merge_pull_request merges only into a branch whose protection requires the checks (6.513844ms)
✔ a rule named for a branch is not made weaker than the glob rule that guards it now (11.89761ms)
✔ a repository owner or name is never another path (0.199356ms)
✔ the judges, without a forge (0.342755ms)
✔ gitea_api never acts as another user: sudo, in any case, and any query key it does not send are refused (2.325636ms)
✔ gitea_api never approves a pull request nor requests changes: those are the operator's (2.197744ms)
✔ no tool's caller text becomes another path or another user: `..` and `?sudo=` are refused before the forge (3.662439ms)
✔ every page of a pull request's files is read, though the forge caps a page at fifty (24.175989ms)
✔ a pass asks only the repositories that moved since the last look, every one before the first (0.363124ms)
✔ the directories above a merge's files that hold a module at the commit are said, the root never (10.774919ms)
✔ a lookup the forge refuses is thrown, not read as no module (3.254743ms)
✔ a renamed file is said under its old name too, as gone (novox/hq ADR 0267) (3.885339ms)
✔ a new head beyond the newest 20 open pull requests is announced, exactly once (35.317538ms)
✔ a pass pages until it reaches back past its floor, and no further (17.563709ms)
✔ the statuses asked for replace the rule's, and an empty list requires none (5.538548ms)
✔ a new rule refuses direct pushes unless asked; an administrator's override only when said (0.260189ms)
✔ each open pull request's new head is announced once, and nothing closed or merged (9.20732ms)
✔ a verdict is the head commit's status; an error is the forge's error, never a success (0.951029ms)
✔ each layer is its own status: the gate with the modules it judged, the repository's own check beside it (0.734581ms)
✔ no verdict sets warning on a required check; only a person's decision fails (0.983921ms)
✔ a commit status is set on the commit, under the merge check's context (32.679436ms)
✔ a change plan is the gate's result: said on the status and, when it builds something, as a comment (0.420971ms)
✔ a head announced is pending in the build queue, since the local time it was announced (0.259177ms)
✔ the vault's token is used, a setting of it is ignored and said once, without its value (1.80244ms)
✔ a consumer that asks nothing, or write, publishes: the package team (1.090791ms)
✔ a consumer that asks to read joins the readers, who write no package (0.347583ms)
✔ a reader is made, put on the readers team, and taken off the package team (0.373473ms)
✔ a publisher is made and put on the package team, as before (0.223791ms)
✔ first start: mints with the admin account, keeps the token at 0600, asks for the tools' scopes only (30.95486ms)
✔ second start: reuses the kept token, mints nothing (13.720682ms)
✔ the forge rejects the kept token (its data was restored): minted afresh, once, and the call goes through (17.758617ms)
✔ a token kept with write:admin by an earlier build is minted again without it at the next start, and the forge drops the old one (22.221712ms)
✔ a kept token lacking a scope the tools need: the forge refuses the call for the scope, the token is re-minted with the whole list, and the call goes through (18.358404ms)
✔ the kept file is gone but the forge still holds a token by that name: replaced, not refused (16.431611ms)
✔ concurrent first calls share one mint (9.936903ms)
✔ the admin account is refused: said plainly, nothing kept, and the next call fails the same way rather than crashing (10.634125ms)
✔ one process shares one source per kept file — the watcher and the tools never renew against each other (0.83962ms)
✔ a second process finds the token the first renewed, and reuses it instead of minting over it (18.424098ms)
✔ a configured token wins, and is reported rather than minted over when the forge rejects it (2.278968ms)
✔ nothing to mint with and no token: the client says what is missing (0.181201ms)
[gitea] no tools — no Gitea token, and nothing to mint one with — set MESH_GITEA_TOKEN, or MESH_GITEA_ADMIN_USER, MESH_GITEA_ADMIN_PASSWORD_FILE, MESH_GITEA_STATE_DIR
[gitea] no token kept — minting one
[gitea] the forge already holds a token named "mesh-tools" — replacing it
[gitea] minted a token for "mesh-admin" (write:repository, write:issue, read:user), kept at /tmp/gitea-QdU5kU/state/token
✔ the tools register once there is a way to a token, and the first call mints it (7.013613ms)
[gitea] no token kept — minting one
[gitea] the forge already holds a token named "mesh-tools" — replacing it
[gitea] minted a token for "mesh-admin" (write:repository, write:issue, read:user), kept at /tmp/gitea-KExOIq/state/token
✔ a pull request can be closed, read and cleaned up through the tools (18.316556ms)
[gitea] novox/mesh-host's main moved from a2c2c35bbbbb to d28ca95ccccc: 25 open pull request(s) into it put out of date, nothing run (novox/hq ADR 0323)
[gitea] novox/mesh-host's main moved from d28ca95ccccc to ffffffffffff: 0 open pull request(s) into it put out of date, nothing run (novox/hq ADR 0323)
[gitea] novox/mesh-host: whether a trunk moved could not be weighed, so it is weighed again on the next pass — the forge is away
[gitea] novox/mesh-host's main moved from a2c2c35bbbbb to d28ca95ccccc: 0 open pull request(s) into it put out of date, nothing run (novox/hq ADR 0323)
✔ both statuses say the head and the trunk commit the verdict judged, first, whatever the summary's length (1.280098ms)
✔ a trunk's move puts an open head's merge check out of date, naming both commits, unless a check is on its way (0.758216ms)
✔ a push to a trunk puts every open pull request into it out of date — twenty-five of them — and none into another (2.834822ms)
✔ a trunk that cannot be read is weighed again on the next pass, never recorded half (0.287291ms)
✔ the trunk's move takes its turn after a verdict in flight, and weighs what the forge holds then (0.362813ms)
✔ a verdict judged against a trunk newer than the pass's first read is not put out of date (0.209945ms)
✔ a verdict that landed out of date keeps its account on the pull request (0.20186ms)
ℹ tests 89
ℹ suites 0
ℹ pass 89
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 634.125758
type-checking modules/lab (TypeScript)
testing modules/lab (TypeScript)
✔ a checkout with a lock file at its root is installed there (2.065866ms)
✔ a checkout whose package lives one directory down is installed there, as mesh-tools' node-tools (0.725024ms)
✔ a package.json with no lock file is named, never installed (0.436491ms)
✔ a run installs and builds mesh-tools in node-tools, where its lock file is (7.169388ms)
✔ a run installs a checkout with its lock file at the root there, and builds only when asked (4.317031ms)
✔ a run fails at its setup, naming the checkout, when nothing of it can be installed (10.428387ms)
✔ a run checks out mesh-tools-go and says where its checkouts are (0.881147ms)
✔ the forge credential is the bound account and its sealed secret, for the forge's own origin (0.614245ms)
✔ a run clones through git's credential store, and its script carries no secret (0.905173ms)
✔ git presents the stored credential to the forge, and only when one is given (9.599468ms)
✔ a stopped script removes the credential, whatever ends it (10.878734ms)
✔ the script removes the credential as soon as its clones are done (0.433455ms)
✔ credentials a crashed run left are removed, but not the running one's (1.353115ms)
✔ the lab asks the package registry for read only (0.423797ms)
ℹ tests 14
ℹ suites 0
ℹ pass 14
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 132.044655
**Merge check** at `8d8dcd5e` Judged: head `8d8dcd5ebb86` merged into trunk `cd239283207a`; read beside it: mesh-controller `584aa2d7d7a5`, mesh-controller-main `584aa2d7d7a5`, mesh-host `7a41e120635b`, mesh-tools `954e1a53eef9` - `mesh/merge-gate`: **PASS** — every machine composes with the change as it did without (4 of 4 compose) (modules: gitea, lab) - `mesh/repo-check`: **PASS** — its merge-check.sh passed, each part in its toolchain: merge-check.sh (go), merge-check-typescript.sh (typescript) **Delivery plan** — builds gitea, lab → novox, shanks; no bus step - tier 0: gitea, lab - novox: receives gitea - shanks: receives lab - gitea provides npm-package-registry, git: its consumers are sent again after it - gitea keeps data (ADR 0233): what it holds is backed up before it moves - lab keeps data (ADR 0233): what it holds is backed up before it moves - grants step: if this changes what the bus's user list says (a new tool, subject or user), novox is sent that list alone, every build there kept, before lab is judged on its first machine Run by the build seat on ace as `build-1791892909885250099` (`builds --log build-1791892909885250099`). ``` --- the gate: gitea, lab gitea: ok, keeps data (valuable); WARNING: server stay(s) up and say(s) not how it is ready — judged by liveness alone, refused from 2026-11-18 (ADR 0240 rule 8) lab: ok, keeps work (cache); WARNING: runtime-env ask(s) for a setting and do(es) not say whether it is trusted, so it counts as trusted: set at the terminal alone; say "trusted" false where nothing trusts it (novox/hq issue 339) long-running resources without health: 1 files asking for a setting without saying whether it is trusted: 1 2 manifest(s) checked. Judged against the seats this binary carries; a claim on one of the mesh's own seats is judged fully at registration, and a seat declared by a module not given here reads as unknown. Identities judged on a 6-character machine name, against the bounds of the providers given here judging 2 module(s) changed against 4 machine(s), as the snapshot of 2026-10-13T11:13:29Z says they run composing every machine as the mesh is the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued composing every machine with the change the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued the bus's user list leaves out 5 user(s) the mesh has minted no credential for: controller, node.f35, node.idt, node.ygcyr, node.yvbpsm. Each is a user that cannot connect until one is issued merge gate: PASS — every machine composes with the change as it did without (4 of 4 compose) judged by controller development build against the facts of 2026-10-13T11:13:29Z modules the change moves: - gitea (changed) - lab (changed) machines: - a machine (f35): composes - holds mesh-dns-resolver (idt): composes - holds git, holds mesh-artifact-store, holds mesh-broker, holds mesh-catalog, holds mesh-delivery, holds mesh-dns-resolver, holds mesh-store, holds mesh-vault, holds npm-package-registry, the control node, the hub (ygcyr): composes; the change adds 1 resource(s) and removes 0 (+file:gitea.grant-npm-package-registry-yvbpsm.lab) - a machine (yvbpsm): composes; the change adds 2 resource(s) and removes 0 (+file:lab.bound-npm-package-registry, +file:lab.secret-npm-package-registry) a merge would rebuild 2 module(s) in 1 tier(s): gitea, lab --- its merge-check.sh (go toolchain) ok git.novox.be/novox/mesh-catalog/checks/words 0.002s words: 12 retired words and 70 daemons' lines, none in the 46320 strings of 716 files ok git.novox.be/novox/mesh-catalog/checks/agenthome 0.012s agent-home: no archive and no file written into under the agent's home ok git.novox.be/novox/mesh-catalog/checks/secrets 0.012s secrets: no setting can replace a vault secret in a mergeable file (1 known, nested) ok git.novox.be/novox/mesh-catalog/checks/paths 0.005s paths: no module names another's state on its machine (3 known, listed to go) long-running resources without health: 66, as kept ok git.novox.be/novox/mesh-catalog/checks/deps 0.212s testing modules/gitea ok gitea/cmd/forge 1.406s ok gitea/cmd/npm-registry 1.747s ? gitea/internal/forgehttp [no test files] modules/lab is TypeScript: merge-check-typescript.sh type-checks and tests it --- its merge-check-typescript.sh (typescript toolchain) type-checking modules/gitea (TypeScript) testing modules/gitea (TypeScript) ✔ a pull request opened after the margin is looked at, by its own update time (10.12756ms) ✔ every open pull request is read with what its base requires and what its head has (gitea_open_pulls) (45.457514ms) ✔ a pull request or issue number that is not one is refused before the forge is asked (1.108956ms) ✔ a merged pull request whose branch was deleted is announced with its branch, not its pull ref (7.895742ms) ✔ the newest status of each context is kept, with what it said, when and by whom (86.894713ms) ✔ a commit merges only when every required status is a success; a warning blocks (0.644452ms) ✔ no rule requires nothing; a rule that cannot be read says nothing, never yes (0.307248ms) ✔ a commit is contained in another when the compare finds nothing on it the other lacks (0.825994ms) ✔ a note line is appended once, as the forge's user, in its own repository (34.061987ms) ✔ a note that cannot be written is said, never read as written (0.30834ms) ✔ one view per pull request, found by its marker; only the mesh's statuses (0.468091ms) ✔ a build machine taking the check is said on the head: building on which machine, since the local time (59.07054ms) ✔ the verdict heard while a 'building' write is in flight lands last and stays (5.863099ms) [gitea] novox/hq@a6b08de8: the verdict of build-1791680941000000000 is an older run's than the check now pending; not written ✔ the verdict written while a start's read of the forge is in flight stays the newest status (0.865237ms) ✔ the verdict heard while a 'building' write still waits its turn: the 'building' is never written (0.458993ms) ✔ a start heard after the verdict writes nothing (0.524797ms) ✔ a start from before the check now pending (a run before a recheck, the stream's history) writes nothing (0.411744ms) ✔ an old run's verdict redelivered after a recheck's pending is not written over it (0.730364ms) [gitea] novox/hq@a6b08de8: the verdict of build-1791680941000000000 is an older run's than the check the forge holds pending; not written [gitea] novox/hq@a6b08de8: the verdict of build-1791680941000000000 is an older run's than the check now pending; not written ✔ an old run's verdict in flight when the recheck comes lands before the recheck's pending (1.466589ms) ✔ a rechecked head says where its new run is: building on which machine (0.599227ms) ✔ the recheck's own verdict is written, even asked a little before the pending by another machine's clock (0.476196ms) ✔ after a restart, an old run's verdict is weighed against the check the forge's history holds open (0.413818ms) ✔ a recheck the forge does not take fails its caller, and the head is as it was (0.409971ms) ✔ the status tool writes the merge check's pending through the writer, and the mesh's other statuses as they were (3.644365ms) ✔ when a check was asked is read from its id; the opening of the check now pending from the gate's history (0.169268ms) ✔ a head this process did not announce (it restarted) is said only while the forge holds its gate pending (0.244691ms) ✔ a repository as the mesh clones it is told from another (0.199765ms) ✔ gitea_api refuses the forge's administration, a branch's protection and the merge check's status, and sends nothing (5.13527ms) ✔ gitea_api refuses a file written to the default branch or one a rule guards, and writes one on a branch of its own (43.294053ms) ✔ a protection rule covers a branch as the forge decides it: classes, alternatives, a plain name in any case (issue 539) (17.029666ms) ✔ gitea_api still writes what an author writes (5.242711ms) ✔ gitea_branch_protection_set only strengthens (13.667572ms) ✔ gitea_merge_pull_request merges only a head whose required statuses all succeeded, and only that head (39.585547ms) ✔ gitea_merge_pull_request refuses a verdict judged against an earlier trunk, and asks the check once (138.645954ms) ✔ gitea_merge_pull_request merges only the head it is named, and refuses one that is not the head (16.677102ms) ✔ gitea_merge_pull_request is loud when the forge merged a head other than the one it was handed (12.340295ms) ✔ gitea_merge_pull_request says the merge happened when reading back what landed fails (23.771277ms) ✔ gitea_merge_pull_request reads back a fast-forward, and says it cannot read back a squash or a rebase (54.186043ms) ✔ gitea_delete_repo deletes only the tools' own user's repository, unguarded, untouched for 30 days, named in full (22.92728ms) ✔ gitea_api sends the path it judged, and refuses moving a pull request's base (3.920074ms) ✔ gitea_merge_pull_request merges only into a branch whose protection requires the checks (6.513844ms) ✔ a rule named for a branch is not made weaker than the glob rule that guards it now (11.89761ms) ✔ a repository owner or name is never another path (0.199356ms) ✔ the judges, without a forge (0.342755ms) ✔ gitea_api never acts as another user: sudo, in any case, and any query key it does not send are refused (2.325636ms) ✔ gitea_api never approves a pull request nor requests changes: those are the operator's (2.197744ms) ✔ no tool's caller text becomes another path or another user: `..` and `?sudo=` are refused before the forge (3.662439ms) ✔ every page of a pull request's files is read, though the forge caps a page at fifty (24.175989ms) ✔ a pass asks only the repositories that moved since the last look, every one before the first (0.363124ms) ✔ the directories above a merge's files that hold a module at the commit are said, the root never (10.774919ms) ✔ a lookup the forge refuses is thrown, not read as no module (3.254743ms) ✔ a renamed file is said under its old name too, as gone (novox/hq ADR 0267) (3.885339ms) ✔ a new head beyond the newest 20 open pull requests is announced, exactly once (35.317538ms) ✔ a pass pages until it reaches back past its floor, and no further (17.563709ms) ✔ the statuses asked for replace the rule's, and an empty list requires none (5.538548ms) ✔ a new rule refuses direct pushes unless asked; an administrator's override only when said (0.260189ms) ✔ each open pull request's new head is announced once, and nothing closed or merged (9.20732ms) ✔ a verdict is the head commit's status; an error is the forge's error, never a success (0.951029ms) ✔ each layer is its own status: the gate with the modules it judged, the repository's own check beside it (0.734581ms) ✔ no verdict sets warning on a required check; only a person's decision fails (0.983921ms) ✔ a commit status is set on the commit, under the merge check's context (32.679436ms) ✔ a change plan is the gate's result: said on the status and, when it builds something, as a comment (0.420971ms) ✔ a head announced is pending in the build queue, since the local time it was announced (0.259177ms) ✔ the vault's token is used, a setting of it is ignored and said once, without its value (1.80244ms) ✔ a consumer that asks nothing, or write, publishes: the package team (1.090791ms) ✔ a consumer that asks to read joins the readers, who write no package (0.347583ms) ✔ a reader is made, put on the readers team, and taken off the package team (0.373473ms) ✔ a publisher is made and put on the package team, as before (0.223791ms) ✔ first start: mints with the admin account, keeps the token at 0600, asks for the tools' scopes only (30.95486ms) ✔ second start: reuses the kept token, mints nothing (13.720682ms) ✔ the forge rejects the kept token (its data was restored): minted afresh, once, and the call goes through (17.758617ms) ✔ a token kept with write:admin by an earlier build is minted again without it at the next start, and the forge drops the old one (22.221712ms) ✔ a kept token lacking a scope the tools need: the forge refuses the call for the scope, the token is re-minted with the whole list, and the call goes through (18.358404ms) ✔ the kept file is gone but the forge still holds a token by that name: replaced, not refused (16.431611ms) ✔ concurrent first calls share one mint (9.936903ms) ✔ the admin account is refused: said plainly, nothing kept, and the next call fails the same way rather than crashing (10.634125ms) ✔ one process shares one source per kept file — the watcher and the tools never renew against each other (0.83962ms) ✔ a second process finds the token the first renewed, and reuses it instead of minting over it (18.424098ms) ✔ a configured token wins, and is reported rather than minted over when the forge rejects it (2.278968ms) ✔ nothing to mint with and no token: the client says what is missing (0.181201ms) [gitea] no tools — no Gitea token, and nothing to mint one with — set MESH_GITEA_TOKEN, or MESH_GITEA_ADMIN_USER, MESH_GITEA_ADMIN_PASSWORD_FILE, MESH_GITEA_STATE_DIR [gitea] no token kept — minting one [gitea] the forge already holds a token named "mesh-tools" — replacing it [gitea] minted a token for "mesh-admin" (write:repository, write:issue, read:user), kept at /tmp/gitea-QdU5kU/state/token ✔ the tools register once there is a way to a token, and the first call mints it (7.013613ms) [gitea] no token kept — minting one [gitea] the forge already holds a token named "mesh-tools" — replacing it [gitea] minted a token for "mesh-admin" (write:repository, write:issue, read:user), kept at /tmp/gitea-KExOIq/state/token ✔ a pull request can be closed, read and cleaned up through the tools (18.316556ms) [gitea] novox/mesh-host's main moved from a2c2c35bbbbb to d28ca95ccccc: 25 open pull request(s) into it put out of date, nothing run (novox/hq ADR 0323) [gitea] novox/mesh-host's main moved from d28ca95ccccc to ffffffffffff: 0 open pull request(s) into it put out of date, nothing run (novox/hq ADR 0323) [gitea] novox/mesh-host: whether a trunk moved could not be weighed, so it is weighed again on the next pass — the forge is away [gitea] novox/mesh-host's main moved from a2c2c35bbbbb to d28ca95ccccc: 0 open pull request(s) into it put out of date, nothing run (novox/hq ADR 0323) ✔ both statuses say the head and the trunk commit the verdict judged, first, whatever the summary's length (1.280098ms) ✔ a trunk's move puts an open head's merge check out of date, naming both commits, unless a check is on its way (0.758216ms) ✔ a push to a trunk puts every open pull request into it out of date — twenty-five of them — and none into another (2.834822ms) ✔ a trunk that cannot be read is weighed again on the next pass, never recorded half (0.287291ms) ✔ the trunk's move takes its turn after a verdict in flight, and weighs what the forge holds then (0.362813ms) ✔ a verdict judged against a trunk newer than the pass's first read is not put out of date (0.209945ms) ✔ a verdict that landed out of date keeps its account on the pull request (0.20186ms) ℹ tests 89 ℹ suites 0 ℹ pass 89 ℹ fail 0 ℹ cancelled 0 ℹ skipped 0 ℹ todo 0 ℹ duration_ms 634.125758 type-checking modules/lab (TypeScript) testing modules/lab (TypeScript) ✔ a checkout with a lock file at its root is installed there (2.065866ms) ✔ a checkout whose package lives one directory down is installed there, as mesh-tools' node-tools (0.725024ms) ✔ a package.json with no lock file is named, never installed (0.436491ms) ✔ a run installs and builds mesh-tools in node-tools, where its lock file is (7.169388ms) ✔ a run installs a checkout with its lock file at the root there, and builds only when asked (4.317031ms) ✔ a run fails at its setup, naming the checkout, when nothing of it can be installed (10.428387ms) ✔ a run checks out mesh-tools-go and says where its checkouts are (0.881147ms) ✔ the forge credential is the bound account and its sealed secret, for the forge's own origin (0.614245ms) ✔ a run clones through git's credential store, and its script carries no secret (0.905173ms) ✔ git presents the stored credential to the forge, and only when one is given (9.599468ms) ✔ a stopped script removes the credential, whatever ends it (10.878734ms) ✔ the script removes the credential as soon as its clones are done (0.433455ms) ✔ credentials a crashed run left are removed, but not the running one's (1.353115ms) ✔ the lab asks the package registry for read only (0.423797ms) ℹ tests 14 ℹ suites 0 ℹ pass 14 ℹ fail 0 ℹ cancelled 0 ℹ skipped 0 ℹ todo 0 ℹ duration_ms 132.044655 ```
mesh-admin merged commit 0d723484a8 into main 2026-10-13 12:07:06 +00:00
mesh-admin deleted branch fix/624-lab-reads-the-forge-with-its-credential 2026-10-13 12:07:06 +00:00
Sign in to join this conversation.
No Reviewers
2 Participants
Notifications
Due Date
No due date set.
Dependencies

No dependencies set.

Reference: novox/mesh-catalog#272