trantor 0.18.49 → 0.18.51

package/bin/drill-report.mjs

@@ -0,0 +1,80 @@
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { signedPost } from "../hooks/lib/api.mjs";
+
+// A PASS assertion is evidence, not a verdict: every mapped step must finish cleanly.
+export class DrillReport {
+  constructor(map, path, { project, session }) {
+    this.map = map;
+    this.path = path;
+    this.project = project;
+    this.session = session;
+    this.steps = {};
+    this.closures = {};
+    for (const { steps, autoClose, recipe } of Object.values(map)) {
+      if (autoClose || !recipe) continue;
+      for (const step of steps) this.steps[step] = {
+        complete: true, checks: [{ status: "skip", assertion: recipe, evidence: "" }],
+      };
+    }
+    this.write();
+  }
+
+  record(step, status, assertion, evidence = "") {
+    (this.steps[step] ||= { complete: false, checks: [] }).checks.push({ status, assertion, evidence });
+    this.write();
+  }
+
+  complete(step) {
+    (this.steps[step] ||= { complete: false, checks: [] }).complete = true;
+    this.write();
+  }
+
+  cardsFor(step) {
+    return Object.keys(this.map).filter(id => this.map[id].steps.includes(step));
+  }
+
+  results() {
+    return Object.fromEntries(Object.entries(this.map).map(([id, { steps }]) => {
+      const evidence = steps.flatMap(step => {
+        const row = this.steps[step];
+        return row?.checks.length
+          ? row.checks.map(check => `${step} ${check.status}: ${check.assertion}${check.evidence ? ` — ${check.evidence}` : ""}`)
+          : [`${step} fail: not run`];
+      });
+      const complete = steps.every(step => {
+        const row = this.steps[step];
+        return row?.complete && row.checks.length > 0 && row.checks.every(check => check.status !== "fail");
+      });
+      const skipped = steps.some(step => this.steps[step]?.checks.some(check => check.status === "skip"));
+      return [id, { status: complete ? skipped ? "skip" : "pass" : "fail", evidence, closure: this.closures[id] || "not attempted" }];
+    }));
+  }
+
+  write() {
+    mkdirSync(dirname(this.path), { recursive: true });
+    const temp = `${this.path}.${process.pid}.tmp`;
+    writeFileSync(temp, JSON.stringify(this.results(), null, 2) + "\n", { mode: 0o600 });
+    renameSync(temp, this.path);
+  }
+
+  exitCode() {
+    // Manual recipes stay visible as SKIP; only missing/failed proof or a refused close is red.
+    return Object.values(this.results()).some(result => result.status === "fail" || result.closure.startsWith("failed:")) ? 1 : 0;
+  }
+
+  async closePassed() {
+    for (const [id, result] of Object.entries(this.results())) {
+      if (!this.map[id].autoClose || result.status !== "pass" || this.closures[id]) continue;
+      const response = await signedPost("/task/update", {
+        id: Number(id), project: this.project, by: this.session, status: "done",
+        note: `trantor drill PASS\n${result.evidence.join("\n")}`.slice(0, 2000),
+      }, { project: this.project, session: this.session, timeoutMs: 15000 });
+      this.closures[id] = response.ok && response.json?.task?.status === "done"
+        && response.json.task.id === Number(id) && response.json.task.project === this.project
+        ? "done" : `failed: hub ${response.status} ${response.json?.error || "did not confirm done"}`;
+      this.write();
+    }
+    return Object.values(this.closures).every(value => value === "done");
+  }
+}

package/bin/drill-report.test.mjs

@@ -0,0 +1,146 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createServer, createConnection } from "node:net";
+import { DrillReport } from "./drill-report.mjs";
+import { CARD_STEPS, findHandoff } from "./drill-surface.mjs";
+import { appVerdict, startDrillHub, stopChild, checkSocketHome } from "./drill-seams.mjs";
+import { signedGet, signedPost } from "../hooks/lib/api.mjs";
+
+test("S4 waits for the hook ledger when relay_handoff arrives first", () => {
+  const world = mkdtempSync(join(import.meta.dirname, "..", ".agent-bus-out", "ledger-"));
+  try {
+    assert.equal(findHandoff(join(world, "missing"), "trantor"), null);
+    writeFileSync(join(world, "trantor-100.json"), JSON.stringify({ summary: "tool handoff" }));
+    writeFileSync(join(world, "trantor-101.json"), "{");
+    writeFileSync(join(world, "trantor-102.json"), JSON.stringify({ states: [] }));
+    writeFileSync(join(world, "other-100.json"), JSON.stringify({ states: [{ state: "written" }] }));
+    assert.equal(findHandoff(world, "trantor"), null);
+    const ledger = join(world, "trantor-103.json");
+    writeFileSync(ledger, JSON.stringify({ states: [{ state: "written" }] }));
+    assert.equal(findHandoff(world, "trantor"), ledger);
+    writeFileSync(ledger, JSON.stringify({ states: [{ state: "written" }, { state: "claimed" }, { state: "recapped" }] }));
+    assert.equal(findHandoff(world, "trantor"), ledger);
+  } finally { rmSync(world, { recursive: true, force: true }); }
+});
+
+test("signed closer on an enforce hub: complete evidence closes, partial/failure/skip never does", async () => {
+  const out = join(import.meta.dirname, "..", ".agent-bus-out");
+  mkdirSync(out, { recursive: true });
+  const world = mkdtempSync(join(out, "closer-test-"));
+  const bus = join(world, "bus");
+  const hub = await startDrillHub(world, bus);
+  const saved = { ...process.env };
+  Object.assign(process.env, { RELAY_URL: hub.url, AGENT_BUS_DIR: bus, RELAY_SESSION: "drill:trantor", RELAY_PROJECT: "trantor" });
+  const project = "trantor", session = "drill:trantor";
+  const path = join(world, "drill-result.json");
+  try {
+    const create = await signedPost("/task", { project, by: session, title: "closer test", status: "testing" });
+    assert.equal(create.ok, true, JSON.stringify(create));
+    const id = create.json.task.id;
+    const report = new DrillReport({ [id]: { steps: ["one", "two"], autoClose: true } }, path, { project, session });
+    report.record("one", "pass", "first assertion", "real evidence A");
+    await report.closePassed();
+    assert.equal(report.results()[id].status, "fail");
+    assert.equal((await signedGet("/tasks?project=trantor")).json.tasks[0].status, "testing");
+    report.complete("one");
+    report.record("two", "pass", "second assertion", "real evidence B");
+    report.complete("two");
+    assert.equal(await report.closePassed(), true);
+    const card = (await signedGet("/tasks?project=trantor")).json.tasks[0];
+    assert.equal(card.status, "done");
+    assert.equal(card.workedBy, session);
+    assert.match(card.log.at(-1).text, /real evidence A/);
+    assert.match(card.log.at(-1).text, /real evidence B/);
+    assert.equal(JSON.parse(readFileSync(path, "utf8"))[id].closure, "done");
+    const notes = card.log.length;
+    await report.closePassed();
+    assert.equal((await signedGet("/tasks?project=trantor")).json.tasks[0].log.length, notes);
+    const unsigned = await fetch(`${hub.url}/task/update`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id, status: "testing", by: session }) });
+    assert.equal(unsigned.status, 401);
+
+    for (const status of ["fail", "skip"]) {
+      const created = await signedPost("/task", { project, by: session, title: status, status: "testing" });
+      const blockedId = created.json.task.id;
+      const blocked = new DrillReport({ [blockedId]: { steps: ["step"], autoClose: true } }, path, { project, session });
+      blocked.record("step", "pass", "partial success");
+      blocked.record("step", status, "missing proof");
+      blocked.complete("step");
+      await blocked.closePassed();
+      assert.equal(blocked.results()[blockedId].status, status);
+      assert.equal((await signedGet("/tasks?project=trantor")).json.tasks.find(row => row.id === blockedId).status, "testing");
+    }
+    const missing = new DrillReport({ 999999: { steps: ["step"], autoClose: true } }, path, { project, session });
+    missing.record("step", "pass", "proof");
+    missing.complete("step");
+    assert.equal(await missing.closePassed(), false);
+    assert.match(missing.results()[999999].closure, /failed: hub 404/);
+    assert.equal(missing.exitCode(), 1);
+    const fresh = new DrillReport({ [id]: { steps: ["one"], autoClose: true } }, path, { project, session });
+    assert.equal(fresh.results()[id].status, "fail", "a rerun cannot inherit old PASS evidence");
+  } finally {
+    for (const key of Object.keys(process.env)) if (!(key in saved)) delete process.env[key];
+    Object.assign(process.env, saved);
+    await stopChild(hub.child);
+    rmSync(world, { recursive: true, force: true });
+  }
+});
+
+test("app proof requires every leg and rejects skipped key targets", () => {
+  assert.deepEqual(CARD_STEPS[6317].steps, ["S6-key-post", "S6-key-throw"]);
+  assert.equal(appVerdict("ask", "ask-drill PASS:"), false);
+  assert.equal(appVerdict("ask", "ask-drill open PASS\nask-drill cold PASS\nask-drill PASS:"), true);
+  const key = [1, 2, 3].map(pass => `key-drill pass=${pass} posted keyDown+keyUp`).join("\n") + "\nkey-drill verdict exit=0";
+  assert.equal(appVerdict("key-post", key), true);
+  assert.equal(appVerdict("key-post", key + "\npass=2 skipped"), false);
+  assert.equal(appVerdict("key-throw", key), false);
+  assert.equal(appVerdict("key-throw", key, "TaoObjcExceptionDrill"), true);
+  assert.equal(appVerdict("handoff", "handoff-drill PASS:\nhandoff-drill verdict exit=3"), false);
+});
+
+test("manual probes remain SKIP even when the runner stops before reaching them", () => {
+  const world = mkdtempSync(join(import.meta.dirname, "..", ".agent-bus-out", "skip-"));
+  try {
+    const report = new DrillReport(CARD_STEPS, join(world, "result.json"), { project: "trantor", session: "drill:trantor" });
+    assert.deepEqual(Object.keys(CARD_STEPS).filter(id => CARD_STEPS[id].autoClose), ["6481", "6667", "6668"]);
+    for (const id of [6317, 6533, 6587, 6483]) {
+      assert.equal(report.results()[id].status, "skip");
+      assert.equal(report.results()[id].closure, "not attempted");
+      assert.match(report.results()[id].evidence.join(" "), id === 6587 ? /live duty probe/ : /covered by in-app Drill Mode/);
+    }
+    assert.equal(report.exitCode(), 1, "unrun seams still fail");
+    for (const { steps, recipe } of Object.values(CARD_STEPS)) {
+      if (recipe) continue;
+      for (const step of steps) {
+        report.record(step, step === "S5" ? "skip" : "pass", step === "S5" ? "interactive Terminal takeover probe" : "seam proof");
+        report.complete(step);
+      }
+    }
+    assert.equal(report.exitCode(), 0, "passing seams plus manual SKIPs exit zero");
+    report.record("S4", "fail", "ledger missing");
+    assert.equal(report.exitCode(), 1, "a real seam failure remains fatal");
+  } finally { rmSync(world, { recursive: true, force: true }); }
+});
+
+test("short drill HOME connects through the native socket symlink; old staging is rejected", async () => {
+  const world = mkdtempSync(`${join(import.meta.dirname, "..", ".agent-bus-out")}/`);
+  const server = createServer(socket => socket.end("connected"));
+  try {
+    const path = checkSocketHome(world);
+    assert.throws(() => checkSocketHome(join(world, "x".repeat(108))), /too long/);
+    mkdirSync(join(world, ".config", "herdr"), { recursive: true });
+    const target = join(world, "s");
+    await new Promise((resolve, reject) => { server.once("error", reject); server.listen(target, resolve); });
+    symlinkSync(target, path);
+    const proof = await new Promise((resolve, reject) => {
+      const socket = createConnection(path);
+      socket.once("error", reject);
+      socket.once("data", data => resolve(data.toString()));
+    });
+    assert.equal(proof, "connected");
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+    rmSync(world, { recursive: true, force: true });
+  }
+});

package/bin/drill-seams.mjs

@@ -0,0 +1,157 @@
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, symlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { createServer } from "node:net";
+import { workspacePane, splitPane } from "./crew/herdr.mjs";
+
+const ROOT = dirname(import.meta.dirname);
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+const herdr = args => JSON.parse(execFileSync("herdr", args, { encoding: "utf8", timeout: 30000 }));
+const read = path => existsSync(path) ? readFileSync(path, "utf8") : "";
+
+export function checkSocketHome(home) {
+  const socket = join(home, ".config", "herdr", "herdr.sock");
+  if (Buffer.byteLength(socket) >= (process.platform === "darwin" ? 104 : 108)) {
+    throw new Error(`drill HOME socket path is too long: ${socket}; use a shorter TRANTOR_DRILL_WORLD inside .agent-bus-out`);
+  }
+  return socket;
+}
+
+export function isolatedEnv(home, bus, overrides = {}) {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) {
+    if (/^(RELAY_|TRANTOR_|CLAUDE_CODE_|HERDR_|AGENT_BUS_)/.test(key) || key === "CLAUDECODE") delete env[key];
+  }
+  return { ...env, HOME: home, AGENT_BUS_DIR: bus, RELAY_DATA_DIR: bus, ...overrides };
+}
+
+export async function stopChild(child) {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  child.kill("SIGTERM");
+  await Promise.race([new Promise(resolve => child.once("close", resolve)), sleep(2000)]);
+  if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+}
+
+export async function startDrillHub(home, bus, auth = "enforce") {
+  mkdirSync(bus, { recursive: true });
+  const probe = createServer();
+  await new Promise(resolve => probe.listen(0, "127.0.0.1", resolve));
+  const port = probe.address().port;
+  await new Promise(resolve => probe.close(resolve));
+  const url = `http://127.0.0.1:${port}`;
+  const env = isolatedEnv(home, bus, {
+    RELAY_PORT: String(port), RELAY_HOST: "127.0.0.1", RELAY_URL: url,
+    RELAY_AUTH: auth, RELAY_ENROLL: "tofu", RELAY_STORE: "json",
+  });
+  const child = spawn(process.execPath, [join(ROOT, "hub.mjs")], { env, stdio: "ignore" });
+  for (let attempt = 0; attempt < 100; attempt++) {
+    try {
+      if ((await fetch(`${url}/health`, { signal: AbortSignal.timeout(500) })).ok) return { child, env, url };
+    } catch { /* The private hub has not bound its port yet. */ }
+    if (child.exitCode !== null) break;
+    await sleep(100);
+  }
+  await stopChild(child);
+  throw new Error("private drill hub did not become ready");
+}
+
+export function appVerdict(kind, trace, panics = "") {
+  if (/\b(?:FAILED|FAIL|ERROR)\b/.test(trace)) return false;
+  if (kind === "ask") return /ask-drill open PASS/.test(trace) && /ask-drill cold PASS/.test(trace) && /ask-drill PASS:/.test(trace);
+  if (kind === "handoff") return /handoff-drill PASS:/.test(trace) && /handoff-drill verdict exit=0/.test(trace);
+  return /key-drill verdict exit=0/.test(trace) && !/skipped/.test(trace)
+    && [1, 2, 3].every(pass => trace.includes(`pass=${pass} posted keyDown+keyUp`))
+    && (kind !== "key-throw" || panics.includes("TaoObjcExceptionDrill"));
+}
+
+async function launchApp(kind, env, bus) {
+  const binary = process.env.TRANTOR_DRILL_APP || "/Applications/Trantor.app/Contents/MacOS/Trantor";
+  if (!existsSync(binary)) throw new Error(`installed app missing: ${binary}; no build/install attempted`);
+  const tracePath = join(bus, "app-trace.log");
+  const panicPath = join(bus, "app-panics.log");
+  const offset = read(tracePath).length;
+  const panicOffset = read(panicPath).length;
+  const child = spawn(binary, [], { env, stdio: "ignore", timeout: 180000, killSignal: "SIGKILL" });
+  let spawnError = null;
+  child.once("error", error => { spawnError = error; });
+  const deadline = Date.now() + 180000;
+  let trace = "";
+  try {
+    await sleep(1000);
+    execFileSync("osascript", ["-e", `tell application "System Events" to set frontmost of (first process whose unix id is ${child.pid}) to true`], { timeout: 10000, stdio: "ignore" });
+    while (Date.now() < deadline) {
+      trace = read(tracePath).slice(offset);
+      if (spawnError) throw spawnError;
+      if (appVerdict(kind, trace, read(panicPath).slice(panicOffset))) return `${tracePath}: ${trace.trim().split("\n").filter(line => /PASS|survived|verdict/.test(line)).join("; ")}`;
+      if (/\b(?:FAILED|FAIL|ERROR)\b/.test(trace) || child.exitCode !== null || child.signalCode !== null) break;
+      await sleep(500);
+    }
+    throw new Error(`${kind}: no complete app proof (exit=${child.exitCode} signal=${child.signalCode}); ${tracePath}: ${trace.trim().slice(-500)}`);
+  } finally {
+    await stopChild(child);
+    // The app normally closes these in its own finally. If it timed out first, only this
+    // launch's trace can authorize cleanup; never sweep the shared herdr workspace list.
+    for (const match of trace.matchAll(/ask-drill (?:open|cold) herdr workspace=(\S+)/g)) {
+      try { herdr(["workspace", "close", match[1]]); } catch { /* Already closed by the app. */ }
+    }
+  }
+}
+
+export async function runAppDrills({ world, proj, project, run }) {
+  // The HOME socket pathname must fit sockaddr_un even when it is a symlink.
+  const home = world;
+  const bus = join(home, "app-bus");
+  mkdirSync(join(home, ".config", "herdr"), { recursive: true });
+  const socket = checkSocketHome(home);
+  if (!existsSync(socket)) symlinkSync(join(homedir(), ".config", "herdr", "herdr.sock"), socket);
+  let hub;
+  try {
+    hub = await startDrillHub(home, bus, "off");
+    await fetch(`${hub.url}/project`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ project, brief: "Throwaway drill project" }) });
+    writeFileSync(join(bus, "config.json"), JSON.stringify({ url: hub.url, hubs: { [project]: hub.url }, contextWindow: 200000 }));
+    const env = { ...hub.env, TRANTOR_DEV_ROOT: dirname(proj), TRANTOR_ROOT: ROOT };
+    const created = herdr(["workspace", "create", "--cwd", proj, "--label", `tt-dead-drill-${process.pid}`, "--no-focus"]);
+    const workspace = created.result.workspace.workspace_id;
+    const pane = created.result.root_pane.pane_id;
+    try {
+      const sid = "00000000-0000-4000-8000-000000000092";
+      const transcripts = join(home, ".claude", "projects", proj.replace(/[/.]/g, "-"));
+      mkdirSync(transcripts, { recursive: true });
+      writeFileSync(join(transcripts, `${sid}.jsonl`), JSON.stringify({ type: "assistant", sessionId: sid, cwd: proj, timestamp: new Date().toISOString(), message: { model: "claude-sonnet-4-5", role: "assistant", usage: { input_tokens: 184000, output_tokens: 1, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 }, content: [{ type: "text", text: "dead drill session" }] } }) + "\n");
+      writeFileSync(join(bus, "crew-windows.txt"), `${project}\therdrws\t__ws__\t${workspace}\n${project}\torch\torchestrator\t${pane}\n`);
+      writeFileSync(join(bus, "orch-sessions.txt"), `${project}\t${sid}\n`);
+      await run("S6-handoff · app dead-pane guard", async () => {
+        const before = herdr(["pane", "process-info", "--pane", pane]).result.process_info.shell_pid;
+        const evidence = await launchApp("handoff", { ...env, TRANTOR_HANDOFF_DRILL: project }, bus);
+        const after = herdr(["pane", "process-info", "--pane", pane]).result.process_info.shell_pid;
+        if (!before || before !== after) throw new Error("dead-pane shell did not survive");
+        return `${evidence}; shell ${after} survived`;
+      });
+    } finally { herdr(["workspace", "close", workspace]); }
+  } catch (error) {
+    await run("S6-handoff · app setup", () => { throw error; });
+  } finally { if (hub) await stopChild(hub.child); }
+}
+
+export async function crewWorkspaceDrill({ proj, workspace }) {
+  if (!workspace) throw new Error("S1 left no project workspace");
+  const ctx = { env: process.env, have: { herdr: true } };
+  const host = workspacePane(ctx, workspace, proj);
+  if (!host) throw new Error("no project-local host pane");
+  const foreign = herdr(["workspace", "create", "--cwd", proj, "--label", `tt-focus-drill-${process.pid}`, "--focus"]);
+  const panes = [];
+  try {
+    for (let i = 0; i < 4; i++) {
+      const pane = splitPane(ctx, panes.at(-1) || host, "right", proj);
+      if (!pane) throw new Error("crew split failed");
+      panes.push(pane);
+    }
+    const rows = herdr(["pane", "list"]).result.panes;
+    if (!panes.every(id => rows.some(row => row.pane_id === id && row.workspace_id === workspace && row.cwd === proj))) throw new Error("a crew split landed outside the project workspace/cwd");
+    return `focused=${foreign.result.workspace.workspace_id}; seats=${panes.join(",")}; workspace=${workspace}; cwd=${proj}`;
+  } finally {
+    for (const pane of panes) herdr(["pane", "close", pane]);
+    herdr(["workspace", "close", foreign.result.workspace.workspace_id]);
+  }
+}