@kylecheng3146/agent-ops 0.7.2 → 0.8.0

package/dist/runtime/src/office/collect.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
-import { readdir, readFile, realpath, stat } from "node:fs/promises";
+import { lstat, readdir, readFile, realpath, stat } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { readWorktreeRecord, parseWorktreeListPorcelain } from "../parallel/service.js";
@@ -10,9 +10,11 @@ import { parseTaskStateSource } from "../task/store.js";
 import { findReviewAttestation } from "../review/attestation.js";
 import { FileEvidenceStore } from "../verify/evidence.js";
 import { readPrivateFile } from "../security/permissions.js";
+import { redactSecrets } from "../security/redact.js";
 import { OFFICE_SESSION_RETENTION_MS, readOfficeSessions } from "./sessions.js";
 import { buildOfficeSnapshot, mergeOfficeSnapshots } from "./snapshot.js";
 import { forgetOfficeRepos, readOfficeRepos } from "./repos.js";
+import { readActivities } from "./activity.js";
 const run = promisify(execFile);
 export const officeGit = async (cwd, args) => {
     try {
@@ -23,6 +25,119 @@ export const officeGit = async (cwd, args) => {
     }
 };
 const MAX_PATHS = 200;
+// The office reads two kinds of proof files, never anything a task record merely points at:
+// acceptance execution artifacts (by an exact path shape) and review report artifacts (by an exact name).
+const ACCEPTANCE_ARTIFACT = /^\.agent-ops\/tasks\/acceptance\/[a-f0-9]{64}\.json$/u;
+const TASK_ID = /^[A-Za-z0-9._-]{1,128}$/u;
+const REVIEW_FILE_BYTES = 512 * 1024, ACCEPTANCE_FILE_BYTES = 4 * 1024 * 1024, REVIEW_FILES = 20, FINDINGS = 10;
+const OUTPUT_BYTES = 2048, SUMMARY_BYTES = 1024, TITLE_BYTES = 300, DETAILS_BYTES = 1024, ADVICE_BYTES = 512;
+/** At most `limit` bytes of UTF-8 text from the start, cut on a character boundary; the ellipsis counts. */
+function headBytes(value, limit) {
+    if (Buffer.byteLength(value, "utf8") <= limit)
+        return value;
+    let out = "", used = 0;
+    for (const character of value) {
+        const size = Buffer.byteLength(character, "utf8");
+        if (used + size > limit - 3)
+            break;
+        out += character;
+        used += size;
+    }
+    return out + "…";
+}
+/** At most `limit` bytes of UTF-8 text from the end, cut on a character boundary; the ellipsis counts. */
+function tailBytes(value, limit) {
+    if (Buffer.byteLength(value, "utf8") <= limit)
+        return value;
+    const characters = [...value];
+    let used = 0, start = characters.length;
+    while (start > 0) {
+        const size = Buffer.byteLength(characters[start - 1], "utf8");
+        if (used + size > limit - 3)
+            break;
+        used += size;
+        start--;
+    }
+    return "…" + characters.slice(start).join("");
+}
+/** Redact first, then cut, so a cut can never expose part of a secret the full text would hide. */
+const clean = (value, limit) => typeof value === "string" ? headBytes(redactSecrets(value), limit) : "";
+/** A private proof file read without following links, or null when absent, oversized or unreadable. */
+async function proofFile(root, relative, limit) {
+    const source = await readPrivateFile(join(root, ...relative.split("/")), root).catch(() => null);
+    if (source === null || Buffer.byteLength(source, "utf8") > limit)
+        return null;
+    try {
+        return JSON.parse(source);
+    }
+    catch {
+        return null;
+    }
+}
+async function failureOutput(root, evidence) {
+    const artifact = evidence?.acceptance?.executionArtifact;
+    if (artifact === undefined || !ACCEPTANCE_ARTIFACT.test(artifact))
+        return null;
+    const source = await readPrivateFile(join(root, ...artifact.split("/")), root).catch(() => null);
+    // An execution artifact is named by its own content hash; a swapped or edited file no longer matches.
+    if (source === null || Buffer.byteLength(source, "utf8") > ACCEPTANCE_FILE_BYTES ||
+        artifact !== ".agent-ops/tasks/acceptance/" + createHash("sha256").update(source).digest("hex") + ".json")
+        return null;
+    let value;
+    try {
+        value = JSON.parse(source);
+    }
+    catch {
+        return null;
+    }
+    const output = typeof value === "object" && value !== null ? value.output : null;
+    if (typeof output !== "object" || output === null)
+        return null;
+    const { stdout, stderr } = output;
+    const text = [stdout, stderr].filter((part) => typeof part === "string" && part.length > 0).join("\n");
+    return text.length === 0 ? null : tailBytes(redactSecrets(text), OUTPUT_BYTES);
+}
+function reviewRound(target, report) {
+    if (typeof report !== "object" || report === null)
+        return null;
+    const value = report;
+    const findings = (Array.isArray(value.findings) ? value.findings : []).slice(0, FINDINGS).map(item => {
+        const finding = (typeof item === "object" && item !== null ? item : {});
+        return { severity: clean(finding.severity, 32), blocking: finding.blocking === true, title: clean(finding.title, TITLE_BYTES),
+            details: clean(finding.details, DETAILS_BYTES), recommendation: clean(finding.recommendation, ADVICE_BYTES) };
+    });
+    return { target: clean(target, 32) || "unknown", summary: clean(value.summary, SUMMARY_BYTES), findings };
+}
+/** The newest review report artifact for a task, or null. */
+async function latestReview(root, taskId) {
+    if (!TASK_ID.test(taskId))
+        return null;
+    const directory = join(root, ".agent-ops", "reviews"), suffix = "." + taskId + ".reports.json";
+    const names = (await readdir(directory).catch(() => []))
+        .filter(name => name.endsWith(suffix) && /^[a-f0-9]{64}$/u.test(name.slice(0, -suffix.length)));
+    const dated = await Promise.all(names.map(async (name) => {
+        const info = await lstat(join(directory, name)).catch(() => null);
+        return info === null || !info.isFile() ? null : { name, at: info.mtimeMs };
+    }));
+    let best = null;
+    for (const entry of dated.filter((item) => item !== null).sort((a, b) => b.at - a.at).slice(0, REVIEW_FILES)) {
+        const value = await proofFile(root, ".agent-ops/reviews/" + entry.name, REVIEW_FILE_BYTES);
+        if (typeof value !== "object" || value === null)
+            continue;
+        const report = value;
+        const status = report.status === "PASS" || report.status === "FAIL" || report.status === "NOT_RUN" ? report.status : null;
+        if (status === null || typeof report.createdAt !== "string" || Number.isNaN(Date.parse(report.createdAt)))
+            continue;
+        if (best !== null && Date.parse(best.createdAt) >= Date.parse(report.createdAt))
+            continue;
+        const adversarial = typeof report.adversarial === "object" && report.adversarial !== null ? report.adversarial : null;
+        const rounds = [reviewRound(report.harness, report.report), adversarial === null ? null : reviewRound(adversarial.target, adversarial.report)]
+            .filter((round) => round !== null);
+        best = { status, createdAt: report.createdAt, reason: typeof report.reason === "string" ? clean(report.reason, SUMMARY_BYTES) : null, rounds,
+            refuted: adversarial === null ? null : adversarial.refuted === true };
+    }
+    return best;
+}
 const OFFICE_PHASES = new Set(["planning", "implementing", "verifying", "reviewing", "integrating", "unknown"]);
 function officePhase(value) {
     return value === undefined ? undefined : OFFICE_PHASES.has(value) ? value : "unknown";
@@ -63,13 +178,21 @@ async function taskView(root, record) {
     }
     const evidence = [...latest.values()].map(item => item.evidence);
     let passed = 0;
+    const criteria = [];
     for (const criterion of record.task.criteria) {
         const rows = evidence.filter(item => item.criterionId === criterion.id);
-        const result = criteriaProgress([criterion], {
-            results: rows.map(item => ({ status: item.status })),
-            acceptance: rows.flatMap(item => item.acceptance?.checks.map(check => ({ criterionId: criterion.id, status: check.status })) ?? [])
-        });
+        const checks = rows.flatMap(item => item.acceptance?.checks.map(check => ({ criterionId: criterion.id, status: check.status })) ?? []);
+        const result = criteriaProgress([criterion], { results: rows.map(item => ({ status: item.status })), acceptance: checks });
         passed += result.passed;
+        // The row is PASS exactly when it counts toward `passed`, so the list and the n/m summary agree.
+        const seen = [...rows.map(item => item.status), ...checks.map(check => check.status)];
+        const status = result.passed === 1 ? "PASS" : seen.includes("FAIL") ? "FAIL" : seen.includes("UNKNOWN") ? "UNKNOWN" : null;
+        const last = rows.reduce((current, item) => current === null || Date.parse(item.finishedAt) >= Date.parse(current.finishedAt) ? item : current, null);
+        const failing = status === "FAIL" || status === "UNKNOWN" ? rows.filter(row => row.acceptance?.executionArtifact !== undefined && row.status !== "PASS")
+            .reduce((current, item) => current === null || Date.parse(item.finishedAt) >= Date.parse(current.finishedAt) ? item : current, null) : null;
+        criteria.push({ id: criterion.id, description: criterion.description, status, finishedAt: last?.finishedAt ?? null,
+            failureClass: status === "PASS" || last === null ? null : last.failureClass, exitCode: status === "PASS" ? null : last?.exitCode ?? null,
+            output: await failureOutput(root, failing) });
     }
     const total = record.task.criteria.length;
     const verify = evidence.some(item => item.status === "FAIL" || item.status === "UNKNOWN")
@@ -90,7 +213,8 @@ async function taskView(root, record) {
                 : evidence.length > 0
                     ? "implementing"
                     : "planning";
-    return { taskId: record.task.id, status: record.status, phase, progress, completedAt: record.completedAt };
+    return { taskId: record.task.id, status: record.status, phase, progress, title: record.task.title, criteria,
+        review: await latestReview(root, record.task.id), completedAt: record.completedAt };
 }
 async function taskState(root) {
     const source = await readPrivateFile(join(root, ".agent-ops", "tasks", "state.json"), root).catch(() => null);
@@ -141,6 +265,21 @@ export async function worktreeDiff(git, path, base) {
     }
     return { files: paths.length, insertions, deletions, paths: paths.slice(0, MAX_PATHS), recent: recent ?? paths[0] ?? null };
 }
+/**
+ * Work already in the target branch by some route other than `worktree finish`
+ * (a merged pull request): commits past its base, all reachable from the
+ * target, and nothing uncommitted. A fresh worktree (HEAD at base) is not merged.
+ * ponytail: ancestry only, so a squash-merged branch stays visible until removed.
+ */
+export async function worktreeMerged(git, path, base, targetBranch) {
+    const head = (await git(path, ["rev-parse", "HEAD"])).stdout.trim();
+    if (!/^[0-9a-f]{40,64}$/u.test(head) || head === base || !/^[A-Za-z0-9._/-]{1,128}$/u.test(targetBranch))
+        return false;
+    if ((await git(path, ["merge-base", "--is-ancestor", head, `refs/heads/${targetBranch}`])).exitCode !== 0)
+        return false;
+    const status = await git(path, ["status", "--porcelain"]);
+    return status.exitCode === 0 && status.stdout.trim() === "";
+}
 /** Each run is read on its own: one unreadable run must not hide the building. */
 export async function readRuns(commonDir) {
     const directory = join(commonDir, "agent-ops", "runs");
@@ -171,7 +310,7 @@ async function readSessions(mainRoot, commonDir, now, trustedRoots = [mainRoot])
                 : observedPhase ?? task.phase;
         return task === null
             ? session
-            : { ...session, taskId: task.taskId, phase, taskStatus: task.status, progress: task.progress,
+            : { ...session, taskId: task.taskId, phase, taskStatus: task.status, progress: task.progress, title: task.title, criteria: task.criteria, review: task.review,
                 completedAt: task.completedAt, status: task.status === "complete" ? "idle" : session.status };
     }));
     return views.filter(session => session.completedAt === undefined || session.completedAt === null ||
@@ -207,19 +346,28 @@ export async function readReviewSlots(commonDir) {
 export async function collectOfficeInput(mainRoot, commonDir, git = officeGit, now = Date.now()) {
     const worktrees = [];
     const discovered = [];
+    const merged = new Set();
     for (const entry of parseWorktreeListPorcelain((await git(mainRoot, ["worktree", "list", "--porcelain"])).stdout)) {
         const path = await realpath(resolve(entry.path)).catch(() => resolve(entry.path));
         const record = await readWorktreeRecord(path).catch(() => null);
         if (record === null)
             continue;
+        if (record.runId === undefined && await worktreeMerged(git, path, record.base, record.targetBranch)) {
+            // A subagent's worktree shares its coordinator's session, which stays.
+            if (record.agentId === undefined)
+                merged.add(record.sessionId);
+            continue;
+        }
         discovered.push({ path, record });
     }
-    const sessions = await readSessions(mainRoot, commonDir, now, [mainRoot, ...discovered.map(item => item.path)]);
+    const sessions = (await readSessions(mainRoot, commonDir, now, [mainRoot, ...discovered.map(item => item.path)])).filter(session => !merged.has(session.sessionId));
     for (const { path, record } of discovered) {
         const session = sessions.find(item => item.sessionId === record.sessionId);
         const task = await attachedTaskView(path, record.sessionId, session?.taskId);
+        const ahead = /^[0-9a-f]{40,64}$/u.test(record.base) ? Number.parseInt((await git(path, ["rev-list", "--count", record.base + "..HEAD"])).stdout.trim(), 10) : Number.NaN;
         const base = { name: record.name, path, branch: record.branch, sessionId: record.sessionId,
-            ...(record.runId === undefined ? {} : { runId: record.runId }), diff: await worktreeDiff(git, path, record.base) };
+            ...(record.runId === undefined ? {} : { runId: record.runId }), diff: await worktreeDiff(git, path, record.base),
+            ...(/^[0-9a-f]{40,64}$/u.test(record.base) ? { base: record.base.slice(0, 12) } : {}), ...(Number.isInteger(ahead) && ahead >= 0 ? { ahead } : {}) };
         const observedPhase = session?.phase === undefined ? undefined : officePhase(session.phase) ?? "unknown";
         const phase = task === null
             ? observedPhase
@@ -229,10 +377,11 @@ export async function collectOfficeInput(mainRoot, commonDir, git = officeGit, n
         worktrees.push(task === null
             ? session === undefined ? base : { ...base, ...(officePhase(session.phase) === undefined ? {} : { phase: officePhase(session.phase) }), status: session.status,
                 ...(session.taskId === undefined ? {} : { taskId: session.taskId }), host: session.host ?? session.harness }
-            : { ...base, phase, status: task.status, taskId: task.taskId, progress: task.progress,
+            : { ...base, phase, status: task.status, taskId: task.taskId, progress: task.progress, title: task.title, criteria: task.criteria, review: task.review,
                 ...(task.completedAt === null ? {} : { completedAt: task.completedAt }), host: session?.host ?? session?.harness });
     }
-    return { runs: await readRuns(commonDir), worktrees, sessions, reviews: await readReviewSlots(commonDir), now };
+    return { runs: await readRuns(commonDir), worktrees, sessions, reviews: await readReviewSlots(commonDir),
+        activities: await readActivities(commonDir).catch(() => []), now };
 }
 /**
  * Every registered repository that still exists and still opts in, as one

package/dist/runtime/src/office/layout.js

@@ -0,0 +1,200 @@
+import { roomSprites } from "./art.js";
+export const ROOM_ORDER = ["planning", "implementing", "verifying", "reviewing", "integrating", "lobby"];
+const W = 576, H = 320;
+const WALL = 40, ROW1 = { top: 40, bottom: 152 }, MIDDLE = { top: 152, bottom: 192 }, ROW2 = { top: 192, bottom: 312 };
+const VERTICAL = [188, 380], THICK = 8, COLUMN = [4, 196, 388], ROOM_W = 184;
+/** Bounding box of the opaque pixels in the bottom `rows` rows of a sprite. */
+function baseOf(rows, depth = 10) {
+    let left = Infinity, right = -1, top = Infinity;
+    for (let y = Math.max(0, rows.length - depth); y < rows.length; y++)
+        for (let x = 0; x < rows[y].length; x++) {
+            if (rows[y][x] === ".")
+                continue;
+            left = Math.min(left, x);
+            right = Math.max(right, x);
+            top = Math.min(top, y);
+        }
+    return right < 0 ? { x: 0, y: rows.length, w: 0, h: 0 } : { x: left, y: top, w: right - left + 1, h: rows.length - top };
+}
+export function officeLayout() {
+    const sprites = roomSprites();
+    const room = (id, row, column, floor, slots) => {
+        const band = row === 1 ? ROW1 : ROW2;
+        return { id, x: COLUMN[column], y: band.top, w: ROOM_W, h: band.bottom - band.top, floor, slots };
+    };
+    // Feet sit on the path-finding grid so a walk ends exactly on them.
+    const onGrid = (p) => ({ x: Math.round(p.x / STEP) * STEP, y: Math.round(p.y / STEP) * STEP });
+    const stand = (x, y, pose = "down0") => ({ x, y, pose, z: y + 50, feet: onGrid({ x: x + 17, y: y + 49 }) });
+    const seat = (x, y, pose, z, feet) => ({ x, y, pose, z, feet: onGrid(feet) });
+    const rooms = [
+        room("planning", 1, 0, "carpet", [seat(9, 28, "down0", 69, { x: 30, y: 140 }), seat(43, 28, "down0", 69, { x: 64, y: 140 }), seat(77, 28, "down0", 69, { x: 98, y: 140 })]),
+        room("implementing", 1, 1, "carpet", [seat(228, 52, "up0", 99, { x: 245, y: 120 }), seat(318, 52, "up0", 99, { x: 345, y: 120 }), stand(240, 96)]),
+        room("verifying", 1, 2, "vinyl", [seat(480, 64, "up0", 113, { x: 497, y: 112 }), stand(406, 96), stand(452, 96)]),
+        room("reviewing", 2, 2, "carpet", [seat(516, 204, "down0", 223, { x: 520, y: 270 }), seat(428, 246, "down0", 271, { x: 446, y: 306 }), seat(502, 246, "down0", 271, { x: 520, y: 308 })]),
+        room("integrating", 2, 1, "vinyl", [seat(306, 206, "up0", 256, { x: 323, y: 254 }), stand(208, 254), stand(328, 254)]),
+        room("lobby", 2, 0, "checker", [seat(22, 202, "up0", 252, { x: 39, y: 252 }), stand(138, 210), stand(56, 240)])
+    ];
+    const items = [];
+    const put = (sprite, x, y, inRoom, extra = {}) => {
+        const rows = sprites[extra.variant === undefined ? sprite : sprite + "Pass"];
+        const footprint = (extra.foot ?? [baseOf(rows)]).map(r => ({ x: x + r.x, y: y + r.y, w: r.w, h: r.h })).filter(r => r.w > 0 && r.h > 0);
+        items.push({ sprite, x, y, z: extra.z ?? y + rows.length, room: inRoom, ...(extra.variant === undefined ? {} : { variant: extra.variant }), footprint });
+    };
+    // Cubicles are solid except the open front where the chair goes.
+    const cubicleFoot = [{ x: 0, y: 0, w: 86, h: 46 }, { x: 0, y: 46, w: 6, h: 12 }, { x: 80, y: 46, w: 6, h: 12 }];
+    // planning: meeting table against the wall, people seated behind it
+    [16, 50, 84].forEach(x => put("chairFront", x, 44, "planning"));
+    put("confTable", 6, 68, "planning");
+    put("board", 118, 42, "planning");
+    [22, 56, 90].forEach(x => put("chairBack", x, 100, "planning", { z: 128 }));
+    put("deskPlant", 158, 128, "planning");
+    // implementing: two cubicles on the wall; the floor in front stays open so both doors connect
+    put("cubicle", 198, 40, "implementing", { foot: cubicleFoot });
+    put("cubicleMirror", 288, 40, "implementing", { foot: cubicleFoot });
+    put("chairBack", 232, 70, "implementing", { z: 100 });
+    put("chairBack", 322, 70, "implementing", { z: 100 });
+    put("trash", 200, 136, "implementing");
+    put("plant", 300, 100, "implementing");
+    // verifying: racks, a test bench and filing along the wall
+    put("rackPass", 388, 46, "verifying");
+    put("rack", 416, 46, "verifying", { variant: "verify" });
+    put("bench", 460, 54, "verifying", { variant: "verify" });
+    put("filing", 548, 54, "verifying");
+    put("trash", 392, 136, "verifying");
+    put("stool", 504, 104, "verifying");
+    put("plant", 536, 100, "verifying");
+    // reviewing: bookcase and filing on the wall, the reviewer's desk, two armchairs
+    put("lowBookcase", 392, 180, "reviewing");
+    put("filing", 444, 178, "reviewing");
+    put("execDesk", 500, 222, "reviewing");
+    put("armchair", 432, 270, "reviewing");
+    put("coffeeTable", 462, 286, "reviewing");
+    put("armchair", 506, 270, "reviewing");
+    put("plant", 536, 258, "reviewing");
+    // integrating: shelving, copier, sorting table, a hand truck and stacked crates
+    put("metalShelf", 200, 178, "integrating");
+    put("copier", 256, 194, "integrating");
+    put("sortTable", 296, 202, "integrating");
+    put("handTruck", 356, 204, "integrating");
+    put("crates", 252, 258, "integrating");
+    put("trash", 236, 294, "integrating");
+    // lobby: kitchenette on the wall, sofa, cafe table, plant by the entrance
+    put("counter", 8, 184, "lobby");
+    put("fridge", 92, 176, "lobby");
+    put("vending", 116, 176, "lobby");
+    put("cooler", 146, 188, "lobby");
+    put("sofa", 84, 230, "lobby");
+    put("cafeTable", 120, 270, "lobby");
+    put("plant", 8, 258, "lobby");
+    put("trash", 92, 296, "lobby");
+    const decor = [
+        { sprite: "tv", x: 30, y: 3, wall: "back" }, { sprite: "frame", x: 112, y: 9, wall: "back" }, { sprite: "frame", x: 132, y: 13, wall: "back" },
+        { sprite: "blinds", x: 210, y: 4, wall: "back" }, { sprite: "clock", x: 281, y: 9, wall: "back" }, { sprite: "blinds", x: 320, y: 4, wall: "back" },
+        { sprite: "status", x: 400, y: 3, wall: "back", variant: "verify" }, { sprite: "poster", x: 520, y: 3, wall: "back" },
+        { sprite: "diploma", x: 404, y: 160, wall: "middle" }, { sprite: "diploma", x: 424, y: 163, wall: "middle" },
+        { sprite: "cubby", x: 258, y: 158, wall: "middle" }, { sprite: "clock", x: 60, y: 160, wall: "middle" }, { sprite: "frame", x: 152, y: 162, wall: "middle" }
+    ];
+    const side = (id, x, y, between) => ({ id, kind: "side", x, y, between, gap: { x, y: y + 3, w: THICK, h: 28 } });
+    const doors = [
+        side("planning-implementing", VERTICAL[0], 96, ["planning", "implementing"]),
+        side("implementing-verifying", VERTICAL[1], 96, ["implementing", "verifying"]),
+        { id: "verifying-reviewing", kind: "front", x: 468, y: MIDDLE.top + 2, between: ["verifying", "reviewing"], gap: { x: 470, y: MIDDLE.top, w: 26, h: MIDDLE.bottom - MIDDLE.top } },
+        side("reviewing-integrating", VERTICAL[1], 258, ["reviewing", "integrating"]),
+        side("integrating-lobby", VERTICAL[0], 258, ["integrating", "lobby"])
+    ];
+    const entrance = { x: 56, y: ROW2.bottom, w: 34, h: H - ROW2.bottom };
+    const area = (sprite, x, y) => ({ x, y, w: sprites[sprite][0].length, h: sprites[sprite].length });
+    return {
+        width: W, height: H,
+        faces: { back: { x: 0, y: 3, w: W, h: 31 }, middle: { x: 0, y: MIDDLE.top + 3, w: W, h: 31 } },
+        walls: { back: { x: 0, y: 0, w: W, h: WALL }, middle: { x: 0, y: MIDDLE.top, w: W, h: MIDDLE.bottom - MIDDLE.top },
+            vertical: VERTICAL.flatMap(x => [{ x, y: ROW1.top, w: THICK, h: ROW1.bottom - ROW1.top }, { x, y: ROW2.top, w: THICK, h: ROW2.bottom - ROW2.top }]),
+            sides: [{ x: 0, y: WALL, w: 4, h: H - WALL }, { x: W - 4, y: WALL, w: 4, h: H - WALL }], bottom: { x: 0, y: ROW2.bottom, w: W, h: H - ROW2.bottom } },
+        rooms, doors, entrance, spawn: { x: entrance.x + 17, y: ROW2.bottom - 2 },
+        items, decor,
+        rugs: [{ x: 6, y: 50, w: 120, h: 46, fill: "b", border: "c" }, { x: 426, y: 264, w: 100, h: 40, fill: "f", border: "g" }],
+        board: { x: 118, y: 42 },
+        staff: {
+            stations: { qa: rooms[2].slots[0], desk: rooms[3].slots[0], armchair: rooms[3].slots[1], integrator: rooms[4].slots[0] },
+            // Two sit on the sofa, in front of its back; two stand chatting at the cafe table.
+            rest: [seat(83, 212, "sit", 262, { x: 100, y: 268 }), seat(101, 212, "sit", 262, { x: 118, y: 268 }),
+                seat(88, 241, "right0", 291, { x: 106, y: 290 }), seat(148, 241, "left0", 291, { x: 166, y: 290 })]
+        },
+        hotspots: [
+            { kind: "task", room: "planning", rects: [area("board", 118, 42)] },
+            // The monitor sits at (30, 1) inside a cubicle, one pixel further in once outlined.
+            { kind: "diff", room: "implementing", rects: [{ x: 198 + 31, y: 40 + 2, w: 26, h: 22 }, { x: 288 + 31, y: 40 + 2, w: 26, h: 22 }] },
+            { kind: "verify", room: "verifying", rects: [area("statusPass", 400, 3), area("benchPass", 460, 54)] },
+            { kind: "review", room: "reviewing", rects: [area("execDesk", 500, 222)] },
+            { kind: "integration", room: "integrating", rects: [area("sortTable", 296, 202)] }
+        ],
+        open: [...rooms.map(({ x, y, w, h }) => ({ x, y, w, h })), ...doors.map(door => door.gap), entrance],
+        blocked: items.flatMap(item => item.footprint)
+    };
+}
+/** Size of one path-finding cell, in art pixels. */
+export const STEP = 2;
+/** A person's feet: a 14x4 box centred on x, ending at y. */
+export const FOOT = { w: 14, h: 4 };
+/**
+ * Free cells for a person's feet. Self-contained: the page embeds it with
+ * toString, so it may not reference imports or module-level values.
+ */
+export function walkGrid(layout) {
+    const step = 2, footW = 14, footH = 4, width = layout.width, height = layout.height;
+    const solid = new Array(width * height).fill(1);
+    layout.open.forEach(r => { for (let y = r.y; y < r.y + r.h; y++)
+        for (let x = r.x; x < r.x + r.w; x++)
+            if (x >= 0 && y >= 0 && x < width && y < height)
+                solid[y * width + x] = 0; });
+    layout.blocked.forEach(r => { for (let y = r.y; y < r.y + r.h; y++)
+        for (let x = r.x; x < r.x + r.w; x++)
+            if (x >= 0 && y >= 0 && x < width && y < height)
+                solid[y * width + x] = 1; });
+    // Summed area table: a feet box is free when it covers no solid pixel.
+    const sum = new Array((width + 1) * (height + 1)).fill(0);
+    for (let y = 0; y < height; y++)
+        for (let x = 0; x < width; x++)
+            sum[(y + 1) * (width + 1) + x + 1] = solid[y * width + x] + sum[y * (width + 1) + x + 1] + sum[(y + 1) * (width + 1) + x] - sum[y * (width + 1) + x];
+    const cols = Math.floor(width / step), rows = Math.floor(height / step), free = new Array(cols * rows).fill(0);
+    for (let cy = 0; cy < rows; cy++)
+        for (let cx = 0; cx < cols; cx++) {
+            const x0 = cx * step - footW / 2, y0 = cy * step - footH, x1 = x0 + footW, y1 = y0 + footH;
+            if (x0 < 0 || y0 < 0 || x1 > width || y1 > height)
+                continue;
+            const blocked = sum[y1 * (width + 1) + x1] - sum[y0 * (width + 1) + x1] - sum[y1 * (width + 1) + x0] + sum[y0 * (width + 1) + x0];
+            free[cy * cols + cx] = blocked === 0 ? 1 : 0;
+        }
+    return { cols, rows, free };
+}
+/**
+ * Shortest four-way walk between two feet points, as feet points every cell,
+ * or null when unreachable. Self-contained for the page, like walkGrid.
+ */
+export function findPath(grid, from, to) {
+    const step = 2, cols = grid.cols, rows = grid.rows;
+    const cell = (p) => Math.max(0, Math.min(rows - 1, Math.round(p.y / step))) * cols + Math.max(0, Math.min(cols - 1, Math.round(p.x / step)));
+    const start = cell(from), goal = cell(to);
+    if (!grid.free[start] || !grid.free[goal])
+        return null;
+    const previous = new Array(cols * rows).fill(-1), queue = [start];
+    previous[start] = start;
+    for (let head = 0; head < queue.length && previous[goal] === -1; head++) {
+        const current = queue[head], cx = current % cols, cy = Math.floor(current / cols);
+        const next = [cx > 0 ? current - 1 : -1, cx < cols - 1 ? current + 1 : -1, cy > 0 ? current - cols : -1, cy < rows - 1 ? current + cols : -1];
+        for (const candidate of next)
+            if (candidate >= 0 && grid.free[candidate] && previous[candidate] === -1) {
+                previous[candidate] = current;
+                queue.push(candidate);
+            }
+    }
+    if (previous[goal] === -1)
+        return null;
+    const path = [];
+    for (let at = goal;; at = previous[at]) {
+        path.push({ x: (at % cols) * step, y: Math.floor(at / cols) * step });
+        if (at === start)
+            break;
+    }
+    return path.reverse();
+}