brainchain-worker 0.13.1 → 0.15.0

package/dist/mint.js

@@ -1,7 +1,7 @@
 import { createPublicClient, createWalletClient, formatEther, parseAbi, parseEventLogs, zeroAddress, } from "viem";
-import { reason, RECEIPT_MS } from "./chain.js";
+import { reason, RECEIPT_MS, REFUND_REASONS } from "./chain.js";
 import { proofsChainOf, proofsTransport } from "./network.js";
-import { when } from "./standing.js";
+import { stake, usdg, when } from "./standing.js";
 export const collectionAbi = parseAbi([
     "function PRICE_QUOTE() view returns (uint256)",
     "function mint(uint256 quantity, uint256 minRoutedTotal) payable",
@@ -23,13 +23,13 @@ export const wethAbi = parseAbi([
 export const MAX_MINT = 10;
 /** How often a delivered task's status is read until it settles. */
 const STATUS_SEC = 300;
-/** Grading, a dispute and its ruling take up to 6 hours each on mainnet, so a task unsettled after a day is left. */
-const WATCH_SEC = 86_400;
+/** Each step from grading to a ruling on appeal has a window of at most 6 hours, so a task unsettled two days after delivery is left. */
+const WATCH_SEC = 2 * 86_400;
 /** A day after payment the task joins the public pool, so the worker's own attempts stop an hour short of it. */
 const OWN_SEC = 23 * 3_600;
 /** The least time between two mint attempts for one task. */
 const RETRY_SEC = 3_600;
-/** The service lists a payment a round or two after it lands; a task still unlisted this long after has its piece. */
+/** The service lists a payment a round or two after it lands, which has taken over ten minutes: this long, the listing is read every minute. */
 const LISTING_SEC = 900;
 /** The piece a mint's receipt shows the collection minting to `to`. */
 export function mintedToken(logs, collection, to) {
@@ -140,7 +140,11 @@ async function afford(proofs, chain, count, options) {
             : `The test WETH faucet allows one claim a day, and this wallet can claim again at ${when(opensAt)}.`);
     }
     const holds = `${chain.account} holds ${formatEther(weth)} WETH${needEth ? " and no ETH" : ""} on ${proofs.name}`;
-    return { price, missing: `${holds}, and ${proofCount(count)} cost${count === 1 ? "s" : ""} ${formatEther(cost)} WETH plus gas. ${fixes.join(" ")}` };
+    return {
+        price,
+        missing: `${holds}, and ${proofCount(count)} cost${count === 1 ? "s" : ""} ${formatEther(cost)} WETH plus gas. ${fixes.join(" ")}`,
+        ...(needEth ? { noEth: true } : {}),
+    };
 }
 /**
  * Mints a piece for each of the worker's paid tasks the service lists without
@@ -178,13 +182,14 @@ export async function mint(network, chain, options) {
         log(rest.trim());
 }
 /**
- * What `run` does for Proofs: it watches each task the worker delivers until
- * it settles and mints a piece for each paid one, at most once an hour per
- * task, and only while the service lists the task as waiting for a piece. The
- * watched tasks live in the state, so a restart neither forgets nor repeats a
- * mint. With `enabled` false, as under --no-mint, it does nothing.
+ * What `run` does once a task is delivered: it watches the task until it
+ * settles and logs how: paid and how much, or refunded, why and any stake
+ * slashed. With `mints`, it then mints a piece for each paid task, at most once
+ * an hour per task, while the service lists the task as waiting for one and
+ * the worker can still mint it. The watched tasks live in the state, so a
+ * restart neither forgets nor repeats a mint.
  */
-export function createProofMinter(options) {
+export function createSettlementWatch(options) {
     const { network, chain, store, log } = options;
     const clock = options.now ?? wall;
     const watched = () => (store.state.proofs ??= {});
@@ -198,49 +203,77 @@ export function createProofMinter(options) {
         entry.nextAt = clock() + seconds;
         store.save();
     };
-    /** Reads whether a delivered task settled; true once it is paid. */
+    /** Reads whether a delivered task settled and logs how; true once it is paid and has a Proof to mint. */
     async function settle(key, entry) {
         let outcome;
         try {
-            outcome = await options.settled(BigInt(key));
+            outcome = await options.settlement(BigInt(key));
         }
         catch (error) {
             later(entry, STATUS_SEC);
-            log(`task ${key}: could not read whether it was paid (${reason(error)})`);
-            return false;
-        }
-        if (outcome === "refunded") {
-            drop(key, "refunded to its poster, so it gets no proof");
+            log(`task ${key}: could not read whether it settled (${reason(error)})`);
             return false;
         }
         if (outcome === undefined) {
             if (clock() - entry.deliveredAt >= WATCH_SEC)
-                drop(key, "not settled a day after delivery, so the worker mints no proof for it");
+                drop(key, "not settled two days after delivery, so the worker stops watching it");
             else
                 later(entry, STATUS_SEC);
             return false;
         }
-        entry.paidAt = clock();
+        if (!outcome.paid) {
+            const slashed = outcome.slashed > 0n ? `; ${stake(network, outcome.slashed)} of the worker's stake was slashed` : "";
+            drop(key, `refunded to its poster: ${REFUND_REASONS[outcome.reason] ?? `reason ${outcome.reason}`}${slashed}`);
+            return false;
+        }
+        log(`task ${key}: paid ${usdg(network, outcome.amount)}`);
+        if (!options.mints) {
+            drop(key);
+            return false;
+        }
+        entry.paidAt = Number(outcome.at);
         store.save();
         return true;
     }
     async function mintFor(key, entry, listed) {
-        const paidAt = entry.paidAt;
-        if (clock() - paidAt >= OWN_SEC)
+        const until = entry.paidAt + OWN_SEC;
+        if (clock() >= until) {
+            if (Array.isArray(listed) && !listed.includes(BigInt(key)) && !entry.listed) {
+                return drop(key, "the BrainChain service never listed it as waiting for a proof, so the worker minted none");
+            }
             return drop(key, "no proof minted within a day of payment, so the task joins the public pool");
+        }
         if (Array.isArray(listed) && !listed.includes(BigInt(key))) {
-            if (clock() - paidAt < LISTING_SEC)
+            // Once listed, a task leaves the list when it has its piece.
+            if (entry.listed)
+                return drop(key, "the BrainChain service no longer lists it as waiting for a proof, so it has one");
+            if (clock() - entry.paidAt < LISTING_SEC)
                 return later(entry, 60);
-            return drop(key, "the BrainChain service lists no proof waiting for it, so the worker mints none");
+            if (!entry.waited) {
+                entry.waited = true;
+                log(`task ${key}: the BrainChain service does not list it as waiting for a proof yet; checking every ${STATUS_SEC / 60} minutes until ${when(BigInt(until))}`);
+            }
+            return later(entry, STATUS_SEC);
         }
+        if (Array.isArray(listed))
+            entry.listed = true;
         // Counted before anything is sent, so a restart during the mint waits out the hour too.
         later(entry, RETRY_SEC);
         if (listed instanceof Error)
             return log(`task ${key}: no proof minted yet (${reason(listed)}); trying again in an hour`);
         try {
             const funds = await afford(network.proofs, chain, 1, { dry: false, claiming: () => log("claiming test WETH from the faucet"), now: clock });
-            if (funds.missing)
-                return log(`task ${key}: no proof minted yet. ${funds.missing} Trying again in an hour.`);
+            if (funds.missing) {
+                if (network.id !== "testnet" || !funds.noEth)
+                    return log(`task ${key}: no proof minted yet. ${funds.missing} Trying again in an hour.`);
+                // No agent route leads to ETH on Robinhood Chain testnet, so the hourly retries say nothing new.
+                if (entry.told)
+                    return;
+                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. Proofs earn no income, and `run` without `--mint` mints none.");
+            }
             await chain.approve(funds.price);
             const { tokenId, tx } = await chain.mint();
             drop(key);
@@ -253,15 +286,13 @@ export function createProofMinter(options) {
     return {
         /** Watches a task the worker just delivered. */
         track(task) {
-            if (!options.enabled)
-                return;
             const now = clock();
             watched()[task.toString()] = { deliveredAt: now, nextAt: now + STATUS_SEC };
             store.save();
         },
-        /** Reads every watched task that is due, and mints for each paid one. */
+        /** Reads every watched task that is due, logs each that settled, and mints for each paid one. */
         async round() {
-            if (!options.enabled || store.state.proofs === undefined)
+            if (store.state.proofs === undefined)
                 return;
             const due = Object.entries(watched()).filter(([, entry]) => clock() >= entry.nextAt);
             const paid = [];
@@ -270,6 +301,12 @@ export function createProofMinter(options) {
                     paid.push([key, entry]);
             if (paid.length === 0)
                 return;
+            // A run under --no-mint after one that minted leaves those tasks' Proofs to `mint`.
+            if (!options.mints) {
+                for (const [key] of paid)
+                    drop(key);
+                return;
+            }
             const listed = await pendingTasks(network, chain.account, options.fetcher).catch((error) => (error instanceof Error ? error : new Error(String(error))));
             for (const [key, entry] of paid)
                 await mintFor(key, entry, listed);

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",
@@ -22,7 +25,9 @@ export const TESTNET = {
         collection: "0x324B52EE2182641ec29652076ab541bc9F9907d2",
         weth: "0x1F852eF3Afa13156b807204d838BbB46B4b452eb",
         faucet: true,
-        gas: "Get Robinhood Chain testnet ETH for gas at https://faucet.testnet.chain.robinhood.com",
+        // The gas drip funds BrainChain testnet only, and this faucet asks for a browser check, so a person has to claim it.
+        gas: "A person can get Robinhood Chain testnet ETH for gas at https://faucet.testnet.chain.robinhood.com, which asks for a browser check and a Google account, " +
+            "and send it to this address; BrainChain's gas drip sends ETH on BrainChain testnet only",
     },
     bridge: {
         chainId: 46630,
@@ -61,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 } from "./chain.js";
+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) {
@@ -119,3 +148,30 @@ export function shortOfStake(network, w, balance, need, now) {
     const unstaking = w.unstaking > 0n ? ` Or run withdraw ${withdraw} and join with the ${stake(network, w.unstaking)} it returns.` : "";
     return `The wallet holds ${stake(network, balance)} of the ${stake(network, need)} join needs. ${network.buyStake}${unstaking}`;
 }
+/** Where a task in flight stands and what happens next, for `status`. */
+export function flightLine(f) {
+    const task = `task ${f.id}`;
+    switch (f.status) {
+        case Status.Hired:
+            return `${task}: hired, due by ${when(f.deadline)}`;
+        case Status.Submitted:
+            return `${task}: delivered, waiting for Jev's grade`;
+        case Status.Graded: {
+            const closes = when(f.gradedAt + f.disputeWindow);
+            return f.accepted
+                ? `${task}: accepted, paid after ${closes} unless the grade is disputed`
+                : `${task}: not accepted, refunded to the poster after ${closes} unless the grade is disputed with \`dispute ${f.id}\``;
+        }
+        case Status.Disputed:
+            return `${task}: grade disputed by ${f.disputedByModel ? "this worker" : "the poster"}, Jev rules by ${when(f.disputedAt + f.ruleWindow)}`;
+        case Status.Ruled: {
+            const a = f.appeal;
+            const closes = when(a.ruledAt + a.window);
+            return a.pays
+                ? `${task}: the ruling pays this worker after ${closes} unless the poster appeals`
+                : `${task}: the ruling refunds the poster after ${closes} unless appealed with \`appeal ${f.id}\``;
+        }
+        default:
+            return `${task}: ruling appealed, Jev rules again by ${when(f.appeal.appealedAt + f.ruleWindow)}`;
+    }
+}

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()) {
@@ -38,10 +39,11 @@ function isTask(value) {
         return false;
     return value.stored === undefined || (isObject(value.stored) && typeof value.stored.uri === "string" && isHash(value.stored.hash));
 }
+const isFlag = (value) => value === undefined || value === true;
 function isProofs(value) {
     if (!isObject(value) || !isIds(Object.keys(value)))
         return false;
-    return Object.values(value).every((p) => isObject(p) && isCount(p.deliveredAt) && isCount(p.nextAt) && (p.paidAt === undefined || isCount(p.paidAt)));
+    return Object.values(value).every((p) => isObject(p) && isCount(p.deliveredAt) && isCount(p.nextAt) && (p.paidAt === undefined || isCount(p.paidAt)) && isFlag(p.listed) && isFlag(p.waited) && isFlag(p.told));
 }
 /** Whether a parsed file is a state this worker can go on from; any other shape fails every round that reads it. */
 function isState(value) {
@@ -112,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.
@@ -169,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;
@@ -15,10 +16,26 @@ const DEFAULT_TIMEOUT_MS = 20 * 60_000;
 const DRAIN_MS = 2_000;
 const ANSI = /\x1b(?:\[[0-?]*[ -\/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\)|[@-Z\\-_])/g;
 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, " ")
-    .replace(/[\x00-\x1f\x7f-\x9f]/g, "");
+    .replace(/[\x00-\x1f\x7f-\x9f]/g, "")
+    .replace(new RegExp(HIDDEN.source, "g"), "");
 export function parseBrief(text) {
     let value;
     try {
@@ -93,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);
@@ -355,8 +359,10 @@ export function createWork(options) {
         store.save();
     };
     const needGas = async () => {
-        if ((await chain.ethBalance()) === 0n)
-            throw new Error("The wallet has no ETH to pay gas for the submit. Add some and the task is tried again");
+        if ((await chain.ethBalance()) === 0n) {
+            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) => {
         if ((await chain.now()) >= task.deadline)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainchain-worker",
-  "version": "0.13.1",
+  "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",