toolroll 0.9.10 → 0.9.12

package/dist/operate.js

@@ -1,3 +1,4 @@
+import { UNSENT_REPLY_MS } from "./telegram-settings.js";
 import { maybeTriggerRepair } from "./dispose.js";
 import { CHECK_LEVEL_HINTS, CHECK_LEVEL_WORDS, isCheckLevel, liveQuickCommand, projectCheckLevel, quickVerifyKey, setProjectCheckLevel, setTaskCheckLevel, suggestQuickCommand } from "./check-levels.js";
 import { fileAddTestsTask, followUpChecksOf, requestFollowUpChecks, runFollowUpCheck, runWaitingChecks } from "./result-follow-ups.js";
@@ -88,6 +89,7 @@ import { pushPass } from "./push.js";
 import { chmodSync, closeSync, constants as fsConstants, existsSync, fstatSync, fsyncSync, openSync, readFileSync, readSync, realpathSync, renameSync, unlinkSync, writeSync, writeFileSync, mkdirSync } from "node:fs";
 import { BRANCH_PREFIX, envTwins, envValue, existingOrFirst, namedPath, taskBranches } from "./names.js";
 import { claimActor, currentActor, parseLeadToken, withActor } from "./actor.js";
+import { leadClaim, leadSay, noteLeadWork } from "./lead-voice.js";
 import { createServer as createNetServer } from "node:net";
 import { spawn as spawnChild } from "node:child_process";
 import { envelopeJson } from "./envelope.js";
@@ -138,7 +140,7 @@ import { diagnoseTaskDispatch, diagnosisIsDispatchable, scopeApprovedForDispatch
 import { createDecisionServer } from "./serve.js";
 import { readTailnetNames } from "./tailnet.js";
 import { daemonLaunchCommand, daemonStatus, installReplacingLegacy, installedLegacyDaemon, planDaemon, uninstallDaemon, awaitFreshHeartbeat, } from "./daemon.js";
-import { bridgePass, clearBotToken, createTransport, followBridge, hashPairingCode, loadBotToken, mintPairingCode, redactToken, saveBotToken, PAIRING_TTL_MS, TOKEN_ENV, telegramHookSecret, telegramPushUrl, } from "./telegram.js";
+import { bridgePass, clearBotToken, createTransport, followBridge, hashPairingCode, loadBotToken, mintPairingCode, networkFence, networkFenceLine, redactToken, saveBotToken, PAIRING_TTL_MS, TOKEN_ENV, telegramHookSecret, telegramPushUrl, } from "./telegram.js";
 import { scanRepo } from "./capscan.js";
 import { computeGaps, describeCapability } from "./gaps.js";
 import { ask, askHidden, confirm, interactive, underAgent } from "./prompt.js";
@@ -637,6 +639,8 @@ export const OPERATE_VALUE_FLAGS = new Set([
     "replaced-by", "replaces",
     // Check levels: a project's level, the quick command, a task's choice.
     "quick", "level", "checks",
+    // lead say: the task the lead's words are about.
+    "task",
 ]);
 export const OPERATE_BOOLEAN_FLAGS = new Set([
     "json", "yes", "all", "local", "history", "latest-watch", "dry-run", "file", "allow-paid-fallback",
@@ -820,6 +824,7 @@ export async function runOperate(command, argv, write, options = {}) {
             ...(options.agentRunner === undefined ? {} : { agentRunner: options.agentRunner }),
             ...(options.gitRunner === undefined ? {} : { gitRunner: options.gitRunner }),
             ...(options.telegramTransport === undefined ? {} : { telegramTransport: options.telegramTransport }),
+            ...(options.telegramEnv === undefined ? {} : { telegramEnv: options.telegramEnv }),
             ...(options.publishExec === undefined ? {} : { publishExec: options.publishExec }),
             ...(options.dispatchAdapter === undefined ? {} : { dispatchAdapter: options.dispatchAdapter }),
             ...(options.flowTriggerIo === undefined ? {} : { flowTriggerIo: options.flowTriggerIo }),
@@ -966,6 +971,9 @@ async function dispatch(command, positional, flags, context) {
                 return projectConcurrencyCommand(positional, flags, context);
             return runProjectCommand(positional, flags, context);
         case "assignment":
+            // The person's own lead (its lead token) claims as the lead; coordinator credentials keep their own path.
+            if (positional[0] === "claim" && currentActor()?.lead === true && !flags.has("token-env") && !flags.has("token-file"))
+                return leadClaimCommand(positional, flags, context);
             return runAssignmentCommand(positional, flags, context);
         case "knowledge":
             return runKnowledgeCommand(positional, flags, { ...context, now: context.clock() });
@@ -7288,6 +7296,52 @@ async function daemonCommand(positional, flags, context) {
 const WATCH_LEASE_MS = 90_000;
 const WATCH_HEARTBEAT_MS = 30_000;
 /** The start repair runs once per process, not once per project loop. */
+/**
+ * The Telegram follower: one actor on the wire that sends notifications and
+ * replies and reads what arrives, all over the same transport. Null when no
+ * bot token is saved, or when this process's network is fenced (it says so
+ * once instead of failing every send).
+ */
+function startTelegramFollower(args) {
+    const { context, progress, label } = args;
+    const source = loadBotToken(process.env, context.telegramTokenFile);
+    if (source === null)
+        return null;
+    const fence = networkFence(context.telegramEnv ?? (context.telegramTransport === undefined ? process.env : {}));
+    if (fence !== null) {
+        progress(networkFenceLine(fence));
+        return null;
+    }
+    const transport = context.telegramTransport ?? createTransport(source.token);
+    // v98: with a public hooks address (Tailscale Funnel covers /hooks), Telegram pushes updates to it instead.
+    const pushUrl = telegramPushUrl(readHooksBase(dirname(context.databaseFile)));
+    return followBridge(context.store, {
+        push: pushUrl === null ? null : { url: pushUrl, secret: telegramHookSecret(dirname(context.databaseFile), true) },
+        readProjects: telegramReadProjects(context),
+        canDeliver: telegramCanDeliver(context, source.token),
+        conversation: telegramConversation(context, args.publicUrl === undefined ? {} : { serverOrigin: args.publicUrl }),
+        botId: source.botId,
+        transport,
+        signal: args.signal,
+        ...(args.owner === undefined ? {} : { owner: args.owner }),
+        onCycle: cycle => {
+            // progress(), not write(): under --json this line went to stdout
+            // BESIDE the final envelope — the one stdout contamination in the
+            // watch (round-4 finding 12).
+            progress(`${label} sent ${cycle.sent}, answered ${cycle.answered}, paired ${cycle.paired}` +
+                ((cycle.statusReplies ?? 0) > 0 ? `, status replies ${cycle.statusReplies}` : "") +
+                ((cycle.chatQueued ?? 0) > 0 ? `, chat received ${cycle.chatQueued}` : "") +
+                ((cycle.chatAnswered ?? 0) > 0 ? `, chat replied ${cycle.chatAnswered}` : "") +
+                ((cycle.chatConfirmed ?? 0) > 0 ? `, chat confirmed ${cycle.chatConfirmed}` : "") +
+                (cycle.problems.length > 0 ? ` — ${cycle.problems.length} problem(s): ${cycle.problems[0].slice(0, 200)}` : ""));
+        },
+    }).catch(error => {
+        progress(`${args.died.prefix}the telegram follower died — ${describe(error)}; ${args.died.then}`);
+        return null;
+    });
+}
+/** How long a stopping service waits for the aborted Telegram follower. */
+const TELEGRAM_STOP_WAIT_MS = 5_000;
 let staleStatusesRepaired = false;
 async function runWatchLoop(args) {
     const { context, flags, runner, token, repo, progress } = args;
@@ -7366,38 +7420,13 @@ async function runWatchLoop(args) {
     // moment they arrive, and answering bumps the wake sequence, so the very
     // loop below wakes and resumes the freed task — phone to build, seconds.
     // The poll lease keeps this the only live poller; a cron `bridge
-    // telegram` overlapping it loses the lease race and reports busy.
-    let follower = null;
-    const followSource = loadBotToken(process.env, context.telegramTokenFile);
-    if (followSource !== null) {
-        const transport = context.telegramTransport ?? createTransport(followSource.token);
-        const publicUrl = text(flags, "public-url");
-        // v98: with a public hooks address (Tailscale Funnel covers /hooks), Telegram pushes updates to it instead.
-        const pushUrl = telegramPushUrl(readHooksBase(dirname(context.databaseFile)));
-        follower = followBridge(store, {
-            push: pushUrl === null ? null : { url: pushUrl, secret: telegramHookSecret(dirname(context.databaseFile), true) },
-            readProjects: telegramReadProjects(context),
-            canDeliver: telegramCanDeliver(context, followSource.token),
-            conversation: telegramConversation(context, publicUrl === undefined ? {} : { serverOrigin: publicUrl }),
-            botId: followSource.botId,
-            transport,
-            signal: followController.signal,
-            onCycle: cycle => {
-                // progress(), not write(): under --json this line went to stdout
-                // BESIDE the final envelope — the one stdout contamination in the
-                // watch (round-4 finding 12).
-                progress(`watch: bridge sent ${cycle.sent}, answered ${cycle.answered}, paired ${cycle.paired}` +
-                    ((cycle.statusReplies ?? 0) > 0 ? `, status replies ${cycle.statusReplies}` : "") +
-                    ((cycle.chatQueued ?? 0) > 0 ? `, chat received ${cycle.chatQueued}` : "") +
-                    ((cycle.chatAnswered ?? 0) > 0 ? `, chat replied ${cycle.chatAnswered}` : "") +
-                    ((cycle.chatConfirmed ?? 0) > 0 ? `, chat confirmed ${cycle.chatConfirmed}` : "") +
-                    (cycle.problems.length > 0 ? ` — ${cycle.problems.length} problem(s): ${cycle.problems[0].slice(0, 200)}` : ""));
-            },
-        }).catch(error => {
-            progress(`watch: the telegram follower died — ${describe(error)}; taps wait for the next watch`);
-            return null;
-        });
-    }
+    // telegram` overlapping it loses the lease race and reports busy. Under
+    // `up` the service runs the one follower itself and project loops leave
+    // Telegram to it.
+    const serviceBridge = args.serviceBridge === true;
+    const follower = serviceBridge
+        ? null
+        : startTelegramFollower({ context, publicUrl: text(flags, "public-url"), signal: followController.signal, progress, label: "watch: bridge", died: { prefix: "watch: ", then: "taps wait for the next watch" } });
     const slackFollower = followSlack({ store, dir: dirname(context.databaseFile), signal: followController.signal,
         readProjects: telegramReadProjects(context), evidenceRoot: context.evidenceRoot,
         ...(context.mateSeams?.subscriptionRunner ? { subscriptionRunner: context.mateSeams.subscriptionRunner } : {}),
@@ -7690,7 +7719,7 @@ async function runWatchLoop(args) {
             // pass is the fallback shape for a watch started before a token existed.
             if (follower === null && now - lastBridge >= bridgeEveryMs) {
                 lastBridge = now;
-                const source = loadBotToken(process.env, context.telegramTokenFile);
+                const source = serviceBridge ? null : loadBotToken(process.env, context.telegramTokenFile);
                 const dir = dirname(context.databaseFile);
                 // Exactly ONE service carries the pages — the chosen primary, or
                 // the sensible implicit one. Telegram keeps draining taps and
@@ -8467,6 +8496,10 @@ async function upCommand(flags, context) {
         resolveStopped();
         for (const controller of followControllers)
             controller.abort();
+        // The coding owner record is released first, whatever else is still
+        // finishing: launchd kills a service that outlasts its exit window, and a
+        // killed process cannot release it. Its outcome is read again at close.
+        console_.server.closeCoding().catch(() => { });
         const building = store.liveClaimCount(runnerName, clock());
         if (building > 0) {
             progress(`Stopping: ${building} build(s) running. Waiting up to ${Math.round(stopGraceMs / 1000)}s for them to finish; any still running then is saved and resumes when the builder starts again.`);
@@ -8538,6 +8571,7 @@ async function upCommand(flags, context) {
             onFollowController: controller => followControllers.push(controller),
             containmentLines,
             passes: projectPasses,
+            serviceBridge: true,
             onReady: () => {
                 markReady();
                 if (bind)
@@ -8557,6 +8591,37 @@ async function upCommand(flags, context) {
         await ready;
     };
     await Promise.all(repos.map(repo => launchRepo(repo, false)));
+    // Telegram: one follower for the whole service, never one per project
+    // loop. Replies and notifications go out from it, over the same transport
+    // in the same cycle (Oct 2: a reply sent by a project loop's own follower
+    // failed "fetch failed" while notifications went out). A token saved
+    // while the service runs connects within seconds; a follower that dies
+    // is started again.
+    const telegramController = new AbortController();
+    followControllers.push(telegramController);
+    const telegramSupervisor = (async () => {
+        const pause = (ms) => new Promise(resolvePause => {
+            const timer = setTimeout(done, ms);
+            function done() { clearTimeout(timer); telegramController.signal.removeEventListener("abort", done); resolvePause(); }
+            // An aborted signal never fires again: without this a stop waited the whole pause.
+            if (telegramController.signal.aborted)
+                done();
+            else
+                telegramController.signal.addEventListener("abort", done, { once: true });
+        });
+        while (!stopping && !telegramController.signal.aborted) {
+            const follower = startTelegramFollower({
+                context, publicUrl: text(flags, "public-url"), signal: telegramController.signal, progress, label: "telegram:",
+                died: { prefix: "", then: "starting it again" }, owner: `service-${randomUUID()}`,
+            });
+            if (follower !== null)
+                await follower;
+            // Without a token (or on a fenced network) look again shortly; the fence line is said once.
+            if (follower === null && loadBotToken(process.env, context.telegramTokenFile) !== null)
+                break;
+            await pause(follower === null ? 2_000 : 5_000);
+        }
+    })();
     const dynamicCeiling = resolveCeiling(repos, projectRoots).ceiling;
     const rejected = new Set();
     const registrySupervisor = (async () => {
@@ -8691,6 +8756,14 @@ async function upCommand(flags, context) {
     await stopped;
     await registrySupervisor;
     await Promise.all([...loopResults.values()]);
+    // The follower was aborted with the stop. A send or a chat turn it is still
+    // finishing keeps its own durable record; the service does not wait past
+    // this for it.
+    await new Promise(done => {
+        const timer = setTimeout(done, TELEGRAM_STOP_WAIT_MS);
+        const finish = () => { clearTimeout(timer); done(); };
+        void telegramSupervisor.then(finish, finish);
+    });
     clearInterval(runnerHeartbeat);
     if (runTimer !== undefined)
         clearTimeout(runTimer);
@@ -8738,6 +8811,7 @@ async function upCommand(flags, context) {
  *   bridge telegram token [<bot-token>|--clear]   set the credential file
  *   bridge telegram status
  *   bridge telegram digest [--every 30m|2h|24h | --off]   away mode: routine facts batch, decisions still page
+ *   bridge telegram retry                send unsent assistant replies again now
  *
  * The bot token comes from ${TOKEN_ENV} or the credential file this command
  * writes (0600, beside the database). Cron the pass right after tick; a
@@ -8754,7 +8828,14 @@ async function bridgeCommand(positional, flags, context) {
         return demoFence;
     const [channel, action] = positional;
     if (channel !== "telegram") {
-        return fail(write, json, "bridge", "usage", "`toolroll bridge telegram [pair|unpair|token|status|digest]`", EXIT.usage);
+        return fail(write, json, "bridge", "usage", "`toolroll bridge telegram [pair|unpair|token|status|digest|retry]`", EXIT.usage);
+    }
+    if (action === "retry") {
+        // Replies already written and fenced on the pairing like every send: this only moves their next attempt to now.
+        const retried = store.retryTelegramReplies(null, clock());
+        return succeed(write, json, "bridge retry", { retried }, () => [
+            retried === 0 ? "No unsent Telegram replies." : `Sending ${retried} Telegram ${retried === 1 ? "reply" : "replies"} again on the next bridge pass.`,
+        ]);
     }
     if (action === "token") {
         const value = positional[2];
@@ -8871,6 +8952,9 @@ async function bridgeCommand(positional, flags, context) {
     if (source === null) {
         return fail(write, json, "bridge", "no-token", `no bot token — set ${TOKEN_ENV}, run \`toolroll bridge telegram token <t>\`, or use the serve settings card`, EXIT.refused);
     }
+    const fenced = networkFence(context.telegramEnv ?? (context.telegramTransport === undefined ? process.env : {}));
+    if (fenced !== null)
+        return fail(write, json, "bridge", "network-fenced", networkFenceLine(fenced), EXIT.refused);
     const transport = context.telegramTransport ?? createTransport(source.token);
     // --follow: stay on the wire. One long-poll actor holds the poll lease;
     // an answer tapped on a phone lands in seconds instead of at the next
@@ -9569,7 +9653,9 @@ async function statusCommand(positional, flags, context) {
     }
     if (positional.length > 0)
         return fail(context.write, context.json, command, "usage", "Use `toolroll status [--json]`.", EXIT.usage);
-    const status = installationStatus(context.store, context.clock());
+    // Whose lead the status line follows: the lead's own person, else the remembered login; nobody shows no lead.
+    const viewer = currentActor()?.account ?? readLoginFile(join(dirname(context.databaseFile), UP_LOGIN_FILE))?.name ?? null;
+    const status = installationStatus(context.store, context.clock(), viewer);
     // One line, only when a newer Toolroll exists; offline or switched off says nothing.
     const current = PACKAGE_VERSION;
     const method = installMethod(context.installBin);
@@ -9588,7 +9674,18 @@ async function statusCommand(positional, flags, context) {
     const projects = projectBuildsStatus(context);
     const projectsLine = projects.length === 0 ? null
         : `Builds by project: ${projects.slice(0, 8).map(one => `${one.name} ${one.running} of ${one.limit}`).join(", ")}${projects.length > 8 ? ", …" : ""}`;
-    return succeed(context.write, context.json, command, { ...status, projects, ...update, ...integrations, ...updateWaiting }, () => [...(waiting === null ? [] : [waiting.words]), ...renderInstallationStatus(status), ...(projectsLine === null ? [] : [projectsLine]), ...(line === null ? [] : [line]), ...(brokenLine === null ? [] : [brokenLine])]);
+    // A Telegram reply written but still not sent after two minutes, with its Retry.
+    const unsent = context.store.unsentTelegramReplies(null, null, new Date(context.clock().getTime() - UNSENT_REPLY_MS));
+    const unsentLine = unsentRepliesLine(unsent);
+    const unsentReplies = unsent.length === 0 ? {} : { unsentReplies: unsent.map(one => ({ ...one, retry: "toolroll bridge telegram retry" })) };
+    return succeed(context.write, context.json, command, { ...status, projects, ...update, ...integrations, ...updateWaiting, ...unsentReplies }, () => [...(waiting === null ? [] : [waiting.words]), ...(unsentLine === null ? [] : [unsentLine]), ...renderInstallationStatus(status), ...(projectsLine === null ? [] : [projectsLine]), ...(line === null ? [] : [line]), ...(brokenLine === null ? [] : [brokenLine])]);
+}
+function unsentRepliesLine(unsent) {
+    if (unsent.length === 0)
+        return null;
+    const oldest = unsent[0];
+    const what = unsent.length === 1 ? "A Telegram reply hasn't" : `${unsent.length} Telegram replies haven't`;
+    return `${what} been sent since ${oldest.since.slice(11, 16)} UTC${oldest.error === null ? "" : ` (${oldest.error})`}. Retry: toolroll bridge telegram retry`;
 }
 /** Each known project's running builds against its limit: its own number, never past its workers' capacity. */
 function projectBuildsStatus(context) {
@@ -9698,6 +9795,19 @@ function taskCommand(positional, flags, context) {
         context.write(OPERATE_HELP);
         return EXIT.ok;
     }
+    // The lead's work on a task it took on counts as acting on it (lead-voice.ts): its claim stays fresh.
+    const actor = currentActor();
+    if (actor?.lead === true && rest[0] !== undefined && LEAD_WORK_VERBS.has(action)) {
+        const noted = (code) => { if (code === EXIT.ok)
+            noteLeadWork(context.store, actor, rest[0], action, context.clock()); return code; };
+        const done = taskAction(action, rest, flags, context);
+        return typeof done === "number" ? noted(done) : done.then(noted);
+    }
+    return taskAction(action, rest, flags, context);
+}
+/** Task verbs that are the lead working on a task, not reading it. */
+const LEAD_WORK_VERBS = new Set(["state", "steer", "reopen", "requeue", "regate", "repair", "resume", "stop", "scope", "approve", "plan", "checks", "revise", "hold", "unhold", "route", "require"]);
+function taskAction(action, rest, flags, context) {
     switch (action) {
         case "complete":
         case "revise":
@@ -10526,9 +10636,11 @@ function askTask(positional, flags, context) {
 async function leadCommand(positional, flags, context) {
     const { store, write, json } = context;
     const [action, ...extra] = positional;
+    if (action === "say")
+        return leadSayCommand(extra, flags, context);
     const command = "lead token";
     if (action !== "token" || extra.length > 0)
-        return fail(write, json, `lead ${action ?? ""}`.trim(), "usage", "`toolroll lead token [--revoke] --as <you> --token <password>`", EXIT.usage);
+        return fail(write, json, `lead ${action ?? ""}`.trim(), "usage", "`toolroll lead token [--revoke] --as <you> --token <password>` · `toolroll lead say \"<text>\" [--task <id>]` with the lead token", EXIT.usage);
     for (const name of flags.keys())
         if (!["as", "token", "revoke", "db", "json"].includes(name))
             return fail(write, json, command, "usage", `--${name} is not a lead token option.`, EXIT.usage);
@@ -10552,6 +10664,42 @@ async function leadCommand(positional, flags, context) {
         "it reaches you when the lead asks you (task ask), when it fails with nothing left to try, or for a security alert.",
     ]);
 }
+/** `lead say "<text>" [--task <id>]` with the lead token: one short message in its person's chat from "Your lead".
+ * Several within two minutes are one message. */
+function leadSayCommand(positional, flags, context) {
+    const { store, write, json } = context;
+    const command = "lead say";
+    for (const name of flags.keys())
+        if (!["task", "db", "json"].includes(name))
+            return fail(write, json, command, "usage", `--${name} is not a lead say option.`, EXIT.usage);
+    const task = flags.get("task");
+    if (positional.length === 0 || task === true)
+        return fail(write, json, command, "usage", "`toolroll lead say \"<what you're doing>\" [--task <id>]` with the lead token", EXIT.usage);
+    const actor = currentActor();
+    if (actor?.lead !== true)
+        return fail(write, json, command, "unauthenticated", "Only the lead speaks as the lead: pass its lead token (--token or TOOLROLL_LEAD_TOKEN).", EXIT.refused);
+    const said = leadSay(store, actor, positional.join(" "), task ?? null, context.clock());
+    if (!said.ok)
+        return fail(write, json, command, said.reason, said.message, said.reason === "usage" ? EXIT.usage : EXIT.refused);
+    return succeed(write, json, command, { owner: actor.account, task: task ?? null, joined: said.joined, notification: said.notification }, () => [said.joined ? `Added to your last message to ${actor.account}.` : `Told ${actor.account}.`]);
+}
+/** `assignment claim <task>` with the lead token: the task reads "Your lead is on it" and leaves Needs you until the
+ * lead completes it, hands it on (task ask), or two hours pass with no lead act on it. */
+function leadClaimCommand(positional, flags, context) {
+    const { store, write, json } = context;
+    const command = "assignment claim";
+    for (const name of flags.keys())
+        if (!["db", "json"].includes(name))
+            return fail(write, json, command, "usage", `--${name} is not an assignment claim option.`, EXIT.usage);
+    const id = positional[1];
+    if (id === undefined || positional.length !== 2)
+        return fail(write, json, command, "usage", "assignment claim takes exactly one task id.", EXIT.usage);
+    const actor = currentActor();
+    const claimed = leadClaim(store, actor, id, context.clock());
+    if (!claimed.ok)
+        return fail(write, json, command, claimed.reason, claimed.message, claimed.reason === "usage" ? EXIT.usage : EXIT.refused);
+    return succeed(write, json, command, { task: id, root: claimed.root, lead: claimed.claim }, () => [`${id} is yours: it reads "Your lead is on it" until you complete it, hand it on with task ask, or go two hours without acting on it.`]);
+}
 function blockTask(positional, flags, context) {
     const { store, write, json } = context;
     const id = positional[0];

package/dist/serve.d.ts

@@ -189,10 +189,14 @@ export type ServeOptions = {
 /** Where `up`'s one-time sign-in link points, and how long it works. */
 export declare const SIGN_IN_LINK_PATH = "/login/once/";
 export declare const SIGN_IN_LINK_MS: number;
-/** The console's server, and the one-time sign-in link `up` opens: a path on this server, or null for no such approver. */
+/** The console's server, and the one-time sign-in link `up` opens: a path on this server, or null for no such approver.
+ * closeCoding starts the coding shutdown on its own, ahead of the rest of a stop; close() awaits the same promise. */
 export type DecisionServer = Server & {
     mintSignInLink(account: string): string | null;
+    closeCoding(): Promise<void>;
 };
+/** How long a stop waits for teammates and the lead's follow pass before closing anyway. */
+export declare const SHUTDOWN_WAIT_MS = 5000;
 export declare function createDecisionServer(options: ServeOptions): DecisionServer;
 /**
  * A vscode://file href, or null (arc 6, finding 2): the link exists only