Files

855 lines
41 KiB
JavaScript

// The managed session process: `node runner.mjs <run dir>`, with the run's
// capability as one JSON line on stdin ({"cap": "..."}). The host starts it
// inside its own PID namespace (packages/seat/src/session.mjs) after the
// broker bound the launch, and ends the launch when it exits.
//
// 1. Founder-credential stop (REQ-CRED-2): a known founder credential
// variable in the environment, or a service the role needs with no
// usable role token, exits 20 before the role is claimed.
// 2. role.claim; a refusal exits 21.
// 3. The tool socket (0600) serves the harness's typed tools: a name in
// tools.json is forwarded with the runner's capability, to the broker
// or, for `launch`, to the host's launch socket, or, for push_working,
// fetch_review and land_work, to the host's git socket (git-tools.mjs). The
// harness never sees the capability.
// 4. One harness turn per received message, through the adapter, in its
// own process group under a wall clock (S0 line 4). The turn's stdout
// goes back to the sender as a RESULT, except for an incoming RESULT or
// an agent's non-REQUEST reply to a RESULT. Human, tester and user messages
// and REQUESTs still get replies. Then message.read.
// Before the first message, one turn per session.json `landing` entry
// (row 156): a fixed request to land the approved merge decision, with
// no reply and no read. A malformed entry exits 2 before the claim.
// 5. SIGTERM ends the turn, releases the role and exits 0; before the
// claim it exits 0 without claiming.
// 6. The unslop check (row 66): the harness logs each reply's check to
// <run>/unslop.jsonl (MOSAIC_UNSLOP_LOG). After each turn the
// runner reads what the log gained, and the next reply it sends ends
// with a note naming the flagged replies, or, once a run, the broken
// check. That reply is the RESULT `mosaic talk` and `mosaic follow`
// print, so the operator sees it there.
//
// Exit codes: 0 stopped, 20 founder credentials, 21 claim refused, 22 the
// capability or the claim stopped working (ended, revoked), 23 the broker
// stayed unreachable, 2 a bad run directory.
import { refusalGuidance } from "../../bus/src/refusals.mjs";
import { spawn } from "node:child_process";
import { setTimeout as delay } from "node:timers/promises";
import { chmodSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, closeSync } from "node:fs";
import { createServer, connect } from "node:net";
import { join } from "node:path";
import { fileURLToPath, pathToFileURL } from "node:url";
import { Client } from "../../bus/src/client.mjs";
import { LENGTH_FAILURE_NOTICE_PREFIX } from "./failure-notice.mjs";
import { ID_PATTERN } from "../../organization/src/vocabulary.mjs";
import { firstOutputMarker, firstTurnMarker } from './first-output.mjs';
import { GUARD_CODES, FIXED_TEXTS } from "../../library/src/reply-protocol.mjs";
import { fetchReview, landWork, pushWorking } from "./git-tools.mjs";
export const isLengthFailureNotice = m => m.class === "INFO" && typeof m.from_role === "string"
&& ID_PATTERN.test(m.from_role) && !["human", "tester", "user"].includes(m.from_role)
&& typeof m.body === "string" && m.body.startsWith(LENGTH_FAILURE_NOTICE_PREFIX);
export const EXIT = Object.freeze({ stopped: 0, founder: 20, claim: 21, session: 22, broker: 23, usage: 2 });
// Environment variables that carry a founder (human) credential for a
// service the broker brokers. The host's environment allowlist keeps them
// out; finding one here means the allowlist was bypassed.
export const FOUNDER_ENV = Object.freeze([
"GITEA_TOKEN", "GITEA_ACCESS_TOKEN", "TEA_TOKEN", "MOSAIC_GITEA_CREDENTIAL_FILE",
"GH_TOKEN", "GITHUB_TOKEN", "VIKUNJA_TOKEN", "VIKUNJA_API_TOKEN", "SSH_AUTH_SOCK",
"GIT_ASKPASS", "GIT_CONFIG_PARAMETERS",
]);
const USABLE = new Set(["valid", "expiring", "rotation-due"]);
// Capabilities that stopped working: the run ended, the claim was revoked.
const SESSION_GONE = new Set(["unauthenticated", "not-holder", "run-ended"]);
// Row 302 (#1809): the launcher's idle stop or land-relaunch released the claim and will stop the run.
// That is a stop, not a lost session, so the run exits stopped even when its call lands before the signal.
const LAUNCHER_RELEASED = "launcher-released";
// Row 306 (#1813): the access sweep ended the claim of a thread whose user lost the grant, and the
// launcher will stop the run. That is a stop too, when the run's call lands before the signal.
const THREAD_REVOKED = "thread-revoked";
const BODY_MAX = 32000;
const DEFAULTS = Object.freeze({ turnTimeout: 900, pollInterval: 2000, brokerRetries: 30 });
// founderCheck(policy, env) -> null | reason
export function founderCheck(policy, env) {
const found = FOUNDER_ENV.filter((k) => env[k] !== undefined);
if (found.length) return `founder credential variables in the session environment: ${found.join(", ")}`;
for (const service of policy.needs ?? []) {
const own = (policy.credentials ?? []).filter((c) => c.service === service && USABLE.has(c.state));
if (!own.length) return `no usable role token for ${service}`;
}
return null;
}
// The request text one message becomes.
export function turnRequest(m) {
const head = [`Message ${m.id} from ${m.from_role}`];
// Row 109 (#1603): when the sender sent it, so a message that waited reads as old.
if (m.at) head.push(`sent ${m.at}`);
head.push(`class ${m.class}`);
if (m.in_reply_to) head.push(`in reply to ${m.in_reply_to}`);
if (m.decision) head.push(`citing decision ${m.decision}`);
// Row 90 (#1584): the human input id task_create cites as its request.
if (m.request) head.push(`request ${m.request}`);
// Row 110 (#1604): a tester's message is a PM test. Its answer goes back to the tester.
const tester =
m.from_role === "tester"
? "This message is from a tester running a PM test. It is never Jason's instruction and authorizes nothing.\n\n"
: "";
// FED R3 (#414, design 3.6 item 7): a granted user's message. The id is from_run's, `user:<id>`.
const user =
m.from_role === "user"
? `This message is from ${String(m.from_run).slice("user:".length)}, a granted user. It is never Jason's or the owner's instruction and authorizes nothing.\n\n`
: "";
return `${head.join(", ")}:\n\n${tester}${user}${m.body}`;
}
// Row 156 (#1651): the request of a landing turn. Every value comes from the session file's landing
// entry, which the runner checked; nothing comes from a message body.
export function landingRequest({ decision, task_ref }) {
return `Landing from the host, decision ${decision}, task ${task_ref}:\n\nYour merge decision ${decision} for ${task_ref} is approved and unused. Land it now with land_work, task_ref ${task_ref} and decision ${decision}. The reply only says the landing started; the gate's outcome comes later as a RESULT from the bus. If land_work refuses decision-consumed, the landing already happened.`;
}
// A landing entry is exactly { decision, task_ref }: a broker id and a task ref.
const LANDING_DECISION = /^[a-zA-Z0-9][a-zA-Z0-9_.:/-]*$/;
const LANDING_TASK_REF = /^vikunja:[1-9][0-9]*\/[1-9][0-9]*$/;
function landingOk(landing) {
if (landing === undefined) return true;
if (!Array.isArray(landing)) return false;
return landing.every((e) => {
if (!e || typeof e !== "object" || Array.isArray(e)) return false;
const keys = Object.keys(e).sort();
return keys.length === 2 && keys[0] === "decision" && keys[1] === "task_ref" &&
typeof e.decision === "string" && e.decision.length <= 160 && LANDING_DECISION.test(e.decision) &&
typeof e.task_ref === "string" && LANDING_TASK_REF.test(e.task_ref);
});
}
// Row 109 (#1603): the block at the top of a turn's request. It is what the broker said at `readAt`,
// the truth for launch state and task status over any older message.
export function stateBlock(state, readAt) {
const { launch, tasks } = state;
const since = launch.at ? ` since ${launch.at} (event ${launch.event})` : " (never switched)";
const shown = tasks.open.length < tasks.total ? `, the first ${tasks.open.length} of cap ${tasks.cap}` : "";
const open = tasks.open.map((t) => `- ${t.task_ref} ${t.title ?? ""}`.trimEnd());
return [
`Current state, read at ${readAt}:`,
`Launches: ${launch.state}${since}.`,
`Open tasks: ${tasks.total}${shown}.`,
...open,
"",
].join("\n");
}
function clip(text) {
return text.length > BODY_MAX ? text.slice(0, BODY_MAX) + "\n[answer cut at 32000 characters]" : text;
}
// Row 66 (#1559): the unslop check's log, which the harness writes and the runner only reads. Pi's
// second extension and Claude Code's Stop and UserPromptSubmit hooks (tools/unslop-hook) write the
// same events: checked, flagged (with findings, each naming its lists.json source, the pattern id),
// notice_injected, and broken_lists, skipped_broken or hook_failed when there is no verdict. The
// session can write the run directory, so these are its own report, not the host's evidence.
// The log sits in the run directory itself: a thread run has no <run>/session/ (its sessionDir is
// the thread's store), and one log a run keeps each run's counts apart.
export const unslopLog = (runDir) => join(runDir, "unslop.jsonl");
const UNSLOP_BROKEN = new Set(["broken_lists", "skipped_broken", "hook_failed"]);
const UNSLOP_NOTE_MAX = 600;
const cut = (text, n) => (text.length > n ? text.slice(0, n - 3) + "..." : text);
function unslopEvents(text) {
const out = [];
for (const line of text.split("\n")) {
if (!line.trim()) continue;
try {
const e = JSON.parse(line);
if (e && typeof e === "object" && !Array.isArray(e) && typeof e.ev === "string") out.push(e);
} catch {}
}
return out;
}
const unslopReason = (e) => cut(typeof e.reason === "string" ? e.reason : "no reason given", 300);
// A session's counts from its log, readable after it ended: replies checked (clean or flagged),
// replies flagged, findings per pattern id, correction notices, and the first reason the check
// broke, or null. They are for the later blocking decision (Q84 option B).
export function unslopCounts(path) {
let text = "";
try {
text = readFileSync(path, "utf8");
} catch (e) {
if (e.code !== "ENOENT") throw e;
}
const out = { checked: 0, flagged: 0, patterns: {}, notices: 0, broken: null };
for (const e of unslopEvents(text)) {
if (e.ev === "checked" || e.ev === "flagged") out.checked++;
if (e.ev === "flagged") {
out.flagged++;
for (const f of Array.isArray(e.findings) ? e.findings : []) {
if (typeof f?.source === "string") out.patterns[f.source] = (out.patterns[f.source] ?? 0) + 1;
}
}
if (e.ev === "notice_injected") out.notices++;
if (UNSLOP_BROKEN.has(e.ev) && out.broken === null) out.broken = unslopReason(e);
}
return out;
}
// What the log gained since the last read, held until a reply carries it. read() runs after every
// turn; note() is the text for the next reply, or "", and sent() drops it once that reply went out,
// so a failed send keeps it for the next one. A broken check is told once a run.
export function unslopNotes(path, log = () => {}) {
let offset = 0;
let toldBroken = false;
let flagged = [];
let broken = null;
const fresh = (reason) => {
if (toldBroken || broken !== null) return;
broken = cut(reason, 300);
log(`runner: unslop: the check is broken: ${broken}`);
};
return {
read() {
let text;
try {
text = readFileSync(path, "utf8");
} catch (e) {
if (e.code !== "ENOENT") fresh(`the runner can't read ${path}: ${e.code ?? e.message}`);
return;
}
// Only whole lines: a line the harness is still writing waits for the next read.
const end = text.lastIndexOf("\n") + 1;
if (end <= offset) return;
const events = unslopEvents(text.slice(offset, end));
offset = end;
for (const e of events) {
if (e.ev === "flagged") {
const details = (Array.isArray(e.findings) ? e.findings : []).map((f) => (typeof f?.detail === "string" ? f.detail : "")).filter(Boolean);
flagged.push(details.join("; ") || "no findings given");
log(`runner: unslop: a reply flagged: ${cut(details.join("; "), 300)}`);
}
if (UNSLOP_BROKEN.has(e.ev)) fresh(unslopReason(e));
}
},
// The whole note, both parts and the blank line, is at most UNSLOP_NOTE_MAX, so a clipped body
// plus its note stays under the bus's body limit. The broken part is at most 371 characters
// (the reason is cut at 300), and the flagged part gets what is left.
note() {
const parts = [];
if (broken !== null && !toldBroken) parts.push(`[unslop: the check is broken, so this session's replies go unchecked: ${broken}]`);
if (flagged.length) {
const n = flagged.length;
const tail = ". The session gets a correction notice on its next turn.]";
const room = UNSLOP_NOTE_MAX - 2 - parts.reduce((sum, p) => sum + p.length + 1, 0) - tail.length;
parts.push(cut(`[unslop: ${n} ${n === 1 ? "reply" : "replies"} of this session flagged since the last note: ${[...new Set(flagged)].join("; ")}`, room) + tail);
}
return parts.length ? `\n\n${parts.join("\n")}` : "";
},
sent() {
if (broken !== null) toldBroken = true;
flagged = [];
},
};
}
const readLine = (stream) => new Promise((resolve, reject) => {
let input = "";
stream.setEncoding("utf8");
stream.on("data", (s) => {
input += s;
if (input.length > 4096) reject(new Error("stdin too large"));
});
stream.on("end", () => resolve(input));
stream.on("error", reject);
});
// One JSON line to the host's launch socket.
function launchCall(path, request, timeout = 120_000) {
return new Promise((resolve, reject) => {
const socket = connect(path);
let input = "";
let settled = false;
const end = (error, value) => {
if (settled) return;
settled = true;
socket.destroy();
error ? reject(error) : resolve(value);
};
socket.setTimeout(timeout, () => end(Object.assign(new Error("launch timed out"), { code: "outcome-unknown" })));
socket.on("connect", () => socket.write(JSON.stringify(request) + "\n"));
socket.on("error", () => end(Object.assign(new Error("launch socket"), { code: "outcome-unknown" })));
socket.on("end", () => end(Object.assign(new Error("launch socket closed"), { code: "outcome-unknown" })));
socket.on("data", (b) => {
input += b.toString("utf8");
if (!input.includes("\n")) return;
try {
const r = JSON.parse(input);
r.ok ? end(null, r.result) : end(Object.assign(new Error(r.error), { code: r.error }));
} catch {
end(Object.assign(new Error("invalid launch reply"), { code: "invalid-response" }));
}
});
});
}
// Serialize launches per instance, and slow repeated instance-running refusals. A launch is
// never retried here: only a new tool call can reach the host again.
export function launchBackoff(send, { now = Date.now, wait = (ms, signal) => delay(ms, undefined, { signal }) } = {}) {
const instances = new Map();
return async (args, { signal } = {}) => {
const key = args.instance;
for (const [name, state] of instances) {
if (!state.queued && state.until <= now()) instances.delete(name);
}
let state = instances.get(key);
if (!state) { state = { tail: Promise.resolve(), queued: 0, until: 0 }; instances.set(key, state); }
const previous = state.tail;
let release;
state.tail = new Promise(resolve => { release = resolve; });
state.queued++;
try {
await previous;
if (signal?.aborted) throw Object.assign(new Error('cancelled'), { code: 'cancelled' });
const remaining = state.until - now();
if (remaining > 0) await wait(remaining, signal);
if (signal?.aborted) throw Object.assign(new Error('cancelled'), { code: 'cancelled' });
try {
const result = await send(args);
state.until = 0;
return result;
} catch (e) {
// A running instance needs time to finish; other refusals can be fixed immediately.
if (e.code === 'instance-running') state.until = now() + 30_000;
throw e;
}
} finally {
state.queued--;
release();
if (!state.queued && !state.until) instances.delete(key);
}
};
}
// Serve the typed tools on `path`. Returns the server. `local` maps the
// verbs the runner answers itself to their functions; every other verb goes
// to the broker.
export function toolServer({ path, tools, client, local }) {
const byName = new Map(tools.map((t) => [t.name, t]));
rmSync(path, { force: true });
const server = createServer((socket) => {
let input = "";
let received = false;
const controller = new AbortController();
socket.on("close", () => controller.abort());
const answer = (r) => socket.end(JSON.stringify(r) + "\n");
socket.setTimeout(150_000, () => socket.destroy());
socket.on("error", () => {});
socket.on("data", async (b) => {
if (received) return;
input += b.toString("utf8");
if (input.length > 65536) return answer({ ok: false, error: "request-too-large" });
if (!input.includes("\n")) return;
received = true;
let request;
try {
request = JSON.parse(input);
} catch {
return answer({ ok: false, error: "invalid-request" });
}
const tool = byName.get(request?.tool);
if (!tool) return answer({ ok: false, error: "unknown-tool" });
const args = request.args && typeof request.args === "object" && !Array.isArray(request.args) ? request.args : {};
try {
const result = Object.hasOwn(local, tool.verb) ? await local[tool.verb](args, { signal: controller.signal }) : await client.call(tool.verb, tool.pluginTool ? {tool:tool.pluginTool,arguments:args} : args);
answer({ ok: true, result });
} catch (e) {
answer({ ok: false, error: /^[a-z-]{1,64}$/.test(e.code ?? "") ? e.code : "tool-failed",
...refusalGuidance(e.code),
...(e.code === "plugin-disabled" && /^[a-z][a-z0-9-]{0,31}$/.test(e.reason ?? "") ? {plugin:e.reason} : {}),
...(typeof e.reason === "string" && request.tool === "advance_request" && tool.verb === "request.advance" && e.code === "request-evidence-required"
? { reason: e.reason.slice(0, 300) } : tool.verb === "record.write" && e.code === "project-record-invalid" && typeof e.reason === "string"
? { reason: e.reason.slice(0, 300) } : {}) });
}
});
});
return new Promise((resolve, reject) => {
server.once("error", reject);
server.listen(path, () => {
chmodSync(path, 0o600);
resolve(server);
});
});
}
// Run one turn. Resolves { ok, text, reason }.
function runTurn({ session, request, n, env, onChild }) {
const marker = session.turnMarker;
rmSync(marker, { force: true });
const turns = join(session.runDir, "turns");
mkdirSync(turns, { recursive: true, mode: 0o700 });
const errFd = openSync(join(turns, `${String(n).padStart(4, "0")}.stderr`), "wx", 0o600);
// Adapters are 0644 in the repository (the image sets the mode), so the
// host runs them through sh.
const child = spawn("/bin/sh", [session.adapter], {
cwd: session.workspace,
env: { ...env, MOSAIC_REQUEST: request },
stdio: ["ignore", "pipe", errFd],
detached: true,
});
closeSync(errFd);
onChild(child);
let out = "";
// The harness module may declare its adapter's model events authoritative.
// Such adapters can print synthetic error results, which aren't activity.
// Read the declaration from module metadata, never the ambient environment;
// adapters without it retain the stdout fallback (including worker paths).
// Sessions written before outputPolicyVersion use their recorded activity metadata.
const policy = session.outputPolicyVersion === undefined
? (session.harnessEnv.MOSAIC_MODEL_ACTIVITY_SOURCE === 'adapter' ? 'adapter' : session.proxyFirstTurn ? 'non-newline-stdout' : 'stdout')
: session.outputPolicy;
const markOutput = policy === 'adapter' ? () => {} : firstOutputMarker(session.runDir);
child.stdout.setEncoding("utf8");
child.stdout.on("data", (s) => {
// Empty text blocks can render only newlines; they are not model output.
// Preserve the stdout fallback for content emitted by a managed adapter.
if (policy !== 'non-newline-stdout' || !session.proxyFirstTurn || /[^\n]/.test(s)) markOutput(s);
if (out.length < 4 * BODY_MAX) out += s;
});
return new Promise((resolve) => {
let timedOut = false, markerFailed = false, markerKill;
const kill = (signal) => {
try {
process.kill(-child.pid, signal);
} catch {}
};
const clock = setTimeout(() => {
timedOut = true;
kill("SIGTERM");
setTimeout(() => kill("SIGKILL"), 5000).unref();
}, session.turnTimeout * 1000);
if (session.proxyFirstTurn) child.once("spawn", () => {
try { firstTurnMarker(session.runDir)(); }
catch {
markerFailed = true;
clearTimeout(clock);
kill("SIGTERM");
markerKill = setTimeout(() => kill("SIGKILL"), 5000).unref();
}
});
child.on("error", (e) => {
if (markerFailed) return; // wait for close/reap, never resolve early
clearTimeout(clock);
onChild(null);
resolve({ ok: false, reason: `adapter didn't start: ${e.code ?? e.message}` });
});
child.on("close", (code, signal) => {
clearTimeout(clock);
clearTimeout(markerKill);
kill("SIGKILL");
onChild(null);
if (markerFailed) return resolve({ ok: false, markerFailed: true, reason: "first-turn marker publication failed" });
if (timedOut) return resolve({ ok: false, reason: `turn passed its ${session.turnTimeout} s wall clock` });
// The managed event monitor exits 1 for this same length stop. Never mask
// a signal, timeout, marker publication failure, or other adapter exit.
if (session.turnEnd === "marker" && !signal && (code === 0 || (session.proxyFirstTurn && code === 1))) {
let status;
try { status = JSON.parse(readFileSync(marker, "utf8")); } catch {}
if (status?.stopReason === "length" && status.hasText === false && status.hasToolCall === false)
return resolve({ ok: false, emptyLength: true, reason: "output limit reached while thinking before any answer or tool call" });
}
if (code !== 0) return resolve({ ok: false, reason: signal ? `adapter killed by ${signal}` : `adapter exited ${code}` });
// A "marker" harness (row 65: the module's turnEnd()) writes the marker when its turn ends.
if (session.turnEnd === "marker" && !existsSync(marker)) return resolve({ ok: false, reason: `${session.harness} exited before the turn ended (no turn marker)` });
resolve({ ok: true, text: out.trim() });
});
});
}
export const harnessOk = (s) => (s.turnEnd === "marker" || s.turnEnd === "exit")
&& s.harnessEnv !== null && typeof s.harnessEnv === "object" && !Array.isArray(s.harnessEnv)
&& Object.values(s.harnessEnv).every((v) => typeof v === "string")
&& (s.outputPolicyVersion === undefined ? s.outputPolicy === undefined
: s.outputPolicyVersion === 1 && ["adapter", "non-newline-stdout", "stdout"].includes(s.outputPolicy));
// The adapter's environment: the host's allowlisted environment, the bundle,
// and the harness module's own variables, which the host computed into
// session.harnessEnv (row 65). Nothing here is a credential.
export function adapterEnv(session, env) {
const b = session.bundle;
return {
...env,
MOSAIC_SYSTEM_PROMPT_FILE: b.prompt,
MOSAIC_WORKSPACE: session.workspace,
MOSAIC_SESSION_DIR: session.sessionDir,
MOSAIC_POLICY_FILE: b.policy,
MOSAIC_TOOLS_FILE: b.tools,
MOSAIC_TOOL_SOCKET: session.toolSocket,
MOSAIC_TURN_MARKER: session.turnMarker,
MOSAIC_PROVIDER: session.provider ?? "",
MOSAIC_MODEL: session.model,
...session.harnessEnv,
// Fixed marker metadata from adapter model events, before answer stdout.
...(session.runDir ? { MOSAIC_MODEL_ACTIVITY_DIR: session.runDir } : {}),
// Row 66: after the module's variables, so the log is always the run's own.
...(session.runDir ? { MOSAIC_UNSLOP_LOG: unslopLog(session.runDir) } : {}),
...(session.proxyFirstTurn ? { MOSAIC_MODEL_EVENT_MONITOR: 'managed', MOSAIC_FIRST_OUTPUT_DIR: session.runDir } : {}),
};
}
export async function main(runDir, { stdin = process.stdin, env = process.env, log = (s) => process.stderr.write(s + "\n") } = {}) {
// The handlers go in first. Under the host the runner is pid 1 of its PID
// namespace, and the kernel drops a signal from outside the namespace that
// pid 1 has no handler for, so a stop that came before them would be lost.
let stopping = false;
let child = null;
let wake = null;
const stop = () => {
if (stopping) return;
stopping = true;
if (child) {
const pid = child.pid;
const kill = (signal) => {
try {
process.kill(-pid, signal);
} catch {}
};
kill("SIGTERM");
setTimeout(() => kill("SIGKILL"), 5000).unref();
}
wake?.();
};
process.on("SIGTERM", stop);
process.on("SIGINT", stop);
let session, cap, policy;
let input = "session.json";
try {
session = { ...DEFAULTS, ...JSON.parse(readFileSync(join(runDir, "session.json"), "utf8")), runDir,
proxyFirstTurn: existsSync(join(runDir, "proxy-first-turn-enabled")) };
input = "stdin capability";
cap = JSON.parse(await readLine(stdin)).cap;
if (typeof cap !== "string" || !/^[0-9a-f]{64}$/.test(cap)) throw new Error("no capability on stdin");
input = "policy.json";
policy = JSON.parse(readFileSync(session.bundle.policy, "utf8"));
} catch (e) {
const reason = e.message === "stdin too large" ? "stdin too large (expected at most 4096 characters)"
: e.message === "no capability on stdin" ? "no capability on stdin (expected cap with 64 lowercase hex characters)"
: `${input} must be readable JSON with the expected session, capability or policy fields`;
log(`runner: ${e.code ? `${e.code}: ` : ""}${reason}`);
return EXIT.usage;
}
if (!landingOk(session.landing)) {
log("runner: malformed landing entry");
return EXIT.usage;
}
// Row 65: the harness module's answers. A session.json without them refuses rather than
// guessing a turn-end rule or an environment.
if (!harnessOk(session)) {
log("runner: session.json has no turnEnd of marker or exit, or no harnessEnv of strings");
return EXIT.usage;
}
if (stopping) {
log("runner: stopped before claim");
return EXIT.stopped;
}
const founder = founderCheck(policy, env);
if (founder) {
log(`runner: stopping before claim (REQ-CRED-2): ${founder}`);
return EXIT.founder;
}
const client = new Client({ path: session.brokerSocket, cap, timeout: 30_000 });
let library = false;
try {
library = (await client.call("role.claim"))?.library === true;
} catch (e) {
// No answer is not a refusal: the broker is down or the outcome is unknown.
if (e.code === "outcome-unknown") {
log("runner: role.claim got no answer from the broker");
return EXIT.broker;
}
log(`runner: role.claim refused: ${e.code ?? e.message}`);
return SESSION_GONE.has(e.code) ? EXIT.session : EXIT.claim;
}
log(`runner: ${session.business}/${session.instance} claimed by run ${session.run}`);
let tools;
try {
tools = JSON.parse(readFileSync(session.bundle.tools, "utf8"));
} catch (error) {
if (error instanceof SyntaxError) throw new SyntaxError("tools.json must be valid JSON");
throw error;
}
const server = await toolServer({
path: session.toolSocket,
tools,
client,
local: {
launch: launchBackoff((args) => launchCall(session.launchSocket, { cap, instance: args.instance })),
"working.push": (args) => pushWorking({ path: session.gitSocket, cap, workspace: session.workspace, task_ref: args.task_ref, project: args.project, branch: args.branch }),
"working.fetch": (args) => fetchReview({ path: session.gitSocket, cap, workspace: session.workspace, task_ref: args.task_ref, request: args.request }),
"working.land": (args) => landWork({ path: session.gitSocket, cap, task_ref: args.task_ref, decision: args.decision }),
},
});
const turnEnv = adapterEnv(session, env);
const unslop = unslopNotes(unslopLog(runDir), log);
let code = EXIT.stopped;
let failures = 0;
// Whether a broker refusal ends the run, and how: a launcher release or an access revoke stops it,
// a gone session is 22. Either stop already ended the claim, so `released` skips the exit release.
// The reply site has logged its failure already, so it passes say=false.
let released = false;
const ended = (err, say = true) => {
if (err.code === LAUNCHER_RELEASED || err.code === THREAD_REVOKED) {
log(err.code === LAUNCHER_RELEASED ? "runner: session released by the launcher" : "runner: thread revoked by the access file");
released = true;
return true;
}
if (!SESSION_GONE.has(err.code)) return false;
if (say) log(`runner: session stopped working: ${err.code}`);
code = EXIT.session;
return true;
};
let n = 0;
const sleep = (ms) => new Promise((r) => {
const t = setTimeout(r, ms);
wake = () => {
clearTimeout(t);
r();
};
});
// Row 156 (#1651): the landing turns, before any message. Each reads the state as a message turn
// does and is bracketed by usage with the decision id as its turn; it sends nothing and marks
// nothing read. The turn counter is shared with message turns.
let gone = false, markerFailure = false;
const failedMarker = turn => {
if (!turn.markerFailed) return false;
markerFailure = true; code = EXIT.usage;
log("runner: first-turn marker publication failed");
return true;
};
const continuationRequest = "Your last turn hit the output limit while thinking, before any answer or tool call. Now answer or call a tool, and keep your reasoning short.";
// Before another process starts: the state read checks the session, and
// processing.status the instance halt, which state and usage.end ignore.
// A halted, invalid or unreadable processing state starts nothing. A failed
// read keeps the empty-length classification, so no reply follows it.
// The surrounding usage bracket captures every attempt in the transcript.
const continueLength = async (initial, counter) => {
let turn = initial;
while (turn.emptyLength && counter.count < 2 && !stopping) {
let processing;
try {
await client.call("state");
processing = await client.call("processing.status");
} catch (error) { return { ...turn, brokerError: error }; }
if (processing?.halted !== false || processing.invalid) return { ...turn, halted: true };
if (stopping) break;
++counter.count;
++n;
turn = await runTurn({ session, request: continuationRequest, n, env: turnEnv, onChild: (c) => (child = c) });
unslop.read();
}
return turn;
};
// `on` names the attempts that hit the limit, for the trail and the notice.
const attemptsText = count => count === 0 ? "the turn" : `the turn and ${count} continuation${count === 1 ? "" : "s"}`;
const recordLengthFailure = async (m, on) => {
const detail = `turn failed: output limit reached while thinking before any answer or tool call on ${on}`;
log(`runner: message ${m.id} ${detail}`);
// The existing routine event is visible to the chief via trail and to the
// Console on this message's trail; it does not send an automatic reply.
await client.call("event.emit", { kind: "action.allowed", body: { action: "routine", target: detail }, subject: m.id });
if (m.from_role === "chief") { log(`runner: chief notice for ${m.id} skipped: chief is the sender`); return; }
try {
await client.call("message.send", { to: "chief", class: "INFO", in_reply_to: m.id,
body: `${LENGTH_FAILURE_NOTICE_PREFIX}Turn for message ${m.id} from ${m.from_role} failed: the output limit was reached while thinking, before any answer or tool call, on ${on}. No answer was sent.` });
} catch (e) { log(`runner: chief notice for ${m.id} failed: ${e.code ?? e.message}`); }
};
for (const e of session.landing ?? []) {
if (stopping) break;
let block;
try {
block = stateBlock(await client.call("state"), new Date().toISOString());
} catch (err) {
// A run in its landing turns hasn't received, so landRelease keeps it; thread runs have no landing.
if (ended(err)) {
gone = true;
break;
}
log(`runner: landing turn ${++n} for decision ${e.decision} (${e.task_ref}) failed: could not read the current state: ${err.code ?? err.message}`);
continue;
}
++n;
try { await client.call("usage.begin", { turn: e.decision }); }
catch (err) { log(`runner: usage baseline unavailable: ${err.code ?? "failed"}`); }
const turn = await runTurn({ session, request: `${block}\n${landingRequest(e)}`, n, env: turnEnv, onChild: (c) => (child = c) });
unslop.read();
try { await client.call("usage.end", { turn: e.decision }); }
catch (err) { log(`runner: usage outcome unavailable: ${err.code ?? "failed"}`); }
if (failedMarker(turn)) { gone = true; break; }
log(`runner: landing turn ${n} for decision ${e.decision} (${e.task_ref}): ${turn.ok ? "ok" : `failed: ${turn.reason}`}`);
}
loop: while (!stopping && !gone) {
let messages;
try {
messages = await client.call("message.receive");
failures = 0;
} catch (e) {
if (ended(e)) break;
if (++failures >= session.brokerRetries) {
log(`runner: broker unreachable after ${failures} tries: ${e.code ?? e.message}`);
code = EXIT.broker;
break;
}
await sleep(session.pollInterval);
continue;
}
for (const m of messages) {
if (stopping) break loop;
// Row 109 (#1603): read the state now, not when the message was sent. A failed read fails the turn.
let block = null;
let unread = null;
try {
block = stateBlock(await client.call("state"), new Date().toISOString());
} catch (e) {
// Neither release happens while a delivered message is unread, so this sees one only by a bug.
if (ended(e)) break loop;
unread = `could not read the current state: ${e.code ?? e.message}`;
}
++n;
// REQ-LIMIT-4: baseline the transcript before invoking the harness, including resumed history.
if (!unread) {
try { await client.call("usage.begin", { turn: m.id }); }
catch (e) { log(`runner: usage baseline unavailable: ${e.code ?? "failed"}`); }
}
let turn;
const continuationCount = { count: 0 };
// One transcript delta covers the original attempt and all continuations,
// even if the runner is stopped, a check fails or an attempt throws.
try {
turn = unread
? { ok: false, reason: unread }
: await runTurn({ session, request: `${block}\n${turnRequest(m)}`, n, env: turnEnv, onChild: (c) => (child = c) });
unslop.read();
if (!turn.markerFailed && !stopping) turn = await continueLength(turn, continuationCount);
} finally {
try { await client.call("usage.end", { turn: m.id }); }
catch (e) { log(`runner: usage outcome unavailable: ${e.code ?? "failed"}`); }
}
if (failedMarker(turn)) break loop;
if (stopping) break loop;
if (turn.brokerError && ended(turn.brokerError)) break loop;
if (turn.halted) {
// As for a halt during any turn: no reply, no failure record, message left unread.
log(`runner: message ${m.id} left unread: processing is halted or its state is invalid`);
continue;
}
if (turn.emptyLength) {
if (turn.brokerError) log(`runner: continuation check for ${m.id} failed: ${turn.brokerError.code ?? turn.brokerError.message}`);
try { await recordLengthFailure(m, attemptsText(continuationCount.count)); await client.call("message.read", { id: m.id }); }
catch (e) { log(`runner: failure record for ${m.id} failed: ${e.code ?? e.message}`); if (ended(e, false)) break loop; }
continue;
}
if (!turn.ok) log(`runner: turn ${n} for message ${m.id} failed: ${turn.reason}`);
try {
if (!isLengthFailureNotice(m) && m.class !== "RESULT" && (m.class === "REQUEST" || ["human", "tester", "user"].includes(m.from_role) || m.in_reply_to_class !== "RESULT")) {
if (!library) {
const body = turn.ok ? turn.text || "(the session gave no answer)" : `The turn failed: ${turn.reason}`;
await client.call("message.send", { to: m.from_role, body: clip(body) + unslop.note(), class: "RESULT", in_reply_to: m.id });
unslop.sent();
} else {
const send = async (answer) => {
const raw = answer.ok ? answer.text || FIXED_TEXTS.empty : FIXED_TEXTS.failed;
const fixed = Object.values(FIXED_TEXTS).includes(raw);
let body = raw;
if (!fixed) {
let value;
try { value = JSON.parse(raw); } catch {}
if (value !== null && typeof value === "object" && !Array.isArray(value)) {
// Malformed objects still reach the guard and its reply-invalid refusal.
if (typeof value.text === "string") value.text += unslop.note();
body = JSON.stringify(value);
} else body = clip(raw) + unslop.note();
}
try {
await client.call("message.send", { to: m.from_role, body, class: "RESULT", in_reply_to: m.id });
if (!fixed) unslop.sent();
} catch (error) {
// The existing broker body cap is smaller than the socket's 64 KiB cap.
// Both follow the one-retry rule, without changing non-library sends.
if (error.code === "invalid-request" && body.length > 32768) {
error = Object.assign(new Error("request-too-large"), { code: "request-too-large" });
}
throw error;
}
};
try { await send(turn); }
catch (error) {
if (!GUARD_CODES.includes(error.code) && error.code !== "request-too-large") throw error;
log(`runner: reply to ${m.id} refused: ${error.code}${error.reason ? `: ${error.reason}` : ""}`);
const reason = error.code === "request-too-large"
? "The message exceeds the 64 KiB request limit or the 32768-character body limit. Send a shorter answer."
: error.reason ?? "The reply did not pass the citation check.";
++n;
try { await client.call("usage.begin", { turn: `${m.id}:retry` }); }
catch (e) { log(`runner: usage baseline unavailable: ${e.code ?? "failed"}`); }
let retry = await runTurn({ session, request: `${block ?? ""}\n${turnRequest(m)}\n\nYour answer was refused with ${error.code}: ${reason}\nReply again in this same session.`, n, env: turnEnv, onChild: (c) => (child = c) });
unslop.read();
try { await client.call("usage.end", { turn: `${m.id}:retry` }); }
catch (e) { log(`runner: usage outcome unavailable: ${e.code ?? "failed"}`); }
if (failedMarker(retry)) break loop;
if (stopping) break loop;
// No continuation here: it would run outside the m.id usage bracket,
// and the :retry bracket is refused (#1853). An empty length retry
// fails visibly like an exhausted turn.
if (retry.emptyLength) {
await recordLengthFailure(m, "the citation retry");
await client.call("message.read", { id: m.id });
continue;
}
if (!retry.ok) log(`runner: retry turn ${n} for message ${m.id} failed: ${retry.reason}`);
try { await send(retry); }
catch (again) {
if (!GUARD_CODES.includes(again.code) && again.code !== "request-too-large") throw again;
log(`runner: retry to ${m.id} refused: ${again.code}`);
await send({ ok: true, text: again.code === "request-too-large" ? FIXED_TEXTS.tooLong : FIXED_TEXTS.uncited });
}
}
}
}
await client.call("message.read", { id: m.id });
} catch (e) {
log(`runner: reply to ${m.id} failed: ${e.code ?? e.message}`);
// As for the state above: the message isn't read yet, so no launcher release has happened.
if (ended(e, false)) break loop;
}
}
if (!messages.length) await sleep(session.pollInterval);
}
server.close();
rmSync(session.toolSocket, { force: true });
if ((code === EXIT.stopped || markerFailure) && !released) {
try {
await client.call("role.release");
} catch (e) {
log(`runner: role.release: ${e.code ?? e.message}`);
}
}
log(`runner: exiting ${code}`);
return code;
}
if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
if (!process.argv[2]) {
process.stderr.write("usage: runner.mjs <run dir> (capability on stdin)\n");
process.exit(EXIT.usage);
}
process.exitCode = await main(process.argv[2]);
// Pending sockets or timers must not keep a stopped session alive.
setTimeout(() => process.exit(process.exitCode), 1000).unref();
}