@agentshouse/kit 0.2.1-ca18b01951c3b → 0.2.1-cab5821cf0a77

package/dist/update.js

@@ -1,141 +1,127 @@
 import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
+import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { run } from './clis.js';
-import { kitHome, workspaceRoot } from './home.js';
-import { service, throughSudo } from './placement.js';
-function logged(error) {
-    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+import { downloadServed, servedRelease } from './building.js';
+import { KIT_RELEASE } from './clis.js';
+import { restart, updateLine } from './end.js';
+import { kitHome, readEnrolment } from './home.js';
+import { placedPrefix } from './placement.js';
+import { childEnvironment, relayOrigin } from './relay.js';
+const INSTALLER_BYTES = 1_000_000;
+// A release's Node.js, Kit package and adapters are about a hundred megabytes, so an hour carries them at thirty kilobytes a second, and a placement still running then has hung.
+const PLACEMENT_MS = 60 * 60_000;
+// A refused Kit is offline until its placement succeeds, so it tries again within five minutes of its Building or this computer recovering, while a placement that fails only after its hundred-megabyte download runs at most twelve times an hour.
+export const PLACEMENT_RETRY_MS = 5 * 60_000;
+const REFUSED = 'kit_bootstrap_refused: ';
+const OUTPUT_CHARACTERS = 4000;
+function causeOf(error) {
+    if (error instanceof TypeError && error.cause instanceof Error)
+        return `the Building did not answer: ${error.cause.message}`;
+    return error instanceof Error ? error.message : String(error);
 }
-function directory() {
-    return join(kitHome(), 'update');
-}
-function pending() {
-    return join(directory(), 'pending.json');
-}
-function outcome() {
-    return join(directory(), 'outcome');
-}
-function unit(inputId) {
-    return `house-kit-update-${inputId}`;
-}
-function manager() {
-    return service() === 'user' ? ['--user'] : [];
-}
-function elevated() {
-    return throughSudo() ? ['sudo', '-n'] : [];
-}
-function account() {
-    return throughSudo() ? [`--uid=${process.getuid()}`, `--gid=${process.getgid()}`] : [];
-}
-function placement() {
-    return service() === 'user' ? ['--workspace', workspaceRoot()] : ['--linux'];
-}
-function record() {
-    return `outcome=$1; shift; bash "$0" "$@"; printf %s "$?" > "$outcome"; ${[...elevated(), 'systemctl', ...manager(), 'start', 'house-kit.service'].join(' ')}`;
+function placing(installer, house, prefix, signal) {
+    return new Promise((resolve) => {
+        const relay = relayOrigin();
+        const child = spawn('bash', [installer, '--house', house, '--place', prefix], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...childEnvironment(), ...(relay === undefined ? {} : { HOUSE_KIT_RELAY: relay }) },
+            detached: true,
+        });
+        const stop = () => {
+            try {
+                process.kill(-child.pid, 'SIGKILL');
+            }
+            catch { }
+        };
+        signal.addEventListener('abort', stop, { once: true });
+        if (signal.aborted)
+            stop();
+        let output = '';
+        for (const stream of [child.stdout, child.stderr]) {
+            stream.setEncoding('utf8').on('data', (chunk) => {
+                output = (output + chunk).slice(-OUTPUT_CHARACTERS);
+            });
+        }
+        const ended = (failure) => {
+            signal.removeEventListener('abort', stop);
+            resolve(failure);
+        };
+        child.on('error', (error) => ended(error.message));
+        child.on('close', (status) => {
+            if (status === 0)
+                return ended(null);
+            if (signal.aborted)
+                return ended(`the placement did not end within ${PLACEMENT_MS / 1000} seconds`);
+            const lines = output.split('\n').filter((line) => line.trim() !== '');
+            const refused = lines.findLast((line) => line.startsWith(REFUSED));
+            ended(refused?.slice(REFUSED.length) ?? lines.at(-1) ?? `the placement ended with status ${status ?? 'a signal'}`);
+        });
+    });
 }
-async function pendingInput() {
-    try {
-        return JSON.parse(await readFile(pending(), 'utf8')).input_id;
+export class KitUpdate {
+    calls;
+    queue = Promise.resolve();
+    placed = null;
+    constructor(calls) {
+        this.calls = calls;
     }
-    catch {
-        return null;
+    take(call) {
+        void this.calls.carry(call.input_id, async () => ({ result: await this.queued(() => this.update(call.release)) }));
     }
-}
-async function recorded() {
-    const status = await readFile(outcome(), 'utf8').catch(() => null);
-    if (status === null)
-        return null;
-    return status.trim() === '0' ? {} : { refused: `the Kit bootstrap exited with ${status.trim()}` };
-}
-async function finished(inputId) {
-    for (;;) {
-        const ack = await recorded();
-        if (ack !== null)
-            return ack;
-        // systemctl answers at once, so ten seconds only bounds a stuck service manager.
-        if ((await run('systemctl', [...manager(), 'is-active', '--quiet', unit(inputId)], 10_000)).status !== 0) {
-            return (await recorded()) ?? { refused: 'the Kit bootstrap did not finish' };
+    async takeRefused(release) {
+        for (;;) {
+            const failure = await this.queued(async () => (this.placed === null ? this.place(release, 'served') : null));
+            if (failure === null)
+                restart(`Kit ${this.placed} is placed; its supervisor starts it`);
+            process.stderr.write(`kit: ${updateLine(`Kit ${KIT_RELEASE} stays offline and tries again in ${PLACEMENT_RETRY_MS / 60_000} minutes`)}\n`);
+            await new Promise((resolve) => setTimeout(resolve, PLACEMENT_RETRY_MS));
         }
-        // The bootstrap runs for minutes, so checking each second sees its outcome within a second at little cost.
-        await new Promise((resolve) => setTimeout(resolve, 1000));
     }
-}
-function rerun(script, inputId, flags) {
-    return new Promise((resolve) => {
-        const [command, ...args] = [
-            ...elevated(),
-            'systemd-run',
-            ...manager(),
-            ...account(),
-            '--wait',
-            '--collect',
-            '--quiet',
-            `--unit=${unit(inputId)}`,
-            `--setenv=HOME=${homedir()}`,
-            `--setenv=HOUSE_KIT_HOME=${kitHome()}`,
-            '/bin/sh',
-            '-c',
-            record(),
-            script,
-            outcome(),
-            ...placement(),
-            ...flags,
-        ];
-        const child = spawn(command, args, { stdio: ['ignore', 'ignore', 'inherit'] });
-        child.on('error', () => resolve({ refused: 'no service manager runs this Kit' }));
-        child.on('close', () => resolve(null));
-    });
-}
-export class Updates {
-    house;
-    held = new Set();
-    queue = Promise.resolve();
-    constructor(house) {
-        this.house = house;
+    placedRelease() {
+        return this.placed;
     }
-    async resumed() {
-        const inputId = await pendingInput();
-        if (inputId === null)
-            return;
-        await this.acknowledge(inputId, await finished(inputId));
+    queued(work) {
+        const taken = this.queue.then(work);
+        this.queue = taken.catch(() => undefined);
+        return taken;
     }
-    start(input) {
-        if (this.held.has(input.input_id))
-            return;
-        this.held.add(input.input_id);
-        this.queue = this.queue
-            .then(() => this.carry(input))
-            .then((ack) => this.acknowledge(input.input_id, ack))
-            .catch(logged)
-            .finally(() => this.held.delete(input.input_id));
+    async update(release) {
+        if (release === (this.placed ?? KIT_RELEASE))
+            return {};
+        if (this.placed !== null)
+            return { refused: `Kit ${this.placed} is placed and starts first, once no turn is open` };
+        const failure = await this.place(release, 'named');
+        if (failure !== null)
+            return { refused: failure };
+        process.stderr.write(`kit: Kit ${release} is placed; it starts once no turn is open\n`);
+        return {};
     }
-    async carry(input) {
-        if ((await pendingInput()) === input.input_id)
-            return finished(input.input_id);
-        const answer = await fetch(input.bootstrap);
-        if (!answer.ok)
-            return { refused: `the Kit bootstrap could not be downloaded: ${answer.status}` };
-        const script = Buffer.from(await answer.arrayBuffer());
-        if (createHash('sha256').update(script).digest('hex') !== input.sha256) {
-            return { refused: 'the Kit bootstrap does not match its sha256' };
+    async place(release, which) {
+        const signal = AbortSignal.timeout(PLACEMENT_MS);
+        let version = release;
+        let failure;
+        try {
+            const prefix = placedPrefix();
+            const served = await servedRelease(signal);
+            if (which === 'named' && served.version !== release)
+                throw new Error(`the Building serves Kit ${served.version}, not Kit ${release}`);
+            version = served.version;
+            if (version === KIT_RELEASE)
+                throw new Error(`the Building serves Kit ${KIT_RELEASE}, which this Kit runs`);
+            await mkdir(join(kitHome(), 'update'), { recursive: true, mode: 0o700 });
+            const installer = join(kitHome(), 'update', served.installer);
+            await downloadServed(served.installer, served.sha256, installer, signal, INSTALLER_BYTES);
+            failure = await placing(installer, (await readEnrolment()).house, prefix, signal);
         }
-        await mkdir(directory(), { recursive: true, mode: 0o700 });
-        const path = join(directory(), 'connect-linux.sh');
-        await writeFile(path, script, { mode: 0o700 });
-        await rm(outcome(), { force: true });
-        await writeFile(pending(), `${JSON.stringify({ input_id: input.input_id })}\n`, { mode: 0o600 });
-        return (await rerun(path, input.input_id, input.update_clis ? ['--update-clis'] : [])) ?? (await recorded()) ?? {
-            refused: 'the Kit bootstrap did not finish',
-        };
-    }
-    async acknowledge(inputId, ack) {
-        await this.house.deliver(`/kit/inputs/${inputId}/ack`, ack);
-        if ((await pendingInput()) !== inputId)
-            return;
-        await rm(pending(), { force: true });
-        await rm(outcome(), { force: true });
+        catch (error) {
+            failure = signal.aborted ? `the placement did not end within ${PLACEMENT_MS / 1000} seconds` : causeOf(error);
+        }
+        if (failure !== null) {
+            const refused = `Kit ${version} could not be placed: ${failure}`;
+            process.stderr.write(`kit: ${refused}\n`);
+            return refused;
+        }
+        this.placed = version;
+        return null;
     }
 }

package/dist/wire.js

@@ -1,6 +1,40 @@
+import { newerThanHouse, updateRequired } from './end.js';
+import { machine } from './placement.js';
 import { refusalOf } from './refusals.js';
-export const KIT_WIRE = 1;
+export const KIT_WIRE = 4;
 export const KIT_WIRE_HEADER = 'x-house-kit-wire';
-export function tooOld(text) {
-    return refusalOf(text)?.code === 'kit_update_required';
+let take = null;
+let taken = false;
+function unservedBy(text) {
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    const error = body?.error;
+    if (error?.code !== 'kit_update_required' && error?.code !== 'kit_newer_than_house')
+        return null;
+    return typeof error.release === 'string' ? error : null;
+}
+export function takeUnservedRelease(taking) {
+    take = taking;
+}
+export function unserved() {
+    return taken;
+}
+export function endUnserved(text) {
+    const refused = unservedBy(text);
+    if (refused !== null && take !== null) {
+        if (!taken) {
+            taken = true;
+            take(refused.release);
+        }
+        return;
+    }
+    if (refusalOf(text)?.code === 'kit_update_required')
+        updateRequired();
+    if (refused?.code === 'kit_newer_than_house')
+        newerThanHouse(refused.release, refused.commands[machine()]);
 }

package/dist/work.js

@@ -1,11 +1,11 @@
 import { randomUUID } from 'node:crypto';
 import { once } from 'node:events';
 import { readFileSync } from 'node:fs';
-import { mkdir, rm } from 'node:fs/promises';
+import { rm } from 'node:fs/promises';
 import { createServer } from 'node:net';
 import { join } from 'node:path';
 import { RUNNING_JOB } from './events.js';
-import { kitHome } from './home.js';
+import { kitHome, socketDirectory } from './home.js';
 const ENDED_TASK = new Set(['completed', 'failed', 'killed']);
 const SCHEDULING = new Set(['CronCreate', 'CronDelete', 'ScheduleWakeup']);
 const QUEUE_LIST = 'house-kit-queue-';
@@ -194,9 +194,7 @@ class CodexWork extends Work {
     proving = -1;
     proven = -1;
     async open(cli) {
-        const sockets = join(kitHome(), 'bridges');
-        await mkdir(sockets, { recursive: true, mode: 0o700 });
-        this.path = join(sockets, `${randomUUID()}.sock`);
+        this.path = join(socketDirectory(), `${randomUUID()}.sock`);
         this.server = createServer((socket) => this.connected(socket));
         this.server.listen(this.path);
         await once(this.server, 'listening');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-ca18b01951c3b",
-  "description": "House Kit connects an Environment to agents.house.",
+  "version": "0.2.1-cab5821cf0a77",
+  "description": "Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -12,28 +12,27 @@
     "kit": "dist/kit-main.js",
     "house": "dist/house-main.js"
   },
-  "exports": {
-    "./bootstrap": "./dist/bootstrap.json"
-  },
   "files": [
-    "dist",
-    "how-we-work.md",
-    "skills"
+    "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && node scripts/bootstrap-manifest.mjs",
+    "bootstrap-manifest": "node scripts/bootstrap-manifest.mjs",
+    "build": "tsc -p tsconfig.build.json",
     "engine": "mkdir -p tmp/engine && docker run --rm -v \"$PWD:/kit\" -w /kit alpine:3.24@sha256:294b683cb724975bec92580e1e685676bd4b50bda910ddb8c51d4cabeaec77e6 sh scripts/engine.sh tmp/engine",
-    "sync-skills": "node scripts/sync-skills.mjs",
+    "follow-skills": "node scripts/follow-skills.mjs",
+    "release-files": "node scripts/release-files.mjs",
     "test": "tsc -p tsconfig.json && vitest run"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "1.7.0",
-    "@agentshouse/mdmodel": "0.1.0-c68e2039f1ca8",
+    "@agentclientprotocol/sdk": "2.0.1",
+    "@agentshouse/mdmodel": "0.1.0-c4f4d37bc9d6a",
+    "@agentshouse/skills": "0.1.0-c4476617b690f",
+    "@lydell/node-pty": "1.2.0-beta.15",
     "yaml": "2.9.1"
   },
   "peerDependencies": {
-    "@agentclientprotocol/claude-agent-acp": "0.85.1",
-    "@agentclientprotocol/codex-acp": "2.1.1"
+    "@agentclientprotocol/claude-agent-acp": "0.94.0",
+    "@agentclientprotocol/codex-acp": "2.2.2"
   },
   "peerDependenciesMeta": {
     "@agentclientprotocol/claude-agent-acp": {
@@ -44,26 +43,26 @@
     }
   },
   "devDependencies": {
-    "@types/node": "24.13.6",
+    "@types/node": "24.19.2",
     "@types/ws": "8.18.2",
     "typescript": "7.0.2",
-    "vitest": "5.0.1",
+    "vitest": "5.0.5",
     "ws": "8.22.0"
   },
-  "packageManager": "npm@11.19.0",
+  "packageManager": "npm@11.19.1",
   "engines": {
-    "node": "24.21.0",
-    "npm": "11.19.0"
+    "node": "24.22.1",
+    "npm": "11.19.1"
   },
   "devEngines": {
     "runtime": {
       "name": "node",
-      "version": "24.21.0",
+      "version": "24.22.1",
       "onFail": "error"
     },
     "packageManager": {
       "name": "npm",
-      "version": "11.19.0",
+      "version": "11.19.1",
       "onFail": "error"
     }
   }

package/dist/bootstrap.json

@@ -1,24 +0,0 @@
-{
-  "schemaVersion": 2,
-  "version": "0.2.1-ca18b01951c3b",
-  "hosts": {
-    "macos": {
-      "asset": {
-        "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-ca18b01951c3b/connect-linux.sh"
-      }
-    },
-    "linux": {
-      "asset": {
-        "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-ca18b01951c3b/connect-linux.sh"
-      }
-    },
-    "windows": {
-      "asset": {
-        "name": "connect-windows.ps1",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-ca18b01951c3b/connect-windows.ps1"
-      }
-    }
-  }
-}

package/dist/clis-main.js

@@ -1,23 +0,0 @@
-import { setGlobalProxyFromEnv } from 'node:http';
-import { post } from './api.js';
-import { CLIS, below, locate, versionOf } from './clis.js';
-import { readEnrolment } from './home.js';
-setGlobalProxyFromEnv();
-try {
-    const { house, credential } = (await readEnrolment());
-    const { agents } = await post(house, '/kit/agents/desired', {}, credential);
-    for (const kind of agents) {
-        const cli = await locate(kind);
-        if (cli === null)
-            continue;
-        const release = await versionOf(cli);
-        if (release === null)
-            continue;
-        const { bin, minimum } = CLIS[kind];
-        process.stdout.write(`${[bin, cli, release, minimum, below(release, minimum) ? 'old' : 'current'].join('\t')}\n`);
-    }
-}
-catch (error) {
-    process.stderr.write(`kit: ${error.message}\n`);
-    process.exitCode = 1;
-}

package/how-we-work.md

@@ -1,33 +0,0 @@
-# How we work
-
-A Room is where information people share is kept; it is not the place for
-private information. Work goes into the Room it belongs to, or the First Room
-when none is named.
-
-Every House answer carries the `url` of what it names; send the User that link.
-
-The skills are already set up; never run `setup-matt-pocock-skills`.
-
-## Where skill output goes
-
-- Glossary (`GLOSSARY.md`): `glossary.md`
-- Decisions (ADRs): `decisions/NNNN-<slug>.md`
-- Plan (spec): `projects/<name>/plan.md`
-- Tasks (tickets): `projects/<name>/tasks/NN-<slug>.md`, with a
-  `Status:` line (`needs-triage`, `needs-info`, `ready-for-agent`,
-  `ready-for-human`, `wontfix`, or `done` once implemented), a
-  `Category:` line (`bug`, `enhancement`), a `Blocked by:` line and comments
-  under `## Comments`; triage takes no pull requests
-- Rejected requests (triage): `out-of-scope/<concept>.md`
-- Implementation notes (implement-spec): `projects/<name>/notes/`
-- PR bodies (pr): `projects/<name>/prs/<branch>.md`
-- Map (Wayfinding): `projects/<name>/map.md`, its tasks under
-  `tasks/` with `Type:`, `Status: claimed|resolved` and `Blocked by:` lines
-- Research: `research/<slug>.md`
-- Architecture reports (improve-codebase-architecture): `architecture/<slug>.html`
-- Handoffs: `handoffs/<slug>.md`
-- Questionnaires: `questionnaires/<slug>.md`
-- Retrospectives (retro): `retros/<date>-<slug>.md`
-- Wizards: `wizards/<slug>.sh`; the values they capture stay out of the Room
-- Learning: `learning/<topic>/`
-- Prototype: one HTML file with every variant on one page.

package/skills/ask-matt/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Matt Pocock
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/skills/ask-matt/PHASE-BOUNDARIES.md

@@ -1,55 +0,0 @@
-# Phase boundaries
-
-A **phase** is a chunk of work inside a session: the grilling, the implementation, the QA. The definition is fuzzy on purpose: a phase ends when you think *"ok, we're done with that"*.
-
-The **phase boundary** is the gap between two phases, and it is the only place this decision belongs. Mid-phase there is no decision to make: continue, or split the work that's left into subagents. Compacting mid-phase makes the agent lose the thread.
-
-## The five options
-
-| Option       | What it does                                                    |
-| ------------ | --------------------------------------------------------------- |
-| **Continue** | Stay in the session. No context switch at all.                    |
-| **`/clear`** | Empty the context window and start from nothing.                  |
-| **`/handoff`** | Write a portable markdown file and seed a session anywhere with it. |
-| **Subagent** | Send the task to its own context window and get a report back.     |
-| **`/compact`** | Compress this context and seed a fresh session with the summary.  |
-
-## The tree
-
-Work top to bottom at the boundary. The first **yes** wins.
-
-**1. Can you continue in this session?** Two things make the answer yes: the next phase needs this phase as a **primary source**, or you have enough [smart zone](https://www.aihero.dev/ai-coding-dictionary/smart-zone) left (~150k tokens) for the next phase to fit. Grilling → implementation is the standard yes: the implementation wants the reasoning verbatim, not a summary of it. Continue costs nothing and loses nothing, so rule it out before anything else.
-
-**2. Is the context irrelevant to what comes next?** Is everything in this session (the exploration, the decisions, the dead ends) disposable? If so, **`/clear`**. It is the cheapest move on the board: it takes no time and hands back the whole window. `/clear` also isn't terminal: the old session stays resumable.
-
-The cost of getting this wrong is one-way. Clear a *relevant* context and you lose the **why** behind what you built, and no amount of reading the diff back gets it returned.
-
-**3. Do you need to hand off?** `/handoff` is narrow. You need it only when you are:
-
-- swapping to a **new harness** (Claude → Codex),
-- moving to a **new directory** or repo,
-- sending the work to a **colleague**,
-- or forking a side task you found **mid-phase** without derailing what you're doing.
-
-That list is the whole clause. What `/handoff` buys is **portability**: a file that travels. If nothing is travelling, you don't need it.
-
-**4. Can the task be done AFK?** Is it scoped tightly enough to run with you away from the keyboard, no steering? Then send it to a **subagent** and leave this session untouched. Automated review is the standard case: the agent reads the diff and reports, and you aren't needed while it does.
-
-**5. Otherwise, `/compact`.** Relevant context, same harness, same directory, and you need to stay in the loop: this is where the tree lands, and it lands here often. Pass it an instruction (`/compact we're going to QA this area`) so the summary keeps what the next phase needs.
-
-`/compact` is the **default, not the first reach**. It sits at the bottom because the four questions above it are all cheaper or more precise. The failure mode when people start here is a fresh session that is confidently wrong about a decision the summary flattened.
-
-## Primary and secondary sources
-
-Every move except **Continue** turns a **primary source** into a **secondary source**: the session as it happened, replaced by a summary of it. The trade is always the same shape:
-
-| Source                            | Information | Noise | Room to move |
-| --------------------------------- | ----------- | ----- | ------------ |
-| Primary (Continue)                | Full        | Lots  | Little       |
-| Secondary (`/compact`, `/handoff`) | Lossy       | Less  | Lots         |
-
-This is why question 1 comes first. You only pay the lossiness when staying costs more than it saves.
-
-## These are judgement calls
-
-The questions are not objective: each has taste in it, and the same boundary can go two ways on two days. The value is in asking them **in order**, at the boundary rather than in the middle of the work.