@staix/agent-hub 0.12.23 → 0.12.24

package/src/hub/permission-mode.ts

@@ -1,17 +1,20 @@
+import { isSupportedPeer } from "./peer-catalog.ts";
 import { lstatSync } from "node:fs";
-import { isAbsolute, relative, sep } from "node:path";
+import { isAbsolute, relative, resolve, sep } from "node:path";
 
 /** Operator-selected approval frequency; agent sandboxes remain separate. */
 export const PERMISSION_MODES = ["ask", "ask-when-needed", "never-ask"] as const;
 export type PermissionMode = typeof PERMISSION_MODES[number];
 export const KIMI_MODE_IDS: Readonly<Record<PermissionMode, string>> = { ask: "default", "ask-when-needed": "yolo", "never-ask": "auto" };
+export const QWEN_MODE_IDS: Readonly<Record<PermissionMode, string>> = { ask: "default", "ask-when-needed": "auto-edit", "never-ask": "yolo" };
 export const isPermissionMode = (value: unknown): value is PermissionMode => typeof value === "string" && (PERMISSION_MODES as readonly string[]).includes(value);
 export function permissionDefaults(value: unknown): Record<string, PermissionMode> {
   if (value === undefined) return {};
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("permission_modes must be an object with ask, ask-when-needed or never-ask values");
   const result: Record<string, PermissionMode> = {};
   for (const [peer, mode] of Object.entries(value)) {
-    if (!["claude", "codex", "kimi", "pi", "local"].includes(peer)) throw new Error(`permission_modes.${peer}: unsupported peer`);
+    if (!isSupportedPeer(peer)) throw new Error(`permission_modes.${peer}: unsupported peer`);
+    if (peer === "jcode") throw new Error("Jcode native policy is unmanaged; no hub permission_modes.jcode mapping exists");
     if (!isPermissionMode(mode)) throw new Error(`permission_modes.${peer} must be ask, ask-when-needed or never-ask`);
     result[peer] = mode;
   }
@@ -19,13 +22,16 @@ export function permissionDefaults(value: unknown): Record<string, PermissionMod
 }
 /** Approval frequency does not create a common sandbox across native peers. */
 export function permissionBoundary(peer: string): string {
+  if (peer === "jcode") return "jcode: native policy unmanaged; NO hub sandbox; approvals belong to its native tools";
   if (peer === "pi" || peer === "local") return `${peer}: inside hub sandbox, path guard and denylist`;
   if (peer === "claude" || peer === "codex") return `${peer}: native vendor bounds; no hub sandbox`;
   return `${peer}: runs its own tools; NO hub sandbox`;
 }
 /** What a mode lets a peer do without asking, in one line a person reads before choosing it (#269). */
 export function permissionGrant(peer: string, mode: PermissionMode): string {
+  if (peer === "jcode") return "no verified hub mode mapping; native policy only";
   if (mode === "ask") return peer === "codex" ? "the session's own approval policy applies again" : peer === "kimi" ? "Kimi asks as it does on its own" : peer === "claude" ? "Claude's own permission rules decide" : "every write, edit and shell command asks";
+  if (peer === "qwen") return mode === "never-ask" ? "Qwen yolo approves every tool; NO hub sandbox" : "Qwen auto-edit approves file edits; shell commands ask; NO hub sandbox";
   if (peer === "kimi") return mode === "never-ask" ? "Kimi's auto mode: nothing asks" : "Kimi's yolo mode: it asks only where it judges it must";
   if (peer === "codex") return mode === "never-ask" ? "approval policy never on every turn: nothing asks" : "approval policy on-request on every turn";
   if (peer === "claude") return mode === "never-ask" ? "every tool runs without asking" : "file tools on project files run without asking, outside .agenthub, .git and agent configuration; other tools keep Claude's own rules";
@@ -33,7 +39,14 @@ export function permissionGrant(peer: string, mode: PermissionMode): string {
 }
 export const PI_EDIT_TOOLS = new Set(["edit", "write"]);
 /** Native agent policy files are never included in scoped automatic file grants. */
-export const AGENT_CONFIG_SEGMENTS: ReadonlySet<string> = new Set([".claude", ".codex", ".qwen", ".kimi", ".pi", ".mcp.json"]);
+export const AGENT_CONFIG_SEGMENTS: ReadonlySet<string> = new Set([".claude", ".codex", ".qwen", ".kimi", ".kimi-code", ".jcode", ".pi", ".mcp.json", ".agents", ".claude.json"]);
+export const INSTRUCTION_FILES: ReadonlySet<string> = new Set(["agents.md", "claude.md", "qwen.md"]);
+export const isInstructionPath = (path: string): boolean => path.split(/[\\/]/).some(segment => INSTRUCTION_FILES.has(foldSegment(segment)));
+export function instructionProtection(value: unknown): boolean {
+  if (value === undefined) return false;
+  if (typeof value !== "boolean") throw new Error("protect_instruction_files must be a boolean");
+  return value;
+}
 /**
  * One spelling per name, as a case-insensitive disk sees it: it opens `.mcp.j\u017Fon` (long s) as `.mcp.json`, and
  * HFS+ also ignores the default-ignorable code points (a zero-width joiner inside `.codex` is still `.codex`).
@@ -52,7 +65,8 @@ export function hardLinked(path: string): boolean {
  * inside the project, outside every agent's configuration, judged by the path within the project (a project that
  * itself lives under `.claude/worktrees/` is still a project), and not a hard link.
  */
-export function grantablePath(root: string, path: string): boolean {
+export function grantablePath(root: string, path: string, originalPath?: string, protectInstructions = false): boolean {
   const inside = relative(root, path);
-  return !!inside && inside !== ".." && !inside.startsWith(`..${sep}`) && !isAbsolute(inside) && !isAgentConfigPath(inside) && !isHubWritePath(inside) && !hardLinked(path);
+  const original = originalPath === undefined ? inside : relative(root, resolve(root, originalPath));
+  return !!inside && inside !== ".." && !inside.startsWith(`..${sep}`) && !isAbsolute(inside) && !isAgentConfigPath(inside) && !isHubWritePath(inside) && !isAgentConfigPath(original) && !isHubWritePath(original) && !(protectInstructions && (isInstructionPath(inside) || isInstructionPath(original))) && !hardLinked(path);
 }

package/src/hub/planning.ts

@@ -0,0 +1,70 @@
+import type { Task } from "./board.ts";
+
+export const BACKLOG_SPLIT_SCREEN_TIMEOUT_MS = 8000;
+
+export const PLANNING_FIELDS = ["rank", "priority", "release", "plannedStart", "due", "pinned", "deps", "reserved"] as const;
+export interface PlanningFields {
+  rank?: number | null;
+  priority?: number | null;
+  release?: number | null;
+  plannedStart?: number | null;
+  due?: number | null;
+  pinned?: boolean;
+  deps?: number[];
+  reserved?: string | null;
+}
+export interface PlanningPatch extends PlanningFields {}
+/** Machine-local capacity settings; ids never grant roster membership or authority. */
+export function planningWipLimits(input: unknown): Record<string, number> {
+  if (input === undefined) return {};
+  if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).length > 64) throw new Error("tasks.wip_limits must be a bounded peer map");
+  const limits: Record<string, number> = Object.create(null);
+  for (const [peer, value] of Object.entries(input)) {
+    if (!/^[a-z][a-z0-9-]{0,31}$/.test(peer) || typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > 32) throw new Error("tasks.wip_limits needs peer ids and integer capacities 0..32");
+    limits[peer] = value;
+  }
+  return limits;
+}
+export const RELEASE_STATES = ["planning", "active", "frozen", "shipped", "dropped"] as const;
+export type ReleaseState = (typeof RELEASE_STATES)[number];
+export interface Release {
+  id: number; name: string; goal: string; order: number; state: ReleaseState;
+  plannedStart: number | null; cut: number | null; ship: number | null;
+  activatedAt: number | null; frozenAt: number | null; shippedAt: number | null;
+  created: number; updated: number; revision: number;
+}
+
+/** Validate the entire planning input before a write; actual dates are never caller input. */
+export function planningPatch(input: unknown): PlanningPatch {
+  if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("planning fields must be an object");
+  const fields = input as Record<string, unknown>;
+  if (!Object.keys(fields).length || Object.keys(fields).some(key => !(PLANNING_FIELDS as readonly string[]).includes(key))) throw new Error("unknown or empty planning fields");
+  const result: PlanningPatch = {};
+  for (const key of PLANNING_FIELDS) {
+    if (!Object.hasOwn(fields, key)) continue;
+    const value = fields[key];
+    if (key === "deps") {
+      if (!Array.isArray(value) || value.length > 64 || value.some(id => !Number.isSafeInteger(id) || id <= 0) || new Set(value).size !== value.length) throw new Error("deps must be at most 64 unique positive task ids");
+      result.deps = [...value];
+    } else if (key === "reserved") {
+      const peer = typeof value === "string" ? value.trim().toLowerCase() : null;
+      if (value !== null && (!peer || !/^[a-z][a-z0-9-]{0,31}$/.test(peer) || ["user", "hub", "digest"].includes(peer))) throw new Error("reserved must be a valid agent peer id or null");
+      result.reserved = peer;
+    } else if (key === "pinned") {
+      if (typeof value !== "boolean") throw new Error("pinned must be a boolean");
+      result.pinned = value;
+    } else {
+      if (value !== null && (typeof value !== "number" || !Number.isSafeInteger(value) || value < (key === "release" || key === "plannedStart" || key === "due" ? 1 : 0) || (key === "priority" && value > 3) || (["plannedStart", "due"].includes(key) && value > 8_640_000_000_000_000))) throw new Error(`invalid planning field ${key}`);
+      result[key] = value as number | null;
+    }
+  }
+  return result;
+}
+
+/** Structured lifecycle events only, including reviewerless approval via done. */
+export function actualTaskDates(task: Pick<Task, "history" | "state" | "reviewer">) {
+  const first = (events: readonly string[]) => task.history.find(entry => events.includes(entry.event))?.at ?? null;
+  const approved = first(["approved"]), reviewed = task.reviewer !== null || task.history.some(entry => entry.event === "approved" || entry.event === "changes_requested");
+  const reviewerlessDone = task.state === "approved" && !task.reviewer ? [...task.history].reverse().find(entry => entry.event === "done")?.at ?? null : null;
+  return { startedAt: first(["accepted"]), reviewAt: reviewed ? first(["done"]) : null, doneAt: approved ?? reviewerlessDone };
+}

package/src/hub/profiles.ts

@@ -0,0 +1,74 @@
+import dev from "../../templates/profiles/dev.json";
+import research from "../../templates/profiles/research.json";
+import writing from "../../templates/profiles/writing.json";
+import general from "../../templates/profiles/general.json";
+import { ALL_PLAN_KEYS, CLASSES, type TaskClass } from "./board.ts";
+import { catalogAssignments } from "./roles.ts";
+import { sanitize } from "./envelope.ts";
+export const PROFILE_NAMES = ["dev", "research", "writing", "general"] as const;
+export type ProfileName = (typeof PROFILE_NAMES)[number];
+export interface ProjectProfile {
+  name: string; classes: Record<string, string>; plan_keys: string[]; role_text: Record<string, string>;
+  catalog_roles: Record<string, string[]>; agents: string; example_checks: string[];
+}
+const PROFILES: Record<ProfileName, ProjectProfile> = { dev, research, writing, general };
+export function profileName(raw: unknown): ProfileName {
+  if (raw === undefined) return "dev";
+  if (typeof raw !== "string" || !PROFILE_NAMES.includes(raw as ProfileName)) throw new Error(`profile must be one of ${PROFILE_NAMES.join(", ")}`);
+  return raw as ProfileName;
+}
+export const projectProfile = (raw?: unknown): ProjectProfile => PROFILES[profileName(raw)];
+export type ProfileSelection = ProfileName | ProjectProfile;
+export const profileData = (profile: ProfileSelection = "dev"): ProjectProfile => typeof profile === "string" ? projectProfile(profile) : profile;
+export function profileClass(raw: string, profile: ProfileSelection = "dev"): TaskClass {
+  const data = profileData(profile);
+  const base = typeof raw === "string" ? (Object.hasOwn(data.classes, raw) ? data.classes[raw] : Object.hasOwn(dev.classes, raw) ? (dev.classes as Record<string, string>)[raw] : undefined) : undefined;
+  if (!base) throw new Error(`class must be one of ${Object.keys(data.classes).join(", ")} (profile ${data.name}; existing base classes also accepted)`);
+  return base as TaskClass;
+}
+export const profileTaskLabel = (task: { class: string; profile?: string; profileClass?: string }) => task.profileClass ? `${task.profileClass} (base ${task.class}, ${task.profile})` : task.class;
+export const PROFILE_CLASS_NAMES = [...new Set(Object.values(PROFILES).flatMap(p => Object.keys(p.classes)))];
+
+/** Pure project data resolution. No mutation of shipped profiles or executable check defaults. */
+export function resolveProfile(raw?: unknown, overrides?: unknown): ProjectProfile {
+  const original = projectProfile(raw);
+  if (overrides === undefined) return original;
+  if (!overrides || typeof overrides !== "object" || Array.isArray(overrides)) throw new Error("profile_overrides must be an object");
+  const data = overrides as Record<string, unknown>, allowed = new Set(["classes", "plan_keys", "role_text", "catalog_roles", "agents", "example_checks"]);
+  if (Object.keys(data).some(key => !allowed.has(key))) throw new Error("unknown profile override field");
+  if (!Object.keys(data).length) return original;
+  const result: ProjectProfile = { ...original, classes: { ...original.classes }, plan_keys: [...original.plan_keys], role_text: { ...original.role_text }, catalog_roles: Object.fromEntries(Object.entries(original.catalog_roles).map(([peer, ids]) => [peer, [...ids]])), example_checks: [...original.example_checks] };
+  const text = (value: unknown, cap: number): string => { if (typeof value !== "string" || value.length > cap) throw new Error("profile text is missing or oversized"); return sanitize(value); };
+  if (data.classes !== undefined) {
+    if (!data.classes || typeof data.classes !== "object" || Array.isArray(data.classes) || Object.keys(data.classes).length > 32) throw new Error("profile classes must be a bounded base-class map");
+    for (const [name, base] of Object.entries(data.classes)) {
+      if (!/^[a-z][a-z0-9_]{0,47}$/.test(name) || typeof base !== "string" || !CLASSES.includes(base as TaskClass) || CLASSES.includes(name as TaskClass) && name !== base) throw new Error("profile class must retain an existing base-class meaning");
+      result.classes[name] = base;
+    }
+  }
+  if (data.plan_keys !== undefined) {
+    if (!Array.isArray(data.plan_keys) || !data.plan_keys.length || data.plan_keys.length > ALL_PLAN_KEYS.length || new Set(data.plan_keys).size !== data.plan_keys.length || data.plan_keys.some(key => !ALL_PLAN_KEYS.includes(key))) throw new Error("profile plan_keys must select distinct supported fields");
+    result.plan_keys = [...data.plan_keys];
+  }
+  if (data.role_text !== undefined) {
+    if (!data.role_text || typeof data.role_text !== "object" || Array.isArray(data.role_text) || Object.keys(data.role_text).length > 8) throw new Error("profile role_text must be bounded guidance");
+    for (const [role, value] of Object.entries(data.role_text)) {
+      if (!["planner", "implementer", "verifier", "reviewer", "conductor"].includes(role)) throw new Error("profile role_text must name an existing flow role");
+      result.role_text[role] = text(value, 2000);
+    }
+  }
+  if (data.catalog_roles !== undefined) result.catalog_roles = { ...result.catalog_roles, ...catalogAssignments(data.catalog_roles) };
+  if (data.agents !== undefined) result.agents = text(data.agents, 16000);
+  if (data.example_checks !== undefined) {
+    if (!Array.isArray(data.example_checks) || data.example_checks.length > 16) throw new Error("profile example_checks must be a bounded display list");
+    result.example_checks = data.example_checks.map(value => text(value, 2000));
+  }
+  return result;
+}
+
+/** Maps merge across shared/local layers; selections and display text replace as a unit. */
+export function mergeProfileOverrides(a: unknown, b: unknown): Record<string, unknown> | undefined {
+  if (a === undefined && b === undefined) return undefined;
+  const left = (a ?? {}) as Record<string, unknown>, right = (b ?? {}) as Record<string, unknown>;
+  return { ...left, ...right, ...Object.fromEntries(["classes", "role_text", "catalog_roles"].filter(key => left[key] !== undefined && right[key] !== undefined).map(key => [key, { ...(left[key] as object), ...(right[key] as object) }])) };
+}

package/src/hub/projected-diff.ts

@@ -0,0 +1,73 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { hubGitSync } from "./git.ts";
+import { sanitize } from "./envelope.ts";
+import { foldSegment } from "./permission-mode.ts";
+import { isDenied } from "../local/deny.ts";
+import { MAX_PROJECTION_INPUT, type TextProjections } from "./text-projection.ts";
+import { repoGitArgs, repoGitEnv, type Repo } from "./snapshots.ts";
+
+export const PROJECTED_DIFF_BYTES = 12000;
+const MAX_FILES = 8, DIFF_MS = 8000;
+const HEADER = "Projected text only (authorship and raw restore safety are independent):";
+const treeId = (tree: string) => /^[a-f0-9]{40}$|^[a-f0-9]{64}$/.test(tree);
+export function projectionPath(repo: Repo, path: string, deny: string[] = []): boolean {
+  const parts = path.split("/"), folded = parts.map(foldSegment).join("/");
+  return !!path && !path.startsWith("/") && path.startsWith(repo.prefix) && parts.every(part => !!part && part !== "." && part !== ".." && ![".git", ".agenthub"].includes(foldSegment(part))) && !isDenied(path, deny) && !isDenied(folded, deny.map(foldSegment));
+}
+/** null is an absent file; undefined is unavailable evidence or a non-regular object. */
+export function snapshotBytes(repo: Repo, tree: string, path: string, deadline = performance.now() + DIFF_MS): Buffer | null | undefined {
+  if (!treeId(tree) || !projectionPath(repo, path) || performance.now() >= deadline) return undefined;
+  const run = (args: string[], encoding: "utf8" | "latin1" = "utf8", maxBuffer = 8192) => hubGitSync(repoGitArgs(repo, args), { encoding, maxBuffer, timeout: Math.ceil(Math.max(1, Math.min(DIFF_MS, deadline - performance.now()))), env: repoGitEnv(repo) });
+  const entry = run(["ls-tree", "-z", tree, "--", `:(literal)${path}`]);
+  if (entry.status !== 0) return undefined;
+  if (!entry.stdout) return null;
+  const match = /^(100644|100755) blob ([a-f0-9]+)\t/.exec(entry.stdout);
+  if (!match || entry.stdout.slice(match[0].length) !== path + "\0" || !treeId(match[2]!)) return undefined;
+  if (performance.now() >= deadline) return undefined;
+  const size = run(["cat-file", "-s", match[2]!]);
+  const length = Number(size.stdout.trim());
+  if (size.status !== 0 || !Number.isSafeInteger(length) || length < 0 || length > MAX_PROJECTION_INPUT || performance.now() >= deadline) return undefined;
+  // Latin1 preserves all byte values through the existing bounded git wrapper.
+  const blob = run(["cat-file", "blob", match[2]!], "latin1", MAX_PROJECTION_INPUT + 1);
+  if (blob.status !== 0 || blob.stdout.length !== length) return undefined;
+  return Buffer.from(blob.stdout, "latin1");
+}
+function hunks(repo: Repo, before: string, after: string, deadline: number): string | undefined {
+  if (performance.now() >= deadline) return undefined;
+  const scratch = mkdtempSync(join(tmpdir(), "ahub-projected-diff-"));
+  try {
+    const a = join(scratch, "before"), b = join(scratch, "after"); writeFileSync(a, before, { mode: 0o600 }); writeFileSync(b, after, { mode: 0o600 });
+    const diff = hubGitSync(repoGitArgs(repo, ["diff", "--no-index", "--no-color", "--no-ext-diff", "--no-textconv", "--unified=2", "--", a, b]), { encoding: "utf8", maxBuffer: 1024 * 1024, timeout: Math.ceil(Math.max(1, Math.min(DIFF_MS, deadline - performance.now()))), env: repoGitEnv(repo) });
+    if (diff.status !== 0 && diff.status !== 1) return undefined;
+    const start = diff.stdout.indexOf("@@");
+    if (start < 0) return diff.status === 0 ? "(projected text unchanged)" : undefined;
+    return diff.stdout.slice(start).replace(/\n$/, "");
+  } finally { rmSync(scratch, { recursive: true, force: true }); }
+}
+/** Presentation of checked snapshot bytes, never evidence of authorship or restore safety. */
+export function projectedDiff(options: { repo: Repo; from: string; to: string; paths: string[]; projections: TextProjections; deny?: string[]; privatePath?: (path: string) => boolean; nameable?: (text: string) => boolean }): string | undefined {
+  const { repo, projections } = options;
+  if (!projections.enabled) return undefined;
+  const deadline = performance.now() + DIFF_MS, rows: string[] = []; let bytes = Buffer.byteLength(HEADER) + 1, files = 0;
+  const add = (text: string) => { const safe = sanitize(text); if (bytes + Buffer.byteLength(safe) + 1 > PROJECTED_DIFF_BYTES) return false; rows.push(safe); bytes += Buffer.byteLength(safe) + 1; return true; };
+  for (const path of [...new Set(options.paths)]) {
+    if (!projections.handles(path) || !projectionPath(repo, path, options.deny) || options.nameable?.(path) === false) continue;
+    if (files++ >= MAX_FILES || performance.now() >= deadline) { add("(remaining projection previews omitted: count or time limit)"); break; }
+    if (options.privatePath?.(path)) { if (!add(`${path}: (projection withheld: private path)`)) break; continue; }
+    const before = snapshotBytes(repo, options.from, path, deadline), after = snapshotBytes(repo, options.to, path, deadline);
+    if (before === undefined || after === undefined) { if (!add(`${path}: (projection unavailable: snapshot file is unknown)`)) break; continue; }
+    if (before === null && after === null) { if (!add(`${path}: (projection unavailable: file is absent from both snapshots)`)) break; continue; }
+    const a = before === null ? null : projections.projectBytes(join(repo.top, path), before, deadline);
+    if (a === undefined) continue;
+    const b = after === null ? null : projections.projectBytes(join(repo.top, path), after, deadline);
+    if (a === undefined || b === undefined) continue; // converter failure keeps the ordinary file-only view
+    if (a && b && a.configHash !== b.configHash) { if (!add(`${path}: (projection unavailable: converter changed during comparison)`)) break; continue; }
+    const diff = hunks(repo, a?.text ?? "", b?.text ?? "", deadline);
+    if (diff === undefined) { if (!add(`${path}: (projection unavailable: diff could not be read)`)) break; continue; }
+    const text = options.nameable?.(diff) === false ? `${path}: (projection withheld: private-data pattern)` : `${path}:\n${diff}`;
+    if (!add(text)) { add("(remaining projection previews omitted: output limit)"); break; }
+  }
+  return rows.length ? `${HEADER}\n${rows.join("\n")}` : undefined;
+}

package/src/hub/projection-exec.ts

@@ -0,0 +1,24 @@
+// Trusted synchronous-boundary helper: the parent waits, this process owns and stops the converter group.
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+let ownedGroup: number | undefined;
+const stop = () => { if (ownedGroup) try { process.kill(-ownedGroup, "SIGKILL"); } catch { /* owned group gone */ } };
+// The aggregate preview deadline can expire before the converter's own timer.
+process.on("SIGTERM", () => { stop(); process.exit(143); });
+process.on("SIGINT", () => { stop(); process.exit(130); });
+const request = JSON.parse(await new Response(Bun.stdin.stream()).text()) as { cwd: string; sandbox: string; argv: string[]; timeoutMs?: number };
+const limit = 256 * 1024;
+const child = spawn("/usr/bin/sandbox-exec", ["-p", request.sandbox, ...request.argv], {
+  cwd: request.cwd, detached: true, stdio: ["ignore", "pipe", "pipe"],
+  env: { PATH: process.env.PATH ?? "/usr/bin:/bin", HOME: homedir(), LANG: "en_US.UTF-8", TERM: "dumb" },
+});
+ownedGroup = child.pid;
+const decoder = new TextDecoder("utf-8", { fatal: true });
+let stdout = "", stderrBytes = 0, outputBytes = 0, invalid = false;
+const timeout = typeof request.timeoutMs === "number" && Number.isFinite(request.timeoutMs) ? Math.ceil(Math.max(1, Math.min(5000, request.timeoutMs))) : 5000;
+const timer = setTimeout(() => { invalid = true; stop(); }, timeout);
+child.stdout.on("data", (bytes: Buffer) => { outputBytes += bytes.length; if (outputBytes > limit) { invalid = true; stop(); } else try { stdout += decoder.decode(bytes, { stream: true }); } catch { invalid = true; stop(); } });
+child.stderr.on("data", (bytes: Buffer) => { stderrBytes += bytes.length; if (stderrBytes > limit) { invalid = true; stop(); } });
+child.on("exit", () => stop()); // descendants may retain the output pipe after the leader exits
+child.on("error", () => { clearTimeout(timer); invalid = true; process.stdout.write(JSON.stringify({ ok: false })); });
+child.on("close", code => { clearTimeout(timer); ownedGroup = undefined; try { stdout += decoder.decode(); } catch { invalid = true; } process.stdout.write(JSON.stringify({ ok: !invalid && code === 0, ...(invalid || code !== 0 ? {} : { text: stdout }) })); });

package/src/hub/research.ts

@@ -1,8 +1,10 @@
 import { createHash } from "node:crypto";
 import { appendFileSync, chmodSync, existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import type { StampedEvent } from "./events.ts";
+import type { RoleIdentity, StampedEvent } from "./events.ts";
 import { hubHome } from "./project.ts";
+import { ADDONS, addonState, type Addon, type AddonName } from "./tooling.ts";
+import { MIN_ATTEMPTS, mulberry32 } from "./bench.ts";
 
 /**
  * #247: opt-in research records of how tasks went, built only from `events.jsonl` (ids, states, counts, tokens), so the
@@ -18,6 +20,11 @@ const FAILED: ReadonlySet<string> = new Set(["regressed", "reverted", "incomplet
 export interface PeerUsage { input: number | null; output: number | null; cacheRead: number | null; total: number | null }
 export interface TaskRecord {
   schema: typeof RESEARCH_SCHEMA; kind: "task"; project: string; task: number;
+  profile?: string; profileClass?: string;
+  release?: number | null; priority?: number | null; plannedStart?: number | null; due?: number | null;
+  role?: string; roleIdentity?: { id: string; layer: "shipped" | "project"; hash: string };
+  /** Native preamble preparations frozen at each attributed turn's start, never proof of model consumption. */
+  sessionRoles?: { peer: string; turn: string; roles: RoleIdentity[] | null }[];
   class: string | null; pii: boolean; outcome: "approved";
   /** The proposal time also tells a task from an earlier one with the same id after `ahub reset --all`. */
   createdAt: string | null; startedAt: string | null; approvedAt: string;
@@ -44,6 +51,12 @@ export interface TaskRecord {
   /** Model routes and served models seen for the task's attributed requests. */
   models: string[];
   writer: { version: string; source: "live" | "backfill" };
+  /** #248: the add-ons each peer that worked on the task had at its latest attach; a peer missing here is unknown. */
+  tooling?: Record<string, Addon[]>;
+  /** #248, with `tooling`: every peer with an event attributed to the task, fingerprinted or not. */
+  peers?: string[];
+  /** #258 AC11: task briefs handed over for it, and how many of them carried a hub-memory fail note; absent without briefs. */
+  briefs?: { delivered: number; withFail: number };
 }
 /** A person's later verdict on one task record: `createdAt` binds it to that task, not a later one with the same id. */
 export interface LabelRecord { schema: typeof RESEARCH_SCHEMA; kind: "label"; project: string; task: number; createdAt: string; label: Label; at: string }
@@ -56,15 +69,15 @@ export const researchFile = (projectId: string, home = hubHome()): string => joi
 /** One task across every record about it: a task id is reused after `ahub reset --all`, its proposal time is not. */
 export const recordKey = (r: { project: string; task: number; createdAt: string | null; approvedAt?: string }): string => `${r.project}#${r.task}@${r.createdAt ?? r.approvedAt ?? ""}`;
 
-type Acc = Omit<TaskRecord, "schema" | "kind" | "project" | "approvedAt" | "wallMs" | "firstPass" | "outcome" | "writer" | "models"> & {
-  models: Set<string>; approvedAt: string | null; lastState: string | null;
+type Acc = Omit<TaskRecord, "schema" | "kind" | "project" | "approvedAt" | "wallMs" | "firstPass" | "outcome" | "writer" | "models" | "tooling" | "peers" | "briefs"> & {
+  models: Set<string>; approvedAt: string | null; lastState: string | null; tooling: Record<string, Addon[]>; peers: Map<string, number>; briefs: { delivered: number; withFail: number };
 };
 /** Keyed by peer ids, model names and reasons, any of which may be `constructor` or `__proto__`: no prototype to inherit from. */
 const keyed = <T>(): Record<string, T> => Object.create(null) as Record<string, T>;
 const blank = (task: number): Acc => ({ task, class: null, pii: false, createdAt: null, startedAt: null, activeMs: 0, owners: [], reviewer: null,
   reviewRounds: 0, changesRequested: 0, checkPassed: 0, checkFailed: 0, dones: 0, reassignments: 0, reassignedBy: keyed(), stuck: 0, overlaps: 0, conflicts: 0,
   tests: { pass: 0, fail: 0 }, tokens: { total: 0, byPeer: keyed(), byAttribution: keyed() }, usage: keyed(), usageByModel: keyed(), turns: 0, filesChanged: 0, models: new Set(),
-  approvedAt: null, lastState: null });
+  approvedAt: null, lastState: null, tooling: keyed(), peers: new Map(), briefs: { delivered: 0, withFail: 0 } });
 const add = (current: number | null, value: unknown): number | null => typeof value === "number" && Number.isFinite(value) ? (current ?? 0) + value : current;
 const bump = (counts: Record<string, number>, key: string, n = 1) => { counts[key] = (counts[key] ?? 0) + n; };
 
@@ -77,18 +90,51 @@ export function taskRecords(events: StampedEvent[], projectId: string, writer: T
   const tasks = new Map<number, Acc>(), earlier: Acc[] = [];
   const acc = (id: number) => { let a = tasks.get(id); if (!a) tasks.set(id, a = blank(id)); return a; };
   const seenUsage = new Set<string>();
+  // A fingerprint belongs to one attachment of its peer: from a state event that brings it online to the next offline.
+  // Detection settles in the background, so it can arrive after the peer's first work in that attachment.
+  const attach = new Map<string, number>(), online = new Set<string>();
+  const tooling = new Map<string, { attach: number; addons: Addon[] }>();
+  /** A peer that worked on the task carries the fingerprint of the attachment it worked in. */
+  /**
+   * `acted`: the peer did something for the task (an attributed turn, tokens, the actor of a board move). A peer only
+   * named on a move (the owner or reviewer an approval lists) joins the task once and never moves to a later
+   * attachment, where it did no work.
+   */
+  const involve = (a: Acc, peer: string | null | undefined, acted = true) => {
+    if (!peer || peer === "hub" || peer === "user" || (!acted && a.peers.has(peer))) return;
+    const now = attach.get(peer) ?? 0, f = tooling.get(peer);
+    a.peers.set(peer, now);
+    if (f?.attach === now) a.tooling[peer] = f.addons;
+    else delete a.tooling[peer]; // a fingerprint of an earlier attachment does not describe this work: unknown until one comes
+  };
   for (const e of events) {
+    // A crash writes no offline: a new run is a new attachment, and no fingerprint from before it describes later work.
+    if (e.type === "hub_start") { online.clear(); tooling.clear(); continue; }
+    if (e.type === "state") {
+      if (e.state === "offline") online.delete(e.peer);
+      else if (!online.has(e.peer)) { online.add(e.peer); attach.set(e.peer, (attach.get(e.peer) ?? 0) + 1); }
+      continue;
+    }
+    if (e.type === "tooling") {
+      const now = attach.get(e.peer) ?? 0;
+      tooling.set(e.peer, { attach: now, addons: e.addons });
+      for (const a of tasks.values()) if (a.peers.get(e.peer) === now) a.tooling[e.peer] = e.addons;
+      continue;
+    }
     if (e.type === "task") {
+      const proposed = e.event === "proposed" || e.event === "backlog pulled";
       // Ids restart after `ahub reset --all` archives the events, but a file that kept both starts the task anew.
-      if (e.event === "proposed" && tasks.get(e.id)?.createdAt) { earlier.push(tasks.get(e.id)!); tasks.delete(e.id); }
+      if ((e.event === "proposed" && tasks.has(e.id)) || (e.event === "backlogged" && tasks.has(e.id))) { earlier.push(tasks.get(e.id)!); tasks.delete(e.id); }
       const a = acc(e.id);
-      a.class = e.class; if (e.pii) a.pii = true;
+      for (const field of ["release", "priority", "plannedStart", "due"] as const) if (Object.hasOwn(e, field)) a[field] = e[field];
+      a.class = e.class; if (e.role && a.role === undefined) { a.role = e.role; if (e.event === "proposed" && e.roleIdentity) a.roleIdentity = e.roleIdentity; } if (e.profile) { a.profile = e.profile; a.profileClass = e.profileClass; } if (e.pii) a.pii = true;
+      if (proposed && e.role === a.role && e.roleIdentity && a.roleIdentity === undefined) a.roleIdentity = e.roleIdentity;
       if (e.owner && e.owner !== a.owners.at(-1)) {
         if (a.owners.length) { a.reassignments++; bump(a.reassignedBy, e.reason ?? "none"); }
         a.owners.push(e.owner);
       }
       if (e.reviewer) a.reviewer = e.reviewer;
-      if (e.event === "proposed") a.createdAt ??= e.at;
+      if (proposed) a.createdAt ??= e.at;
       if (e.state === "in_progress") a.startedAt ??= e.at;
       if (e.event === "done") a.dones++;
       if (e.event === "check passed") a.checkPassed++;
@@ -97,14 +143,19 @@ export function taskRecords(events: StampedEvent[], projectId: string, writer: T
       if (e.state === "changes_requested" && a.lastState !== "changes_requested") a.changesRequested++;
       if (e.state === "approved") a.approvedAt ??= e.at;
       a.lastState = e.state;
+      involve(a, e.by); involve(a, e.owner, false); involve(a, e.reviewer, false);
       continue;
     }
     const task = "task" in e && typeof e.task === "number" ? e.task : undefined;
     if (task === undefined) continue;
     const a = acc(task);
     if ("pii" in e && e.pii === true) a.pii = true;
+    if ("peer" in e && typeof e.peer === "string") involve(a, e.peer);
     if (e.type === "tokens") { a.tokens.total += e.n; bump(a.tokens.byPeer, e.peer, e.n); bump(a.tokens.byAttribution, e.attribution ?? "unknown", e.n); }
-    else if (e.type === "turn_end") { a.turns++; a.activeMs += e.ms; a.filesChanged += e.files ?? 0; }
+    else if (e.type === "turn_end") {
+      a.turns++; a.activeMs += e.ms; a.filesChanged += e.files ?? 0;
+      if (e.preparedRoles !== undefined) (a.sessionRoles ??= []).push({ peer: e.peer, turn: e.turn, roles: e.preparedRoles?.map(role => ({ id: role.id, layer: role.layer, hash: role.hash })) ?? null });
+    }
     else if (e.type === "usage") {
       const key = `${e.peer}\0${e.source}\0${e.id}`;
       if (seenUsage.has(key)) continue;
@@ -117,6 +168,7 @@ export function taskRecords(events: StampedEvent[], projectId: string, writer: T
     }
     else if (e.type === "route") a.models.add(e.route);
     else if (e.type === "route_outcome") { if (e.next?.tests === "pass") a.tests.pass++; if (e.next?.tests === "fail") a.tests.fail++; }
+    else if (e.type === "memory_brief") { a.briefs.delivered++; if (e.fails > 0) a.briefs.withFail++; }
     else if (e.type === "stuck") a.stuck++;
     else if (e.type === "overlap") a.overlaps++;
     else if (e.type === "conflict") a.conflicts++;
@@ -124,11 +176,12 @@ export function taskRecords(events: StampedEvent[], projectId: string, writer: T
   const out: TaskRecord[] = [];
   for (const a of [...earlier, ...tasks.values()]) {
     if (!a.approvedAt) continue;
-    const { approvedAt, lastState: _state, models, ...rest } = a;
+    const { approvedAt, lastState: _state, models, tooling: fingerprints, peers, briefs, ...rest } = a;
     const start = a.startedAt ? Date.parse(a.startedAt) : NaN, end = Date.parse(approvedAt);
     out.push({ schema: RESEARCH_SCHEMA, kind: "task", project: projectKey(projectId), ...rest, outcome: "approved", approvedAt,
       wallMs: Number.isFinite(start) && Number.isFinite(end) && end >= start ? end - start : null,
-      firstPass: a.changesRequested === 0 && a.checkFailed === 0 && a.reviewRounds <= 1, models: [...models].sort(), writer });
+      firstPass: a.changesRequested === 0 && a.checkFailed === 0 && a.reviewRounds <= 1, models: [...models].sort(), writer,
+      ...(Object.keys(fingerprints).length ? { tooling: fingerprints, peers: [...peers.keys()].sort() } : {}), ...(briefs.delivered ? { briefs } : {}) });
   }
   return out.sort((x, y) => x.approvedAt.localeCompare(y.approvedAt) || x.task - y.task);
 }
@@ -175,7 +228,11 @@ export function labelTarget(records: ResearchRecord[], events: StampedEvent[], t
   if (created !== undefined) {
     return mine.find((r) => r.createdAt === created) ?? fail(`no research record for task #${task} proposed at ${created}${mine.length ? ` (it has: ${mine.map((r) => r.createdAt).join(", ")})` : ""}`);
   }
-  const proposed = events.filter((e) => e.type === "task" && e.id === task && e.event === "proposed").at(-1);
+  const creation = events.findLast(e => e.type === "task" && e.id === task && ["proposed", "backlogged"].includes(e.event));
+  const proposed = creation?.type === "task" && creation.event === "backlogged"
+    ? events.slice(events.indexOf(creation) + 1).find(e => e.type === "task" && e.id === task && e.event === "backlog pulled")
+    : creation;
+  if (creation?.type === "task" && creation.event === "backlogged" && !proposed) fail(`task #${task} is backlog and has no execution proposal; name an earlier record with --created`);
   if (proposed) {
     return mine.find((r) => r.createdAt === proposed.at)
       ?? fail(`task #${task} has no research record yet: it is not approved, its record still waits for the turns that approved it, or it was approved while research was off (ahub research backfill builds that one)${mine.length ? `; an earlier task #${task} from before a reset is labelled with --created ${mine.map((r) => r.createdAt).join(" or ")}` : ""}`);
@@ -207,19 +264,15 @@ function measures(records: TaskRecord[], labels: Map<string, Label>): Measures {
     tokensPerTask: { median: quantile(records.map((r) => r.tokens.total), 0.5), p90: quantile(records.map((r) => r.tokens.total), 0.9) },
     wallMsPerTask: { median: quantile(records.flatMap((r) => r.wallMs ?? []), 0.5), p90: quantile(records.flatMap((r) => r.wallMs ?? []), 0.9) } };
 }
-export interface ResearchReport { overall: Measures; byClass: Record<string, Measures>; byOwner: Record<string, Measures>; byProject: Record<string, Measures>; byModel: Record<string, Measures> }
+export interface ResearchReport { overall: Measures; byClass: Record<string, Measures>; byOwner: Record<string, Measures>; byProject: Record<string, Measures>; byModel: Record<string, Measures>;
+  /** #258 AC11: tasks whose brief carried a hub-memory fail note, a brief without one, or no brief recorded. */
+  byMemoryBrief: Record<string, Measures> }
 /**
  * The derived measures, never stored as truth: each task counts once (its last record), and a person's latest label
  * decides whether an approved task later failed. Records older than `since` (ms epoch, by approval) are left out.
  */
 export function researchReport(records: ResearchRecord[], since = 0): ResearchReport {
-  const latest = new Map<string, TaskRecord>(), labels = new Map<string, Label>();
-  for (const r of records) {
-    const key = recordKey(r);
-    if (r.kind === "label") { labels.set(key, r.label); continue; }
-    if (Date.parse(r.approvedAt) >= since) latest.set(key, r);
-  }
-  const all = [...latest.values()];
+  const { all, labels } = latestRecords(records, since);
   const group = (keys: (r: TaskRecord) => string[]) => {
     // A Map: a peer or model may be named `constructor`, which a plain object answers with an inherited value.
     const out = new Map<string, TaskRecord[]>();
@@ -227,7 +280,8 @@ export function researchReport(records: ResearchRecord[], since = 0): ResearchRe
     return Object.fromEntries([...out].sort(([a], [b]) => a.localeCompare(b)).map(([k, rs]) => [k, measures(rs, labels)]));
   };
   return { overall: measures(all, labels), byClass: group((r) => [r.class ?? "unknown"]), byOwner: group((r) => r.owners.length ? [...new Set(r.owners)] : ["none"]),
-    byProject: group((r) => [r.project]), byModel: group((r) => r.models.length ? r.models : ["unknown"]) };
+    byProject: group((r) => [r.project]), byModel: group((r) => r.models.length ? r.models : ["unknown"]),
+    byMemoryBrief: group((r) => [!r.briefs ? "no brief recorded" : r.briefs.withFail ? "a fail note in its brief" : "brief without a fail note"]) };
 }
 
 const fmtPct = (v: number | null) => v === null ? "-" : `${Math.round(v * 100)}%`;
@@ -236,7 +290,76 @@ export function formatResearch(r: ResearchReport): string[] {
   const row = (name: string, m: Measures) => `${name.padEnd(24)} ${String(m.tasks).padStart(5)}  ${fmtPct(m.successRate).padStart(7)}  ${fmtPct(m.firstPassRate).padStart(10)}  ${(m.reworkRate === null ? "-" : m.reworkRate.toFixed(2)).padStart(6)}  ${fmtPct(m.checkFailureRate).padStart(11)}  ${fmtNum(m.tokensPerTask.median).padStart(10)}  ${fmtNum(m.tokensPerTask.p90).padStart(10)}  ${(m.wallMsPerTask.median === null ? "-" : `${Math.round(m.wallMsPerTask.median / 60_000)}m`).padStart(8)}`;
   const head = `${"".padEnd(24)} ${"tasks".padStart(5)}  ${"success".padStart(7)}  ${"first pass".padStart(10)}  ${"rework".padStart(6)}  ${"check fails".padStart(11)}  ${"tokens p50".padStart(10)}  ${"tokens p90".padStart(10)}  ${"wall p50".padStart(8)}`;
   const section = (title: string, groups: Record<string, Measures>) => Object.keys(groups).length ? [``, title, head, ...Object.entries(groups).map(([k, m]) => row(k, m))] : [];
-  return [head, row("all approved tasks", r.overall), ...section("by class", r.byClass), ...section("by owner", r.byOwner), ...section("by model", r.byModel), ...section("by project", r.byProject)];
+  return [head, row("all approved tasks", r.overall), ...section("by class", r.byClass), ...section("by owner", r.byOwner), ...section("by model", r.byModel), ...section("by project", r.byProject), ...(Object.keys(r.byMemoryBrief).some((k) => k !== "no brief recorded") ? section("by memory brief", r.byMemoryBrief) : [])];
+}
+
+/** Each approved task once, its last record, and every task's latest label: what both reports count. */
+function latestRecords(records: ResearchRecord[], since: number): { all: TaskRecord[]; labels: Map<string, Label> } {
+  const latest = new Map<string, TaskRecord>(), labels = new Map<string, Label>();
+  for (const r of records) {
+    const key = recordKey(r);
+    if (r.kind === "label") { labels.set(key, r.label); continue; }
+    if (Date.parse(r.approvedAt) >= since) latest.set(key, r);
+  }
+  return { all: [...latest.values()], labels };
+}
+
+/** The peers that worked on a task: every peer with an attributed event, else (older records) owners, reviewer and token peers. */
+const involved = (r: TaskRecord): string[] => [...new Set([...(r.peers ?? []), ...r.owners, ...(r.reviewer ? [r.reviewer] : []), ...Object.keys(r.tokens.byPeer)])].filter((p) => p !== "user");
+/** Own properties only: a peer may be named `constructor`, and a parsed record's object would answer with an inherited one. */
+const fingerprintOf = (r: TaskRecord, peer: string): Addon[] | undefined => r.tooling && Object.hasOwn(r.tooling, peer) ? r.tooling[peer] : undefined;
+
+type AddonMeasure = "successRate" | "firstPassRate" | "reworkRate" | "checkFailureRate" | "tokensMedian" | "wallMsMedian" | "collisionRate";
+const ADDON_MEASURES: AddonMeasure[] = ["successRate", "firstPassRate", "reworkRate", "checkFailureRate", "tokensMedian", "wallMsMedian", "collisionRate"];
+/** Every add-on measure of one set of tasks, computed once (a bootstrap calls this per resample). */
+function addonValues(rs: TaskRecord[], labels: Map<string, Label>): Record<AddonMeasure, number | null> {
+  const x = measures(rs, labels);
+  return { successRate: x.successRate, firstPassRate: x.firstPassRate, reworkRate: x.reworkRate, checkFailureRate: x.checkFailureRate,
+    tokensMedian: x.tokensPerTask.median, wallMsMedian: x.wallMsPerTask.median, collisionRate: pct(rs.reduce((n, r) => n + r.overlaps + r.conflicts, 0), rs.length) };
+}
+export interface AddonComparison {
+  addon: AddonName;
+  /** Tasks where a peer that worked on it had the add-on, where every such peer is known not to, and the rest. */
+  on: number; off: number; unknown: number;
+  measures: { measure: AddonMeasure; on: number | null; off: number | null; diff: number | null; low: number | null; high: number | null; inconclusive: boolean }[];
+}
+/**
+ * #248, observational: approved tasks with each add-on on against those with it off, by the tooling fingerprint each
+ * record carries. The difference is on minus off with a 95% bootstrap interval (seeded, so the same records give the
+ * same interval); below MIN_ATTEMPTS tasks on either side it is inconclusive. Field data shows association only: the
+ * peers, task mix and time differ between the sides. The causal side is `ahub bench` arms (docs/bench.md).
+ */
+export function addonReport(records: ResearchRecord[], since = 0, resamples = 1000, seed = 248): AddonComparison[] {
+  const { all, labels } = latestRecords(records, since);
+  return ADDONS.map((addon) => {
+    const side = { on: [] as TaskRecord[], off: [] as TaskRecord[], unknown: [] as TaskRecord[] };
+    for (const r of all) side[addonState(addon, involved(r).map((p) => fingerprintOf(r, p)))].push(r);
+    const random = mulberry32(seed);
+    const pick = (xs: TaskRecord[]) => Array.from({ length: xs.length }, () => xs[Math.floor(random() * xs.length)]!);
+    const samples = new Map<AddonMeasure, number[]>(ADDON_MEASURES.map((m) => [m, []]));
+    if (side.on.length && side.off.length) for (let i = 0; i < resamples; i++) {
+      const a = addonValues(pick(side.on), labels), b = addonValues(pick(side.off), labels);
+      for (const m of ADDON_MEASURES) { const x = a[m], y = b[m]; if (x !== null && y !== null) samples.get(m)!.push(x - y); }
+    }
+    const onValues = addonValues(side.on, labels), offValues = addonValues(side.off, labels);
+    return { addon, on: side.on.length, off: side.off.length, unknown: side.unknown.length, measures: ADDON_MEASURES.map((measure) => {
+      const on = onValues[measure], off = offValues[measure];
+      const s = samples.get(measure)!.sort((x, y) => x - y);
+      const rank = (q: number) => s[Math.min(s.length - 1, Math.max(0, Math.ceil(q * s.length) - 1))]!;
+      const diff = on !== null && off !== null ? on - off : null;
+      return { measure, on, off, diff, low: s.length ? rank(0.025) : null, high: s.length ? rank(0.975) : null,
+        inconclusive: diff === null || side.on.length < MIN_ATTEMPTS || side.off.length < MIN_ATTEMPTS };
+    }) };
+  });
+}
+export function formatAddons(rows: AddonComparison[]): string[] {
+  const fmt = (m: AddonMeasure, v: number | null) => v === null ? "-" : m === "tokensMedian" ? String(Math.round(v)) : m === "wallMsMedian" ? `${Math.round(v / 60_000)}m` : m === "reworkRate" || m === "collisionRate" ? v.toFixed(2) : `${Math.round(v * 100)}%`;
+  const out = ["add-on tasks with it on / off / unknown; on minus off with a 95% bootstrap interval (association, not cause)"];
+  for (const r of rows) {
+    out.push("", `${r.addon}: ${r.on} on, ${r.off} off, ${r.unknown} unknown`);
+    for (const m of r.measures) out.push(`  ${m.measure.padEnd(16)} on ${fmt(m.measure, m.on).padStart(6)}  off ${fmt(m.measure, m.off).padStart(6)}  diff ${fmt(m.measure, m.diff).padStart(6)} (${fmt(m.measure, m.low)} to ${fmt(m.measure, m.high)})${m.inconclusive ? `  inconclusive (fewer than ${MIN_ATTEMPTS} tasks on a side)` : ""}`);
+  }
+  return out;
 }
 
 export const CSV_COLUMNS = ["project", "task", "class", "pii", "outcome", "createdAt", "startedAt", "approvedAt", "wallMs", "activeMs", "owners",