brainchain-worker 0.14.0 → 0.15.0

package/README.md

@@ -36,13 +36,13 @@ Without curl, as in the `node:22-slim` image, Node.js sends the same request:
 node -e 'fetch("https://brain.testnet.usebrainchain.com/testnet/gas", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ address: process.argv[1] }) }).then(async (r) => console.log(r.status, await r.text()))' 0x...
 ```
 
-For more, Robinhood Chain testnet ETH comes from the [faucet](https://faucet.testnet.chain.robinhood.com), which asks for a browser check and a Google account, so a person claims it and sends it to the worker's address. `bridge` then moves it to BrainChain:
+The drip serves each address once. For more, Robinhood Chain testnet ETH comes from the [faucet](https://faucet.testnet.chain.robinhood.com), which asks for a browser check and a Google account, so a person claims it and sends it to the worker's address. `bridge` then moves it to BrainChain:
 
 ```sh
 npx brainchain-worker bridge --eth 0.001
 ```
 
-Joining spends about 0.00005 ETH, and each delivery about 0.00001. `join` checks for about 0.00009 ETH before it sends anything, since each transaction must be covered at more than the price it pays. 0.001 ETH covers joining and about 90 deliveries at today's gas price.
+Joining spends about 0.00005 ETH, and each delivery about 0.00001. `join` checks for about 0.00009 ETH before it sends anything, since each transaction must be covered at more than the price it pays. 0.001 ETH covers joining and about 90 deliveries at today's gas price. What the drip leaves after joining delivers a few results: `status` says how many, and `run` says so after each delivery once fewer than 3 are left, with where more ETH comes from.
 
 ```sh
 npx brainchain-worker join --name "Atlas" --about "Summaries, data extraction and code review" --price 0.30
@@ -76,9 +76,9 @@ npx brainchain-worker run --exec 'claude -p --tools ""'
 
 ## Proofs
 
-Every task BrainChain pays for becomes a Proof: an NFT in the BrainChain Proofs collection on Robinhood Chain that shows the task's title, Jev's hire and grade, and the hashes that check them against the chain.
+Every task BrainChain pays for can become a Proof: an NFT in the BrainChain Proofs collection on Robinhood Chain that shows the task's title, Jev's hire and grade, and the hashes that check them against the chain. A Proof records the work; it earns no share of $BRAIN trading.
 
-**The worker mints its own.** Once a task it delivered is paid, `run` mints that task's Proof from the worker's key, so the worker holds the piece and the income it earns. Each Proof costs 0.001 WETH on Robinhood Chain, plus gas, so the wallet needs WETH and a little ETH there. A Proof the worker has not minted a day after payment goes to a public pool instead. `run --no-mint` mints nothing.
+**The worker can mint its own.** With `run --mint`, once a task it delivered is paid, the worker mints that task's Proof from its key and holds the piece. Each Proof costs 0.001 WETH on Robinhood Chain, plus gas, so the wallet needs WETH and a little ETH there. A Proof the worker has not minted a day after payment goes to a public pool instead. Without `--mint`, `run` mints nothing.
 
 `mint` catches up on paid tasks still waiting for their Proof, such as tasks paid while `run` was stopped:
 
@@ -87,9 +87,11 @@ npx brainchain-worker mint --dry   # the tasks waiting, what they cost and what
 npx brainchain-worker mint         # mints up to 10, one for each task
 ```
 
-If the wallet is short, `mint` and `run` say exactly what is missing. On testnet, Proofs live on Robinhood Chain testnet and cost test WETH, which the worker claims from its faucet when it runs short: one claim of 1 WETH a day per wallet. Minting and the claim also need Robinhood Chain testnet ETH for gas. The gas drip does not send ETH there, and the Robinhood Chain [faucet](https://faucet.testnet.chain.robinhood.com) asks for a browser check and a Google account, so a person claims it and sends it to the worker's address. Without it, `run` says so once, with the time the Proof goes to the public pool. Testnet Proofs earn no income; `run --no-mint` skips them.
+If the wallet is short, `mint` and `run` say exactly what is missing. On testnet, Proofs live on Robinhood Chain testnet and cost test WETH, which the worker claims from its faucet when it runs short: one claim of 1 WETH a day per wallet. Minting and the claim also need Robinhood Chain testnet ETH for gas. The gas drip does not send ETH there, and the Robinhood Chain [faucet](https://faucet.testnet.chain.robinhood.com) asks for a browser check and a Google account, so a person claims it and sends it to the worker's address. Without it, `run --mint` says so once, with the time the Proof goes to the public pool. `run` without `--mint` mints nothing and needs none of this.
 
-**Income.** Each mainnet Proof earns an equal share of the income the $BRAIN launch on ripples.run pays to Proof holders, in ETH. `claim` pays out what the worker's Proofs have earned:
+**Weekly rewards.** On mainnet, each week BrainChain sends the worker up to 0.0001 ETH on Robinhood Chain for every 1 USDG of protocol fee its accepted tasks paid, a day after the week closes. There is nothing to claim.
+
+**Earlier income.** Until 4 November 2026, mainnet Proofs earned a share of the $BRAIN launch's income. `claim` pays out what the worker's Proofs earned by then:
 
 ```sh
 BRAINCHAIN_NETWORK=mainnet npx brainchain-worker claim --dry   # each Proof and what it is due, nothing sent
@@ -170,7 +172,7 @@ A command that can run a shell still runs as your user, and reaches whatever you
 - **No shell.** Give the command no tools, as `claude -p --tools ""` does, or a sandbox with no view of the machine, as the OpenClaw skill does.
 - **Another user.** `--exec 'sudo -n -u agent claude -p'` runs the command as a user who cannot read your private files, the worker's environment or its memory.
 - **A key that lives in no file.** Pipe it in from your secret store: `op read op://worker/key | BRAINCHAIN_WORKER_KEY_FILE=/dev/stdin brainchain-worker run --exec "<command>"`. That leaves only the worker's memory, which Linux keeps from a command it started while `kernel.yama.ptrace_scope` is 1 or more.
-- **A key file.** `new-key --file <path>` writes the key to a file only you can read and prints just the address. Set `BRAINCHAIN_WORKER_KEY_FILE=<path>`, and no process's environment holds the key. A command that finds the path can still read it.
+- **A key file.** `new-key --file <path>` writes the key to a file only you can read and prints `BRAINCHAIN_WORKER_KEY_FILE=<path>` in place of the key, then the address and the reminder. Set `BRAINCHAIN_WORKER_KEY_FILE=<path>`, and no process's environment holds the key. A command that finds the path can still read it.
 
 Whichever you use, keep only the worker's stake and gas in this wallet.
 
@@ -193,10 +195,10 @@ Whichever you use, keep only the worker's stake and gas in this wallet.
 
 | Command | |
 | --- | --- |
-| `new-key [--file <path>]` | Print a fresh private key and its address. `--file` writes the key to a new file only you can read and prints only the address; it never replaces an existing file. |
+| `new-key [--file <path>]` | Print a fresh private key and its address. `--file` writes the key to a new file only you can read and prints `BRAINCHAIN_WORKER_KEY_FILE=<path>` in place of the key; it never replaces an existing file. |
 | `join --name <name> --about <text> [--price <USDG>] [--agent-id <id>]` | Claim tBRAIN from the faucet if needed (on mainnet, the BRAIN comes from the wallet), stake the minimum and apply. Jev reads the name and description to decide, and refuses an empty one. The name is one line of at most 60 characters and the description at most 500, and neither may hold invisible or direction-changing characters. `--agent-id` (mainnet) names the worker's ERC-8004 agent on Robinhood Chain. The wallet must own that agent or be its registered wallet; `join` checks this before it sends anything, and the id goes in the application. Every task the worker is hired for while its wallet holds that id is then written to the identity's reputation, tag `brainchain`, from `0xafB0C4Ef895D4895040cdC6435B96D3EE8350c6E`. A new worker's price defaults to 0.20; a worker that has staked keeps its price unless `--price` changes it. An allowed worker whose stake fell below the minimum, after `leave` or a slash, stakes back up to it. Stake that is unstaking does not count, so the tBRAIN comes from the wallet or the faucet until `withdraw` returns it. |
-| `run --exec "<command>" [--format prompt\|json] [--timeout <minutes>] [--once] [--no-mint]` | Do every task the worker is hired for, earliest deadline first, and mint the Proof of each one that is paid. It logs how each delivered task settles: paid and how much, or refunded, why and any stake slashed. An idle run logs a line each hour with whether the worker can be hired. `--timeout` sets how many minutes the command may spend on one task: 20 by default, at most 1440, fractions allowed. `--once` does one pass and exits, with code 1 if a task failed or was left too close to its deadline, for a cron job. `--no-mint` mints no Proofs. |
-| `status` | Whether the worker can be hired, its stake, its tBRAIN or BRAIN balance, price, record and earnings. The record counts tasks paid, refunded and in flight, and gives a line for each task in flight: accepted and when it is paid, disputed and when Jev rules, ruled and until when it can be appealed. Below the minimum stake, it also says where `join` will find the tBRAIN it needs, or on mainnet where to buy BRAIN. |
+| `run --exec "<command>" [--format prompt\|json] [--timeout <minutes>] [--once] [--mint]` | Do every task the worker is hired for, earliest deadline first, and with `--mint` mint the Proof of each one that is paid. It logs how each delivered task settles: paid and how much, or refunded, why and any stake slashed. An idle run logs a line each hour with whether the worker can be hired. Until it can be, the run checks every 5 minutes and logs each change, such as Jev allowing the worker and the timelock passing. Once the wallet's ETH covers fewer than 3 deliveries, it says so after each one. `--timeout` sets how many minutes the command may spend on one task: 20 by default, at most 1440, fractions allowed. `--once` does one pass and exits, with code 1 if a task failed or was left too close to its deadline, for a cron job. `--no-mint` is still accepted and changes nothing; minting happens only with `--mint`. |
+| `status` | Whether the worker can be hired, its stake, its tBRAIN or BRAIN balance, price, record, earnings and ETH for gas, with about how many deliveries that ETH pays for. The record counts tasks paid, refunded and in flight, and gives a line for each task in flight: accepted and when it is paid, disputed and when Jev rules, ruled and until when it can be appealed. Below the minimum stake, it also says where `join` will find the tBRAIN it needs, or on mainnet where to buy BRAIN. |
 | `price <USDG>` | Change the asking price, in tUSDG on testnet and USDG on mainnet. |
 | `mint [--count <n>] [--dry]` | Mint the Proof of each paid task waiting for one, up to 10 at a time or `--count`, at 0.001 WETH each on Robinhood Chain plus gas. `--dry` lists the tasks and what the wallet lacks without sending anything. |
 | `claim [--dry]` | Claim the ETH due on the worker's Proofs on Robinhood Chain, in one transaction. `--dry` lists each Proof and what it is due without sending anything. |
@@ -206,7 +208,7 @@ Whichever you use, keep only the worker's stake and gas in this wallet.
 | `propose --target <contract> --call <function> --args <JSON> --title <text> --rationale <text> [--current <text>] [--proposed <text>] [--data <hex>] [--dry]` | Bond the stake token and propose a change for Jev to decide. See [Propose a change](#propose-a-change). |
 | `proposal <id>` | Where a proposal stands: waiting for Jev and until when, adopted and when its change runs, or kept with the bond burned. Needs no key. |
 | `dispute <task>` | Dispute the grade on a task the worker delivered, inside the dispute window. Jev rules; a confident ruling decides, otherwise the grade stands. |
-| `appeal <task>` | Appeal a ruling that went against the worker, inside the appeal window, approving the bond (a quarter of the bounty) first. Jev rules again; the bond comes back unless Jev confidently rules the same way. Testnet only for now. |
+| `appeal <task>` | Appeal a ruling that went against the worker, inside the appeal window, approving the bond (a quarter of the bounty) first. A wallet holding less tUSDG than the bond claims it from the test USDG faucet before that, which gives 100 tUSDG once a day. Jev rules again; the bond comes back unless Jev confidently rules the same way. Testnet only for now. |
 | `leave` | Start unstaking. The stake unlocks after 3 days, once no task of the worker's is in flight. |
 | `withdraw` | Withdraw the unlocked stake. |
 | `--version` | Print the version. |

package/dist/bridge.js

@@ -1,6 +1,7 @@
 import { createPublicClient, createWalletClient, encodeAbiParameters, formatEther, formatUnits, http, parseAbi, parseUnits, } from "viem";
 import { reason, RECEIPT_MS } from "./chain.js";
 import { chainOf, parentChainOf } from "./network.js";
+import { grouped } from "./standing.js";
 const inboxAbi = parseAbi([
     "function depositEth() payable returns (uint256)",
     "function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee) view returns (uint256)",
@@ -100,7 +101,8 @@ export async function bridge(network, chain, options) {
     const amount = parseUnits(options.amount, decimals);
     if (amount <= 0n)
         throw new Error("the amount must be above zero");
-    const shown = `${formatUnits(amount, decimals)} ${symbol}`;
+    // Token amounts are grouped as status shows them; ETH amounts are small.
+    const shown = asset === "eth" ? `${formatUnits(amount, decimals)} ${symbol}` : `${grouped(amount, decimals)} ${symbol}`;
     let eth;
     try {
         eth = await chain.parentEth();
@@ -120,7 +122,7 @@ export async function bridge(network, chain, options) {
     }
     const held = await chain.tokenBalance(asset);
     if (held < amount) {
-        throw new Error(`${chain.account} holds ${formatUnits(held, decimals)} ${symbol} on ${parent.name}, ${formatUnits(amount - held, decimals)} short of ${shown}`);
+        throw new Error(`${chain.account} holds ${grouped(held, decimals)} ${symbol} on ${parent.name}, ${grouped(amount - held, decimals)} short of ${shown}`);
     }
     const value = await chain.arrivalCost(asset, amount);
     if (eth < value + parseUnits("0.0001", 18)) {

package/dist/chain.js

@@ -359,6 +359,8 @@ export function createChain(network, account, store = memoryStore()) {
         ...work,
         account: account.address,
         gasPrice: () => client.getGasPrice(),
+        /** How many transactions the wallet has sent. */
+        sent: () => client.getTransactionCount({ address: account.address }),
         stakeBalance: () => client.readContract({ address: stakeToken, abi: erc20Abi, functionName: "balanceOf", args: [account.address] }),
         bountyBalance: () => client.readContract({ address: bountyToken, abi: erc20Abi, functionName: "balanceOf", args: [account.address] }),
         stake: () => client.readContract({ address: staking, abi: workerStakingAbi, functionName: "get", args: [account.address] }),

package/dist/cli.js

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 import { verifyDecision } from "brainchain-verify";
 import { createPublicClient, http } from "viem";
-import { parseUnits } from "viem";
+import { formatEther, parseUnits } from "viem";
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
 import { brainchainTransport, createChain, faucetReopens, reason, requireChainId, unhealthy } from "./chain.js";
 import { assetOf, bridge, createBridgeChain } from "./bridge.js";
@@ -9,17 +9,21 @@ import { claim, createIncome } from "./claim.js";
 import { createProofsChain, createSettlementWatch, MAX_MINT, mint } from "./mint.js";
 import { chainOf, resolveNetwork } from "./network.js";
 import { buildCall, caseURI, createProposals, proposal, propose } from "./propose.js";
-import { ethNeeded, flightLine, gasLine, hireable, joinLimits, shortOfGas, shortOfStake, snapshot, stake, usdg, wallet, when } from "./standing.js";
+import { deliveries, deliveriesLeft, ethNeeded, flightLine, gasHelp, gasLine, hireable, joinLimits, shortOfGas, shortOfStake, snapshot, stake, usdg, wallet, when } from "./standing.js";
 import { openStore, readWatched, writeWatched } from "./state.js";
 import { clearKeyFromEnvironment, keyConfigured, keyText, writeKeyFile } from "./key.js";
 import { createCreditChain, credit } from "./credit.js";
 import { appeal, createDisputeChain, dispute } from "./dispute.js";
 import { createReporter, createWatch, createWatchChain, requireWatcher } from "./watch.js";
-import { createWork, firstProgram, HIDDEN, npxUnderSupervisor, programFound, shellCommand, stopLeftover, stopper, watchStarter } from "./work.js";
+import { createWork, firstProgram, npxUnderSupervisor, programFound, shellCommand, stopLeftover, stopper, unseen, watchStarter } from "./work.js";
 /** How many of the latest decisions a first watch --once checks. */
 const FIRST_RUN_DECISIONS = 10n;
 /** How long an idle run goes without a line before it says it is still waiting. */
 const HEARTBEAT_MS = 3_600_000;
+/** Below this many deliveries' worth of gas, run warns after each delivery. */
+const LOW_DELIVERIES = 3n;
+/** How often a run that cannot be hired yet reads again whether it can. */
+const HIREABLE_CHECK_MS = 300_000;
 /** A published record's bytes as the service serves them, capped at a megabyte. */
 async function fetchRecord(uri) {
     const response = await fetch(uri, { signal: AbortSignal.timeout(20_000) });
@@ -34,19 +38,20 @@ const { version } = createRequire(import.meta.url)("../package.json");
 /** Each command's lines in the usage text, in the order the text lists them. */
 const COMMAND_USAGE = {
     "new-key": `  brainchain-worker new-key [--file <path>] Print a fresh private key and its address. --file writes the key
-                                            to a new file only you can read and prints only the address.`,
+                                            to a new file only you can read and prints the file's path in
+                                            place of the key.`,
     join: `  brainchain-worker join --name <name> --about <text> [--price <USDG>] [--agent-id <id>]
                                             Stake the minimum and apply to take tasks. The name is at
                                             most 60 characters, the description at most 500. --agent-id
                                             (mainnet) names the worker's ERC-8004 agent on Robinhood Chain,
                                             so its BrainChain record is written to that identity.`,
-    run: `  brainchain-worker run --exec "<command>" [--format prompt|json] [--timeout <minutes>] [--once] [--no-mint]
+    run: `  brainchain-worker run --exec "<command>" [--format prompt|json] [--timeout <minutes>] [--once] [--mint]
                                             Do every task Jev hires the worker for: the command reads the
                                             task on stdin and prints the deliverable on stdout, within
                                             --timeout minutes (20 by default, at most 1440). It logs how
-                                            each task settles, and mints the Proof of each task it is paid
-                                            for, unless --no-mint.`,
-    status: `  brainchain-worker status                  Stake, wallet, application, record and earnings, with where each
+                                            each task settles. --mint also mints the Proof of each task it is
+                                            paid for.`,
+    status: `  brainchain-worker status                  Stake, wallet, application, record, earnings and gas, with where each
                                             task in flight stands.`,
     price: `  brainchain-worker price <USDG>            Change your asking price per task.`,
     mint: `  brainchain-worker mint [--count <n>] [--dry]
@@ -84,8 +89,9 @@ const COMMAND_USAGE = {
                                             window. Jev rules on it; a confident ruling decides.`,
     appeal: `  brainchain-worker appeal <task>           Appeal the ruling on a task, when it went against the worker, within the
                                             appeal window, with the bond the task's terms fix (a quarter of the
-                                            bounty). Jev rules again; the bond comes back unless Jev confidently
-                                            rules the same way. Testnet only for now.`,
+                                            bounty), claimed from the test USDG faucet when the wallet holds less.
+                                            Jev rules again; the bond comes back unless Jev confidently rules the
+                                            same way. Testnet only for now.`,
     leave: `  brainchain-worker leave                   Start unstaking (3-day cooldown).`,
     withdraw: `  brainchain-worker withdraw                Withdraw stake once the cooldown has passed.`,
 };
@@ -119,7 +125,8 @@ export class UsageError extends Error {
 const FLAGS = {
     "new-key": { file: false },
     join: { name: false, about: false, price: false, "agent-id": false },
-    run: { exec: false, format: false, timeout: false, once: true, "no-mint": true },
+    // --no-mint is still accepted from before minting became opt-in; it changes nothing.
+    run: { exec: false, format: false, timeout: false, once: true, mint: true, "no-mint": true },
     status: {},
     price: {},
     leave: {},
@@ -193,7 +200,7 @@ function signer() {
     const raw = keyText()?.trim();
     if (!raw)
         throw new Error("Set BRAINCHAIN_WORKER_KEY to the worker's private key, or BRAINCHAIN_WORKER_KEY_FILE to a file that holds it. `npx brainchain-worker new-key` makes one.");
-    const hex = raw.startsWith("0x") ? raw.slice(2) : raw;
+    const hex = raw.replace(/^0x/i, "");
     if (!/^[0-9a-fA-F]{64}$/.test(hex))
         throw new Error("The worker's key must be 64 hex characters, with or without 0x");
     const key = `0x${hex.toLowerCase()}`;
@@ -214,12 +221,12 @@ function price(value) {
 }
 const RUN = '`npx brainchain-worker run --exec "<command>"`';
 const KEEP_RUNNING = "https://github.com/usebrainchain/brainchain-worker#keep-it-running";
-function noGas(chain, network) {
-    return new Error(`${chain.account} has no ETH on ${network.name} for gas. ${network.gas(chain.account)}.`);
+async function noGas(chain, network) {
+    return new Error(`${chain.account} has no ETH on ${network.name} for gas. ${gasHelp(network, chain.account, 0n, await chain.sent())}.`);
 }
 async function needGas(chain, network) {
     if ((await chain.ethBalance()) === 0n)
-        throw noGas(chain, network);
+        throw await noGas(chain, network);
 }
 export async function join(chain, network, values) {
     const name = values.get("name")?.trim() ?? "";
@@ -229,15 +236,18 @@ export async function join(chain, network, values) {
     if (name.length > 60)
         throw new UsageError("--name is at most 60 characters");
     // A name that hides characters or turns text around can read as another, Jev's included.
-    if (HIDDEN.test(name) || /[\x00-\x1f\x7f-\x9f]/.test(name))
-        throw new UsageError("--name must be one line with no invisible or direction-changing characters");
+    const nameHides = unseen(name);
+    if (nameHides)
+        throw new UsageError(`--name must be one line with no invisible or direction-changing characters, and it holds ${nameHides}`);
     if (!about) {
         throw new UsageError("--about is required: say what work your agent does in up to 500 characters, since Jev reads it to decide and refuses an empty application");
     }
     if (about.length > 500)
         throw new UsageError("--about is at most 500 characters");
-    if (HIDDEN.test(about))
-        throw new UsageError("--about must have no invisible or direction-changing characters");
+    // A description may run over several lines.
+    const aboutHides = unseen(about.replace(/[\t\n]/g, " "));
+    if (aboutHides)
+        throw new UsageError(`--about must have no invisible or direction-changing characters, and it holds ${aboutHides}`);
     const agentId = values.get("agent-id");
     if (agentId !== undefined && !/^(0|[1-9]\d{0,14})$/.test(agentId))
         throw new UsageError("--agent-id is the worker's ERC-8004 agent id, a whole number");
@@ -261,12 +271,19 @@ export async function join(chain, network, values) {
     }
     // A worker that has staked keeps its price unless --price changes it.
     const asking = requested ?? (w.registered ? w.price : price(DEFAULT_PRICE));
-    const [gas, gasPrice, bond, balance, timelock] = await Promise.all([chain.ethBalance(), chain.gasPrice(), chain.bond(), chain.stakeBalance(), chain.timelock()]);
+    const [gas, gasPrice, bond, balance, timelock, sent] = await Promise.all([
+        chain.ethBalance(),
+        chain.gasPrice(),
+        chain.bond(),
+        chain.stakeBalance(),
+        chain.timelock(),
+        chain.sent(),
+    ]);
     const need = toStake + (applying ? bond : 0n);
     const claims = balance < need && !network.buyStake;
     // Checked before anything is sent: a wallet that runs out partway leaves the stake placed and the application unsent.
     const gasNeed = ethNeeded(joinLimits(standing, claims, toStake === 0n && w.price !== asking), gasPrice);
-    const lacksGas = gas < gasNeed ? `${chain.account} holds ${shortOfGas(network, chain.account, gas, gasNeed, "join")}` : undefined;
+    const lacksGas = gas < gasNeed ? `${chain.account} holds ${shortOfGas(network, chain.account, gas, sent, gasNeed, "join")}` : undefined;
     if (balance < need && network.buyStake) {
         const short = shortOfStake(network, w, balance, need, await chain.now());
         // Both needs at once, so a new worker does not bridge ETH only to learn it needs the stake token too.
@@ -320,9 +337,10 @@ export async function join(chain, network, values) {
         "the application with `npx brainchain-worker status`. New workers are offered house tasks first, which BrainChain pays for.");
 }
 async function status(chain, network) {
-    const [gas, gasPrice, s, held, record, bountyBalance, stakeBalance, bond, faucet, now] = await Promise.all([
+    const [gas, gasPrice, sent, s, held, record, bountyBalance, stakeBalance, bond, faucet, now] = await Promise.all([
         chain.ethBalance(),
         chain.gasPrice(),
+        chain.sent(),
         snapshot(chain),
         chain.held(),
         chain.record(),
@@ -342,7 +360,7 @@ async function status(chain, network) {
   Price     ${w.registered ? `${usdg(network, w.price)} per task` : "not set until you join"}
   Record    ${record.paid} paid, ${record.refunded} refunded, ${record.inFlight.length} in flight${held > 0 ? " (stake held until they settle)" : ""}${record.inFlight.map((f) => `\n            ${flightLine(f)}`).join("")}
   Earned    ${usdg(network, record.earned)} after fees; wallet holds ${usdg(network, bountyBalance)}
-  Gas       ${gasLine(network, chain.account, s, gas, gasPrice, !network.buyStake && stakeBalance < s.toStake + (s.applying ? bond : 0n))}`);
+  Gas       ${gasLine(network, chain.account, s, gas, gasPrice, !network.buyStake && stakeBalance < s.toStake + (s.applying ? bond : 0n), sent)}`);
 }
 async function run(network, { key, account }, values, once, mints) {
     const exec = values.get("exec");
@@ -379,9 +397,23 @@ async function run(network, { key, account }, values, once, mints) {
         stopping: stop.stopping,
         // A cron job sees a failed task as a failed run.
         failed: once ? () => void (process.exitCode = 1) : undefined,
-        delivered: settlements.track,
-        gasHelp: network.gas(account.address),
+        delivered(task) {
+            settlements.track(task);
+            void lowGas();
+        },
+        gasHelp: async () => gasHelp(network, account.address, 0n, await chain.sent()),
     });
+    // The drip pays for only a few deliveries, so the log says when the wallet is down to its last ones.
+    const lowGas = async () => {
+        const [gas, price, sent] = await Promise.all([chain.ethBalance(), chain.gasPrice(), chain.sent()]).catch(() => []);
+        if (gas === undefined || price === undefined || sent === undefined)
+            return;
+        const left = deliveriesLeft(gas, price);
+        if (left >= LOW_DELIVERIES)
+            return;
+        const enough = left === 0n ? "not enough for another delivery" : `enough for about ${left} more ${left === 1n ? "delivery" : "deliveries"}`;
+        log(`warning: the wallet holds ${formatEther(gas)} ETH for gas, ${enough}. ${gasHelp(network, account.address, gas, sent)}.`);
+    };
     for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"])
         process.on(signal, stop.signal);
     if (process.env.npm_execpath !== undefined) {
@@ -406,12 +438,14 @@ async function run(network, { key, account }, values, once, mints) {
         log(`could not read the wallet's ETH balance: ${reason(error)}`);
     }
     if (gas === 0n)
-        throw noGas(chain, network);
-    const [line, sick] = await Promise.all([
+        throw await noGas(chain, network);
+    const held = gas;
+    const [line, sick, left] = await Promise.all([
         snapshot(chain).then((s) => hireable(s, network, "run"), (error) => `could not check (${reason(error)})`),
         unhealthy(network.service),
+        held === undefined ? undefined : chain.gasPrice().then((price) => deliveriesLeft(held, price), () => undefined),
     ]);
-    log(`worker ${chain.account} on ${network.name}; hireable: ${line}`);
+    log(`worker ${chain.account} on ${network.name}; hireable: ${line}${left === undefined ? "" : `; gas for ${deliveries(left)}`}`);
     if (sick)
         log(`warning: ${sick}`);
     if (once) {
@@ -428,12 +462,16 @@ async function run(network, { key, account }, values, once, mints) {
     log("waiting for tasks (Ctrl-C to stop)");
     // Minting waits on receipts from another chain, so it runs beside the work, one round at a time.
     let minting;
+    const hireChange = hireWatch(line, () => snapshot(chain).then((s) => hireable(s, network, "run"), () => undefined));
     while (!stop.stopping()) {
         await work.round().catch((error) => log(`round failed: ${reason(error)}`));
         minting ??= settlements
             .round()
             .catch((error) => log(`settlement round failed: ${reason(error)}`))
             .finally(() => (minting = undefined));
+        const changed = stop.stopping() ? undefined : await hireChange();
+        if (changed !== undefined)
+            log(`hireable: ${changed}`);
         if (quietFor() >= HEARTBEAT_MS && !work.busy() && !stop.stopping()) {
             log(`still waiting for tasks; hireable: ${await snapshot(chain).then((s) => hireable(s, network, "run"), (error) => `could not check (${reason(error)})`)}`);
         }
@@ -443,6 +481,26 @@ async function run(network, { key, account }, values, once, mints) {
     await minting;
     log("stopped");
 }
+/**
+ * Reads again, every few minutes until the worker can be hired, whether it can,
+ * and returns the new answer when it changed. A run started while Jev decides
+ * on the application then says when Jev allows the worker, and when its
+ * timelock has passed.
+ */
+export function hireWatch(first, check, everyMs = HIREABLE_CHECK_MS, now = Date.now) {
+    let last = first;
+    let checkedAt = now();
+    return async () => {
+        if (last === "yes" || now() - checkedAt < everyMs)
+            return undefined;
+        checkedAt = now();
+        const line = await check();
+        if (line === undefined || line === last)
+            return undefined;
+        last = line;
+        return line;
+    };
+}
 /** Run's log, with each line's time, and how long it has been quiet, so an idle run can say it is still there. */
 export function timedLog(write, now = Date.now) {
     let last = now();
@@ -602,7 +660,7 @@ export async function main(argv) {
         return propose(network, createProposals(network, worker.account), call, uri, { dry: switches.has("dry"), log: console.log });
     }
     if (command === "run")
-        return run(network, worker, values, switches.has("once"), !switches.has("no-mint"));
+        return run(network, worker, values, switches.has("once"), switches.has("mint"));
     const chain = createChain(network, worker.account);
     switch (command) {
         case "join":

package/dist/dispute.js

@@ -1,8 +1,8 @@
 import { createPublicClient, createWalletClient, encodeFunctionData, formatUnits, parseAbi } from "viem";
 import { erc20Errors, transferErrors } from "./abi.js";
-import { appealAbi, brainchainTransport, erc20Abi, explainRevert, reason, RECEIPT_MS, Status } from "./chain.js";
+import { appealAbi, brainchainTransport, erc20Abi, explainRevert, faucetReopens, reason, RECEIPT_MS, Status } from "./chain.js";
 import { chainOf } from "./network.js";
-import { ethNeeded, shortOfGas } from "./standing.js";
+import { ethNeeded, GAS, shortOfGas } from "./standing.js";
 /** TaskBoard statuses from set 3.5.0 on: a ruling that waits out its appeal window, and one under appeal. */
 export const { Ruled, Appealed } = Status;
 const boardAbi = [
@@ -55,7 +55,23 @@ export function createDisputeChain(network, account) {
         appealOf: (id) => client.readContract({ ...board, functionName: "appealOf", args: [id] }),
         appealBond: (id) => client.readContract({ ...board, functionName: "appealBond", args: [id] }),
         bountyBalance: () => client.readContract({ ...token, functionName: "balanceOf", args: [account.address] }),
+        async bountyFaucet() {
+            const [amount, interval, last] = await Promise.all([
+                client.readContract({ ...token, functionName: "FAUCET_AMOUNT" }),
+                client.readContract({ ...token, functionName: "FAUCET_INTERVAL" }),
+                client.readContract({ ...token, functionName: "lastClaim", args: [account.address] }),
+            ]);
+            return { amount, opensAt: last === 0n ? 0n : last + interval };
+        },
+        async claimBounty() {
+            const hash = await wallet.writeContract({ ...token, functionName: "faucet" });
+            const receipt = await client.waitForTransactionReceipt({ hash, timeout: RECEIPT_MS });
+            if (receipt.status !== "success")
+                throw new Error(`The faucet claim ${hash} reverted`);
+            return hash;
+        },
         ethBalance: () => client.getBalance({ address: account.address }),
+        sent: () => client.getTransactionCount({ address: account.address }),
         gasPrice: () => client.getGasPrice(),
         allowance: () => client.readContract({ ...token, functionName: "allowance", args: [account.address, board.address] }),
         async approveBounty(amount) {
@@ -110,14 +126,41 @@ export async function appeal(network, chain, id, log) {
     const closes = terms.ruledAt + terms.window;
     if (now > closes)
         throw new Error(`The appeal window for task ${id} closed at ${at(closes)}.`);
-    const [bond, balance, eth, gasPrice, allowance] = await Promise.all([chain.appealBond(id), chain.bountyBalance(), chain.ethBalance(), chain.gasPrice(), chain.allowance()]);
+    const [bond, balance, eth, gasPrice, allowance, sent] = await Promise.all([
+        chain.appealBond(id),
+        chain.bountyBalance(),
+        chain.ethBalance(),
+        chain.gasPrice(),
+        chain.allowance(),
+        chain.sent(),
+    ]);
     const amount = `${formatUnits(bond, 6)} ${network.bountySymbol}`;
-    if (balance < bond)
-        throw new Error(`The appeal bond is ${amount}, and the worker holds ${formatUnits(balance, 6)}. Bridge more with \`npx brainchain-worker bridge --bounty <amount>\`.`);
-    // Checked for both transactions before either is sent: an approval alone spends gas and leaves the bond approved.
-    const need = ethNeeded(allowance < bond ? [APPROVE_GAS, APPEAL_GAS] : [APPEAL_GAS], gasPrice);
+    const holds = `The appeal bond is ${amount}, and this wallet holds ${formatUnits(balance, 6)}.`;
+    // Test USDG comes from its faucet, as tBRAIN does for join; only mainnet's USDG is bridged in.
+    const claims = balance < bond && network.bountyFaucet === true;
+    if (balance < bond && !claims)
+        throw new Error(`${holds} Bridge more with \`npx brainchain-worker bridge --bounty <amount>\`.`);
+    const closed = (opensAt) => new Error(`${holds} The ${network.bountySymbol} faucet allows one claim a day, and this wallet can claim again at ${at(opensAt)}` +
+        (opensAt > closes ? `, after the appeal window closes at ${at(closes)}.` : `. Run appeal again then, before the appeal window closes at ${at(closes)}.`));
+    if (claims) {
+        const faucet = await chain.bountyFaucet();
+        if (now < faucet.opensAt)
+            throw closed(faucet.opensAt);
+        if (balance + faucet.amount < bond)
+            throw new Error(`${holds} The faucet's ${formatUnits(faucet.amount, 6)} ${network.bountySymbol} a day would not make up the rest.`);
+    }
+    // Checked for every transaction before any is sent: an approval alone spends gas and leaves the bond approved.
+    const need = ethNeeded([...(claims ? [GAS.faucet] : []), ...(allowance < bond ? [APPROVE_GAS] : []), APPEAL_GAS], gasPrice);
     if (eth < need)
-        throw new Error(`${chain.account} holds ${shortOfGas(network, chain.account, eth, need, "the appeal")} Nothing was sent.`);
+        throw new Error(`${chain.account} holds ${shortOfGas(network, chain.account, eth, sent, need, "the appeal")} Nothing was sent.`);
+    if (claims) {
+        log(`Claiming ${network.bountySymbol} from the testnet faucet for the bond...`);
+        const claim = await chain.claimBounty().catch((error) => {
+            const opensAt = faucetReopens(error);
+            throw opensAt === undefined ? error : closed(opensAt);
+        });
+        log(`Claimed: ${claim}`);
+    }
     const approval = await chain.approveBounty(bond);
     const tx = await chain.appeal(id).catch((error) => {
         if (approval === undefined)

package/dist/key.js

@@ -13,7 +13,7 @@ export const keyConfigured = (env = process.env) => Boolean(env[HANDOFF] || env.
 function keyFileProblem(text) {
     if (text === "")
         return "is empty";
-    if (/^(0x)?[0-9a-fA-F]{64}$/.test(text))
+    if (/^(0x)?[0-9a-f]{64}$/i.test(text))
         return undefined;
     if (/[\r\n]/.test(text))
         return "holds more than one line";
@@ -21,7 +21,7 @@ function keyFileProblem(text) {
         return "holds a line in the form NAME=value";
     if (/^["'`]|["'`]$/.test(text))
         return "holds the key in quotes";
-    const hex = text.startsWith("0x") ? text.slice(2) : text;
+    const hex = text.replace(/^0x/i, "");
     if (/^[0-9a-fA-F]+$/.test(hex))
         return `holds ${hex.length} hex characters where a key has 64`;
     return "holds characters that are not hex digits";

package/dist/mint.js

@@ -272,7 +272,7 @@ export function createSettlementWatch(options) {
                 entry.told = true;
                 store.save();
                 return log(`task ${key}: no proof minted. ${funds.missing} It tries again every hour, without another line, until ${when(BigInt(until))}; ` +
-                    "an hour later the Proof goes to the public pool. Testnet Proofs earn no income, and `run --no-mint` turns minting off.");
+                    "an hour later the Proof goes to the public pool. Proofs earn no income, and `run` without `--mint` mints none.");
             }
             await chain.approve(funds.price);
             const { tokenId, tx } = await chain.mint();

package/dist/network.js

@@ -10,10 +10,13 @@ export const TESTNET = {
     explorer: "https://usebrainchain.com/testnet",
     stakeSymbol: "tBRAIN",
     bountySymbol: "tUSDG",
-    // The drip needs no browser, so an agent can fund itself; the faucet asks for a browser check and a Google account.
-    gas: (address) => "Ask the testnet gas drip first: `curl -X POST https://brain.testnet.usebrainchain.com/testnet/gas -H 'content-type: application/json' " +
-        `-d '{"address":"${address}"}'\` sends 0.0001 ETH, enough to join, once per address. After that, get Robinhood Chain testnet ETH from ` +
-        "https://faucet.testnet.chain.robinhood.com and move it here with `npx brainchain-worker bridge --eth 0.001`",
+    bountyFaucet: true,
+    gas: "Get Robinhood Chain testnet ETH from https://faucet.testnet.chain.robinhood.com, which asks for a browser check and a Google account, " +
+        "so a person claims it, and move it here with `npx brainchain-worker bridge --eth 0.001`",
+    drip: {
+        wei: 100000000000000n,
+        request: (address) => `\`curl -X POST https://brain.testnet.usebrainchain.com/testnet/gas -H 'content-type: application/json' -d '{"address":"${address}"}'\``,
+    },
     proofs: {
         chainId: 46630,
         name: "Robinhood Chain testnet",
@@ -63,7 +66,7 @@ export const MAINNET = {
     explorer: "https://usebrainchain.com",
     stakeSymbol: "BRAIN",
     bountySymbol: "USDG",
-    gas: () => "Send this address ETH on Robinhood Chain, then move it here with `npx brainchain-worker bridge --eth 0.001`",
+    gas: "Send this address ETH on Robinhood Chain, then move it here with `npx brainchain-worker bridge --eth 0.001`",
     buyStake: "Buy BRAIN on Robinhood Chain at ripples.run (https://ripples.run/t/0xa06e3D898Bce92F67617E0Bfb640F153A5b65AB7) and move it to BrainChain with " +
         `brainchain-worker bridge --stake <amount> (docs: https://docs.usebrainchain.com/bridging); the stake token on BrainChain is ${BRAIN}.`,
     proofs: {

package/dist/proc.js

@@ -0,0 +1,34 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+/** One field of `ps` for a process, or undefined when it is gone or ps cannot tell. */
+export function ps(pid, field) {
+    const result = spawnSync("ps", ["-o", `${field}=`, "-p", String(pid)], { encoding: "utf8" });
+    return result.status === 0 ? result.stdout.trim() : undefined;
+}
+/**
+ * When a Linux process started, from /proc, which slim container images have
+ * without ps. The kernel counts it in ticks since boot, 100 a second on every
+ * architecture Node.js runs on.
+ */
+function procStart(pid) {
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+        const ticks = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19]);
+        const boot = Number(/^btime (\d+)$/m.exec(readFileSync("/proc/stat", "utf8"))?.[1]);
+        return Number.isSafeInteger(ticks) && boot > 0 ? boot * 1000 + ticks * 10 : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** When a process started, in ms since the epoch, or undefined when it is gone or neither /proc nor ps can tell. */
+export function startTime(pid) {
+    const started = procStart(pid);
+    if (started !== undefined)
+        return started;
+    const elapsed = /^(?:(?:(\d+)-)?(\d+):)?(\d+):(\d+)$/.exec(ps(pid, "etime") ?? "");
+    if (!elapsed)
+        return undefined;
+    const [days, hours, minutes, seconds] = elapsed.slice(1).map((part) => Number(part ?? 0));
+    return Date.now() - (((days * 24 + hours) * 60 + minutes) * 60 + seconds) * 1000;
+}

package/dist/propose.js

@@ -2,7 +2,7 @@ import { BaseError, createPublicClient, createWalletClient, decodeErrorResult, d
 import { erc20Errors } from "./abi.js";
 import { bondsAbi, brainchainTransport, erc20Abi, executorAbi, RECEIPT_MS } from "./chain.js";
 import { chainOf } from "./network.js";
-import { stake, when } from "./standing.js";
+import { gasHelp, stake, when } from "./standing.js";
 /** Every call the executor can be asked to make, by the contract it calls. */
 export const GOVERNED = {
     board: parseAbi([
@@ -198,6 +198,7 @@ export function createProposals(network, account) {
         account: account.address,
         now: async () => (await client.getBlock()).timestamp,
         ethBalance: () => client.getBalance({ address: account.address }),
+        sent: () => client.getTransactionCount({ address: account.address }),
         stakeBalance: () => client.readContract({ address: stakeToken, abi: erc20Abi, functionName: "balanceOf", args: [account.address] }),
         bond: () => client.readContract({ ...proposals, functionName: "bond" }),
         decideWithin: () => client.readContract({ ...proposals, functionName: "decideWithin" }),
@@ -303,7 +304,7 @@ export async function propose(network, chain, call, uri, options) {
         throw new Error(`The wallet holds ${stake(network, balance)} of the ${stake(network, bond)} bond.${buy}`);
     }
     if (gas === 0n)
-        throw new Error(`${chain.account} has no ETH on ${network.name} for gas. ${network.gas(chain.account)}.`);
+        throw new Error(`${chain.account} has no ETH on ${network.name} for gas. ${gasHelp(network, chain.account, 0n, await chain.sent())}.`);
     log(`Bonding ${stake(network, bond)} and proposing...`);
     const { id, tx } = await chain.propose(call, uri, bond);
     log(`Proposal ${id} is waiting for Jev (${tx}). Follow it with \`npx brainchain-worker proposal ${id}\`.`);

package/dist/standing.js

@@ -1,7 +1,7 @@
 import { formatEther, formatUnits } from "viem";
 import { ApplicationState, Status } from "./chain.js";
 /** A token amount with thousands separators, such as 1,250,000; a fraction is kept as it is. */
-function grouped(amount, decimals) {
+export function grouped(amount, decimals) {
     const [whole, fraction] = formatUnits(amount, decimals).split(".");
     return `${whole.replace(/\B(?=(\d{3})+$)/g, ",")}${fraction === undefined ? "" : `.${fraction}`}`;
 }
@@ -27,7 +27,7 @@ export async function snapshot(chain) {
     };
 }
 /** The highest gas limit seen for each transaction join can send, across testnet and mainnet. */
-const GAS = { faucet: 76000n, approve: 50000n, stake: 120000n, setPrice: 31000n, apply: 240000n };
+export const GAS = { faucet: 76000n, approve: 50000n, stake: 120000n, setPrice: 31000n, apply: 240000n };
 /** The highest gas limit seen for delivering a result. */
 const SUBMIT_GAS = 104000n;
 /**
@@ -105,13 +105,42 @@ export function wallet(network, s, balance, bond, faucet, now) {
     const buy = network.buyStake ? `. ${network.buyStake}` : "";
     return `${has}; join needs ${stake(network, need)}${reopens}${unstaking}${buy}`;
 }
+/**
+ * Where a wallet gets ETH for gas, given what it holds and how many
+ * transactions it has sent. The drip serves an address once and turns away one
+ * that holds a drip's worth, so only a wallet that has sent nothing and holds
+ * less is sure to get it; any other is sent to the faucet.
+ */
+export function gasHelp(network, address, gas, sent) {
+    const { drip } = network;
+    if (!drip)
+        return network.gas;
+    if (sent > 0 || gas >= drip.wei)
+        return `${network.gas}. The gas drip serves each address once`;
+    const after = `${network.gas[0].toLowerCase()}${network.gas.slice(1)}`;
+    return `Ask the testnet gas drip first: ${drip.request(address)} sends ${formatEther(drip.wei)} ETH, enough to join, once per address. After that, ${after}`;
+}
 /** What a wallet short of gas holds and needs, for join's refusal and for `status`. */
-export const shortOfGas = (network, address, gas, need, purpose) => `${formatEther(gas)} ETH on ${network.name}; ${purpose} needs about ${aboutEth(need)} ETH for gas. ${network.gas(address)}.`;
-/** The wallet's ETH, and what more join or the next delivery needs, since a send the wallet cannot cover fails partway through. */
-export function gasLine(network, address, s, gas, gasPrice, claims) {
+export const shortOfGas = (network, address, gas, sent, need, purpose) => `${formatEther(gas)} ETH on ${network.name}; ${purpose} needs about ${aboutEth(need)} ETH for gas. ${gasHelp(network, address, gas, sent)}.`;
+/** How many results the wallet's ETH delivers at this gas price, the last of them at the fee cap the RPC checks. */
+export function deliveriesLeft(gas, gasPrice) {
+    const price = gasPrice > 0n ? gasPrice : 1n;
+    const last = ethNeeded([SUBMIT_GAS], price);
+    return gas < last ? 0n : (gas - last) / (SUBMIT_GAS * price) + 1n;
+}
+/** About how many results the wallet's ETH delivers, for `status` and `run`. */
+export const deliveries = (count) => `about ${count} ${count === 1n ? "delivery" : "deliveries"}`;
+/**
+ * The wallet's ETH, and what more join or the next delivery needs, since a
+ * send the wallet cannot cover fails partway through. A worker with nothing to
+ * join hears how many results its ETH delivers.
+ */
+export function gasLine(network, address, s, gas, gasPrice, claims, sent) {
     const limits = joinLimits(s, claims, false);
     const need = ethNeeded(limits.length > 0 ? limits : [SUBMIT_GAS], gasPrice);
-    return gas >= need ? `${formatEther(gas)} ETH` : shortOfGas(network, address, gas, need, limits.length > 0 ? "join" : "delivering a result");
+    if (gas < need)
+        return shortOfGas(network, address, gas, sent, need, limits.length > 0 ? "join" : "delivering a result");
+    return limits.length > 0 ? `${formatEther(gas)} ETH` : `${formatEther(gas)} ETH, enough for ${deliveries(deliveriesLeft(gas, gasPrice))} at the current gas price`;
 }
 /** What join says when the wallet holds too little of a stake token that has no faucet. */
 export function shortOfStake(network, w, balance, need, now) {

package/dist/state.js

@@ -2,6 +2,7 @@ import { randomBytes } from "node:crypto";
 import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, readlinkSync, renameSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
 import { dirname, join } from "node:path";
+import { startTime } from "./proc.js";
 export const stateDir = () => join(homedir(), ".config", "brainchain-worker");
 /** The decision count a one-shot watch run stopped at, kept per decision log; undefined when there is none or it cannot be read. */
 export function readWatched(log, dir = stateDir()) {
@@ -113,6 +114,8 @@ const LOCK_STALE_MS = 15_000;
 const LOCK_WATCH_MS = 7_000;
 /** A takeover takes a few system calls, so one marker older than this was left by a crash. */
 const TAKEOVER_STALE_MS = 5_000;
+/** How far a start time read from ps, which gives it to the second, can fall after the true one. */
+const START_SLACK_MS = 2_000;
 /**
  * Where a pid means something. Containers sharing a config folder each have
  * their own numbering, so a holder's pid says nothing outside its own space.
@@ -170,14 +173,27 @@ function holderOf(text) {
     }
     return { pid: 0, space: "" };
 }
+/**
+ * Whether the run that wrote a bare-pid lock is still going. 0.12 and earlier
+ * wrote the pid once and never touched the file again, so the lock's age says
+ * nothing. A process that started after the lock was written, as pid 1 does
+ * when a container restarts, has only come to reuse the pid.
+ */
+function bareHeld(pid, writtenAt) {
+    if (!alive(pid))
+        return false;
+    const started = startTime(pid);
+    return started === undefined || started <= writtenAt + START_SLACK_MS;
+}
 /** Whether the run that wrote a lock is still going. */
 function isHeld(file, { pid, space }, watchMs) {
     const touched = touchedAt(file);
-    if (touched === undefined || Date.now() - touched >= LOCK_STALE_MS)
+    if (touched === undefined)
         return false;
-    // A bare pid was written in this PID namespace or one gone since, so after a restart a live pid can be another process.
     if (space === undefined)
-        return alive(pid);
+        return bareHeld(pid, touched);
+    if (Date.now() - touched >= LOCK_STALE_MS)
+        return false;
     if (pid === 0)
         return true;
     if (space === pidSpace())

package/dist/work.js

@@ -2,6 +2,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { toBytes } from "viem";
 import { fetchBrief, PermanentError, reason, RECEIPT_MS } from "./chain.js";
+import { ps, startTime } from "./proc.js";
 import { memoryStore } from "./state.js";
 /** The most the service accepts for one result. */
 export const MAX_RESULT_BYTES = 100_000;
@@ -17,6 +18,19 @@ const ANSI = /\x1b(?:\[[0-?]*[ -\/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\)|[@-Z\\-_
 export const stripAnsi = (text) => text.replace(ANSI, "");
 /** Characters that show nothing or turn the text around them, so text that holds them can read as other text. */
 export const HIDDEN = /[\u00ad\u061c\u180e\u200b\u200e\u200f\u202a-\u202e\u2060-\u2064\u2066-\u2069\ufeff]/;
+/**
+ * What a worker's name and description may not hold: control, format and
+ * separator characters, and the default-ignorable code points Unicode files
+ * as letters or marks, which no property escape reaches, plus the blank
+ * braille pattern. Each shows nothing, breaks the line or turns the text
+ * around, so a name that holds one can read as another.
+ */
+const UNSEEN = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}͏ᅟᅠ឴឵᠋-᠏⁥⠀ㅤ︀-️ﾠ￰-￸\u{e0000}-\u{e0fff}]/u;
+/** The first character of `text` that UNSEEN refuses, as U+XXXX, or undefined when there is none. */
+export function unseen(text) {
+    const found = UNSEEN.exec(text)?.[0];
+    return found === undefined ? undefined : `U+${found.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}`;
+}
 /** Text from strangers, made safe to print as one terminal line. */
 export const printable = (text) => stripAnsi(text)
     .replace(/[\t\n\r]+/g, " ")
@@ -96,19 +110,6 @@ function signalGroup(pid, signal) {
             throw error;
     }
 }
-/** One field of `ps` for a process, or undefined when it is gone or ps cannot tell. */
-function ps(pid, field) {
-    const result = spawnSync("ps", ["-o", `${field}=`, "-p", String(pid)], { encoding: "utf8" });
-    return result.status === 0 ? result.stdout.trim() : undefined;
-}
-/** When a process started, in ms since the epoch, or undefined when it is gone or ps cannot tell. */
-function startTime(pid) {
-    const elapsed = /^(?:(?:(\d+)-)?(\d+):)?(\d+):(\d+)$/.exec(ps(pid, "etime") ?? "");
-    if (!elapsed)
-        return undefined;
-    const [days, hours, minutes, seconds] = elapsed.slice(1).map((part) => Number(part ?? 0));
-    return Date.now() - (((days * 24 + hours) * 60 + minutes) * 60 + seconds) * 1000;
-}
 function exists(pid) {
     try {
         process.kill(pid, 0);
@@ -359,7 +360,8 @@ export function createWork(options) {
     };
     const needGas = async () => {
         if ((await chain.ethBalance()) === 0n) {
-            throw new Error(`The wallet has no ETH to pay gas for the submit${options.gasHelp ? `. ${options.gasHelp}` : ""}. The task is tried again`);
+            const help = await options.gasHelp?.().catch(() => undefined);
+            throw new Error(`The wallet has no ETH to pay gas for the submit${help ? `. ${help}` : ""}. The task is tried again`);
         }
     };
     const inTime = async (task) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainchain-worker",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Earn on BrainChain and propose changes to it: stake, apply, do the tasks Jev hires your agent for, and bond BRAIN to put a change to Jev.",
   "license": "MIT",
   "author": "BrainChain <hello@usebrainchain.com>",
@@ -29,7 +29,7 @@
   },
   "dependencies": {
     "brainchain-verify": "^0.4.0",
-    "viem": "^2.0.0"
+    "viem": "^2.57.12"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",