@orkestrel/scaffold 0.0.77 → 0.0.78

package/dist/agents/skills/orkestrel-dispatch/scripts/launch.js

@@ -0,0 +1,108 @@
+// Journaled launch of a bench exec or any command that outlives a turn. Run from the checkout root:
+//   node .agents/skills/orkestrel-dispatch/scripts/launch.ts --journal tmp/codex/UNIT.jsonl --errors tmp/codex/UNIT.err --cap 1500 [--status] -- codex exec --json ...
+// The command's stdout goes to --journal and its stderr to --errors; stdin is closed. Arguments after
+// `--` pass to the command verbatim, so no shell quoting is involved. --cap is in seconds: when it
+// expires the process tree is killed and the errors file records `capped=true`. --status records
+// `git status --porcelain` before and after beside the journal, which is how a read-only lane's
+// containment is checked. Stdout carries up to two JSON lines. The spawn line
+// `{"pid","journal","errors"}` prints as soon as the command starts, and the pid, as decimal digits
+// and a newline, goes to `<journal>.pid`. A pid file an earlier run left on the same journal is
+// removed before the spawn, so neither appears when the command cannot start. The summary line
+// prints last, after the command exits, and the errors file ends with `exit=<code>`. At the cap,
+// Windows kills the process tree; any other host kills the command alone, not its descendants.
+// The launcher's own flags are read before `--` alone. Exit: the command's code; 124 when capped;
+// 127 when the command could not start (the errors file names why); 64 on usage, including a
+// journal and errors path that are the same file and a cap that is not a number of seconds.
+import { spawn, spawnSync } from 'node:child_process';
+import { appendFileSync, closeSync, mkdirSync, openSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { readMissingFlags, readOption } from "./helpers.js";
+function readStatus() {
+    const result = spawnSync('git', ['status', '--porcelain'], { encoding: 'utf8' });
+    return result.status === 0 ? result.stdout : `git status failed: ${result.stderr}`;
+}
+function killTree(pid) {
+    if (process.platform === 'win32') {
+        spawnSync('taskkill', ['/pid', String(pid), '/T', '/F'], { stdio: 'ignore' });
+        return;
+    }
+    try {
+        process.kill(pid, 'SIGKILL');
+    }
+    catch { }
+}
+function waitForExit(child) {
+    return new Promise((resolve) => {
+        child.on('error', (error) => resolve({ code: null, signal: null, error: error.message }));
+        child.on('close', (code, signal) => resolve({ code, signal, error: undefined }));
+    });
+}
+async function main(argv) {
+    const separator = argv.indexOf('--');
+    // The launcher's own flags end at the separator; everything after it belongs to the command.
+    const own = separator === -1 ? argv : argv.slice(0, separator);
+    const journal = readOption(own, '--journal');
+    const errors = readOption(own, '--errors');
+    const cap = readMissingFlags(own, ['--cap']).length > 0
+        ? Number.NaN
+        : Number(readOption(own, '--cap') ?? '0');
+    const [command, ...args] = separator === -1 ? [] : argv.slice(separator + 1);
+    if (separator === -1 ||
+        journal === undefined ||
+        errors === undefined ||
+        journal === errors ||
+        !Number.isFinite(cap) ||
+        cap < 0 ||
+        command === undefined ||
+        command === '') {
+        console.error('usage: launch.ts --journal PATH --errors PATH --cap SECONDS [--status] -- COMMAND [ARGS...]; the journal and the errors file differ, and the cap is a number of seconds (0 for none)');
+        return 64;
+    }
+    const status = own.includes('--status');
+    mkdirSync(dirname(journal), { recursive: true });
+    mkdirSync(dirname(errors), { recursive: true });
+    if (status)
+        writeFileSync(`${journal}.status-before.txt`, readStatus());
+    const journalFd = openSync(journal, 'w');
+    const errorsFd = openSync(errors, 'w');
+    rmSync(`${journal}.pid`, { force: true });
+    const started = Date.now();
+    const child = spawn(command, args, { stdio: ['ignore', journalFd, errorsFd], windowsHide: true });
+    if (child.pid !== undefined) {
+        writeFileSync(`${journal}.pid`, `${child.pid}\n`);
+        console.log(JSON.stringify({ pid: child.pid, journal, errors }));
+    }
+    let capped = false;
+    const timer = cap > 0
+        ? setTimeout(() => {
+            capped = true;
+            if (child.pid !== undefined)
+                killTree(child.pid);
+        }, cap * 1000)
+        : undefined;
+    const exit = await waitForExit(child);
+    if (timer !== undefined)
+        clearTimeout(timer);
+    closeSync(journalFd);
+    closeSync(errorsFd);
+    const durationMs = Date.now() - started;
+    appendFileSync(errors, `${exit.error === undefined ? '' : `launch: the command could not start: ${exit.error}\n`}\nexit=${exit.error === undefined ? (exit.code ?? 'null') : '127'} signal=${exit.signal ?? 'none'} capped=${capped} duration_ms=${durationMs}\n`);
+    if (status)
+        writeFileSync(`${journal}.status-after.txt`, readStatus());
+    console.log(JSON.stringify({
+        pid: child.pid,
+        exit: exit.error === undefined ? exit.code : 127,
+        signal: exit.signal,
+        capped,
+        durationMs,
+        journal,
+        errors,
+        error: exit.error,
+    }));
+    if (exit.error !== undefined)
+        return 127;
+    return capped ? 124 : (exit.code ?? 1);
+}
+main(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+});

package/dist/agents/skills/orkestrel-dispatch/scripts/login.js

@@ -0,0 +1,114 @@
+// Recover a bench login. Run from the checkout root:
+//   node .agents/skills/orkestrel-dispatch/scripts/login.ts --codex [--cap SECONDS]
+//   node .agents/skills/orkestrel-dispatch/scripts/login.ts --claude
+// --codex reads `codex login status`; when it reports no login, the script runs
+// `codex login --device-auth` with its output journaled to tmp/codex/login.log, prints the
+// verification URL and the one-time code the moment the journal carries them, polls
+// `codex login status` every 5 seconds until it answers or the cap (default 600 seconds) ends, then
+// kills the login by its pid. --claude reads `claude auth status` and prints it. The JSON summary
+// carries `live`; exit 0 when the bench is logged in, 3 when it is not, 64 on usage.
+import { spawn, spawnSync } from 'node:child_process';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync } from 'node:fs';
+import { readMissingFlags, readOption } from "./helpers.js";
+const JOURNAL = 'tmp/codex/login.log';
+const POLL_MS = 5_000;
+const URL_PATTERN = /https?:\/\/[^\s"'<>]+/u;
+const CODE_PATTERN = /\b([A-Z0-9]{4,5}-[A-Z0-9]{4,5})\b/u;
+function readStatus(command, args) {
+    const result = spawnSync(command, args, { encoding: 'utf8', windowsHide: true });
+    if (result.error !== undefined)
+        return { live: false, text: `${command} could not start: ${result.error.message}` };
+    return { live: result.status === 0, text: `${result.stdout ?? ''}${result.stderr ?? ''}`.trim() };
+}
+function killTree(pid) {
+    if (process.platform === 'win32') {
+        spawnSync('taskkill', ['/pid', String(pid), '/T', '/F'], { stdio: 'ignore' });
+        return;
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch { }
+}
+function waitFor(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+async function loginCodex(capSeconds) {
+    const before = readStatus('codex', ['login', 'status']);
+    if (before.live) {
+        console.log(JSON.stringify({ bench: 'codex', live: true, status: before.text }));
+        return 0;
+    }
+    mkdirSync('tmp/codex', { recursive: true });
+    const journal = openSync(JOURNAL, 'w');
+    const started = Date.now();
+    const child = spawn('codex', ['login', '--device-auth'], {
+        stdio: ['ignore', journal, journal],
+        windowsHide: true,
+    });
+    let url;
+    let code;
+    let live = false;
+    while (Date.now() - started < capSeconds * 1000) {
+        await waitFor(POLL_MS);
+        const text = existsSync(JOURNAL) ? readFileSync(JOURNAL, 'utf8') : '';
+        if (url === undefined) {
+            url = text.match(URL_PATTERN)?.[0];
+            if (url !== undefined)
+                console.error(`login: open ${url}`);
+        }
+        if (code === undefined) {
+            code = text.match(CODE_PATTERN)?.[1];
+            if (code !== undefined)
+                console.error(`login: enter the code ${code}`);
+        }
+        if (child.exitCode !== null && readStatus('codex', ['login', 'status']).live) {
+            live = true;
+            break;
+        }
+        if (child.exitCode === null && readStatus('codex', ['login', 'status']).live) {
+            live = true;
+            break;
+        }
+    }
+    if (child.exitCode === null && child.pid !== undefined)
+        killTree(child.pid);
+    closeSync(journal);
+    console.log(JSON.stringify({
+        bench: 'codex',
+        live,
+        url,
+        code,
+        durationMs: Date.now() - started,
+        journal: JOURNAL,
+        status: readStatus('codex', ['login', 'status']).text,
+    }));
+    return live ? 0 : 3;
+}
+function loginClaude() {
+    const status = readStatus('claude', ['auth', 'status']);
+    console.log(JSON.stringify({ bench: 'claude', live: status.live, status: status.text }));
+    return status.live ? 0 : 3;
+}
+async function main(argv) {
+    const missing = readMissingFlags(argv, ['--cap']);
+    if (missing.length > 0) {
+        console.error(`login: ${missing.join(', ')} given with no value`);
+        return 64;
+    }
+    if (argv.includes('--codex') && argv.includes('--claude')) {
+        console.error('usage: login.ts names one bench: --codex [--cap SECONDS] | --claude');
+        return 64;
+    }
+    if (argv.includes('--codex'))
+        return loginCodex(Number(readOption(argv, '--cap') ?? 600));
+    if (argv.includes('--claude'))
+        return loginClaude();
+    console.error('usage: login.ts --codex [--cap SECONDS] | --claude');
+    return 64;
+}
+main(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+});

package/dist/agents/skills/orkestrel-dispatch/scripts/result.js

@@ -0,0 +1,108 @@
+// Read a bench lane's answer, session id, and liveness from its journal. Run from the checkout root:
+//   node .agents/skills/orkestrel-dispatch/scripts/result.ts --cursor tmp/cursor/UNIT.jsonl [--out tmp/cursor/UNIT-result.md]
+//   node .agents/skills/orkestrel-dispatch/scripts/result.ts --claude tmp/claude/UNIT.jsonl [--out tmp/claude/UNIT-result.md]
+//   node .agents/skills/orkestrel-dispatch/scripts/result.ts --codex tmp/codex/UNIT.jsonl [--out tmp/codex/UNIT-result.md]
+// A Cursor or Claude journal is the `--output-format stream-json` stream: the `init` event carries
+// the session id and the `result` event carries the answer. A Codex journal is the `--json` stream:
+// the `thread.started` event carries the thread id and the answer sits in the sibling `UNIT-last.md`
+// file that `--output-last-message` wrote. The summary also reads the sibling `UNIT.err` file that
+// launch.ts wrote (`exit`, `capped`, `durationMs`) and the journal's `bytes`, `ageMs`, and last
+// event, which is the liveness reading for a run still going. The answer is written to --out when
+// given, and a journal with no session or answer exits 3 so a driver cannot pass off an empty lane.
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { readMissingFlags, readNumber, readOption, readString } from "./helpers.js";
+function readEvents(path) {
+    const events = [];
+    for (const line of readFileSync(path, 'utf8').split(/\r\n|\n/)) {
+        if (line.trim() === '')
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                events.push(Object.fromEntries(Object.entries(parsed)));
+            }
+        }
+        catch { }
+    }
+    return events;
+}
+function readAnswer(text) {
+    return text === undefined || text.trim() === '' ? undefined : text;
+}
+function readStream(events) {
+    const init = events.find((event) => event.type === 'system' && event.subtype === 'init');
+    const result = events.find((event) => event.type === 'result');
+    return {
+        session: init === undefined ? undefined : readString(init, 'session_id'),
+        answer: result === undefined ? undefined : readAnswer(readString(result, 'result')),
+        durationMs: result === undefined ? undefined : readNumber(result, 'duration_ms'),
+    };
+}
+function readCodex(path, events) {
+    const started = events.find((event) => event.type === 'thread.started');
+    const last = path.replace(/\.jsonl$/u, '-last.md');
+    return {
+        session: started === undefined ? undefined : readString(started, 'thread_id'),
+        answer: existsSync(last) ? readAnswer(readFileSync(last, 'utf8')) : undefined,
+        durationMs: undefined,
+    };
+}
+function readErrors(path) {
+    const errors = path.replace(/\.jsonl$/u, '.err');
+    if (!existsSync(errors))
+        return { exit: undefined, capped: undefined, durationMs: undefined };
+    const match = readFileSync(errors, 'utf8').match(/exit=(\S+) signal=\S+ capped=(true|false) duration_ms=(\d+)\s*$/u);
+    if (match === null)
+        return { exit: undefined, capped: undefined, durationMs: undefined };
+    const exit = Number(match[1]);
+    return {
+        exit: Number.isFinite(exit) ? exit : undefined,
+        capped: match[2] === 'true',
+        durationMs: Number(match[3]),
+    };
+}
+function describeEvent(event) {
+    if (event === undefined)
+        return undefined;
+    const type = readString(event, 'type');
+    const subtype = readString(event, 'subtype');
+    return subtype === undefined ? type : `${type}/${subtype}`;
+}
+function main(argv) {
+    const missing = readMissingFlags(argv, ['--cursor', '--claude', '--codex', '--out']);
+    if (missing.length > 0) {
+        console.error(`result: ${missing.join(', ')} given with no value`);
+        return 64;
+    }
+    const modes = ['--cursor', '--claude', '--codex'].filter((flag) => argv.includes(flag));
+    const mode = modes[0];
+    const path = mode === undefined ? undefined : readOption(argv, mode);
+    const out = readOption(argv, '--out');
+    if (modes.length !== 1 || mode === undefined || path === undefined || !existsSync(path)) {
+        console.error('usage: result.ts (--cursor JOURNAL | --claude JOURNAL | --codex JOURNAL) [--out PATH]; name one mode');
+        return 64;
+    }
+    const events = readEvents(path);
+    const reading = mode === '--codex' ? readCodex(path, events) : readStream(events);
+    const errors = readErrors(path);
+    const stat = statSync(path);
+    if (reading.answer !== undefined && out !== undefined) {
+        mkdirSync(dirname(out), { recursive: true });
+        writeFileSync(out, reading.answer);
+    }
+    console.log(JSON.stringify({
+        journal: path,
+        session: reading.session,
+        durationMs: reading.durationMs ?? errors.durationMs,
+        exit: errors.exit,
+        capped: errors.capped,
+        bytes: stat.size,
+        ageMs: Math.max(0, Math.round(Date.now() - stat.mtimeMs)),
+        lastEvent: describeEvent(events.at(-1)),
+        answerLength: reading.answer?.length ?? 0,
+        out: reading.answer === undefined ? undefined : out,
+    }));
+    return reading.session === undefined || reading.answer === undefined ? 3 : 0;
+}
+process.exitCode = main(process.argv.slice(2));

package/dist/agents/skills/orkestrel-dispatch/scripts/sweep.js

@@ -0,0 +1,156 @@
+// Campaign artifact sweep. Run from the checkout root with Node's type stripping:
+//   node .agents/skills/orkestrel-dispatch/scripts/sweep.ts --report
+//   node .agents/skills/orkestrel-dispatch/scripts/sweep.ts --tmp [--older-than MINUTES]
+//   node .agents/skills/orkestrel-dispatch/scripts/sweep.ts --unit UNIT [--delete]
+// --report lists leftovers under tmp/ and .orkestrel/ by age and deletes nothing.
+// --tmp deletes launch files older than the threshold (default 60 minutes), removes emptied
+// directories, and refuses while any launch file changed in the last 2 minutes.
+// --unit lists one accepted unit's files under the launch directories (the brief, report, claims,
+// journal, errors, status, pid, and last-message files whose name is UNIT followed by `-` or `.`), and
+// --delete removes them, refusing while one changed in the last 2 minutes.
+// Exit 0 on success, 2 when a deletion is refused, 64 on usage.
+import { existsSync, readdirSync, rmSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { listFiles, readMissingFlags, readOption } from "./helpers.js";
+const LAUNCH_DIRECTORIES = [
+    'tmp/units',
+    'tmp/cursor',
+    'tmp/codex',
+    'tmp/claude',
+    'tmp/probes',
+    'tmp/type',
+    'tmp/captures',
+];
+const RECENT_MS = 2 * 60_000;
+// A launch directory holds nothing a walk skips, so every file beneath it counts.
+const NOTHING_SKIPPED = new Set();
+function formatDay(modified) {
+    return new Date(modified).toISOString().slice(0, 10);
+}
+function reportDirectory(directory) {
+    if (!existsSync(directory))
+        return undefined;
+    const files = listFiles(directory, NOTHING_SKIPPED);
+    if (files.length === 0)
+        return undefined;
+    const oldest = files.reduce((low, file) => Math.min(low, file.modified), Number.POSITIVE_INFINITY);
+    return `sweep: ${directory} holds ${files.length} file(s), oldest ${formatDay(oldest)}`;
+}
+function listCampaignDirectories() {
+    if (!existsSync('.orkestrel'))
+        return [];
+    return readdirSync('.orkestrel', { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => join('.orkestrel', entry.name));
+}
+function reportCampaignFiles() {
+    if (!existsSync('.orkestrel'))
+        return undefined;
+    const files = readdirSync('.orkestrel', { withFileTypes: true }).filter((entry) => entry.isFile());
+    if (files.length === 0)
+        return undefined;
+    return `sweep: .orkestrel holds ${files.length} ecosystem file(s): ${files.map((entry) => entry.name).join(', ')}`;
+}
+function removeEmptyDirectories(directory) {
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const path = join(directory, entry.name);
+        removeEmptyDirectories(path);
+        if (readdirSync(path).length === 0)
+            rmSync(path, { recursive: true });
+    }
+}
+function readThreshold(argv) {
+    if (!argv.includes('--older-than'))
+        return 60;
+    const value = Number(readOption(argv, '--older-than'));
+    return Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function runReport() {
+    for (const directory of [...LAUNCH_DIRECTORIES, ...listCampaignDirectories()]) {
+        const line = reportDirectory(directory);
+        if (line !== undefined)
+            console.log(line);
+    }
+    const files = reportCampaignFiles();
+    if (files !== undefined)
+        console.log(files);
+    return 0;
+}
+function runSweep(thresholdMinutes) {
+    const now = Date.now();
+    const present = LAUNCH_DIRECTORIES.filter((directory) => existsSync(directory));
+    const files = present.flatMap((directory) => listFiles(directory, NOTHING_SKIPPED));
+    if (files.some((file) => now - file.modified < RECENT_MS)) {
+        console.error('sweep: a launch file changed within the last 2 minutes; refusing to delete');
+        return 2;
+    }
+    const cutoff = now - thresholdMinutes * 60_000;
+    for (const file of files) {
+        if (file.modified > cutoff)
+            continue;
+        rmSync(file.path, { force: true });
+        console.log(`sweep: deleted ${file.path}`);
+    }
+    for (const directory of present)
+        removeEmptyDirectories(directory);
+    return 0;
+}
+function listUnitFiles(unit) {
+    return LAUNCH_DIRECTORIES.filter((directory) => existsSync(directory))
+        .flatMap((directory) => listFiles(directory, NOTHING_SKIPPED))
+        .filter((file) => {
+        const name = basename(file.path);
+        return name.startsWith(unit) && /^[-.]/u.test(name.slice(unit.length));
+    });
+}
+function runUnit(unit, remove) {
+    if (unit === undefined || !/^[A-Za-z0-9._][A-Za-z0-9._-]*$/u.test(unit)) {
+        console.error('usage: sweep.ts --unit UNIT [--delete]');
+        return 64;
+    }
+    const files = listUnitFiles(unit);
+    if (remove && files.some((file) => Date.now() - file.modified < RECENT_MS)) {
+        console.error(`sweep: a file of ${unit} changed within the last 2 minutes; refusing to delete`);
+        return 2;
+    }
+    for (const file of files) {
+        if (remove)
+            rmSync(file.path, { force: true });
+        console.log(`sweep: ${remove ? 'deleted' : 'found'} ${file.path}`);
+    }
+    console.log(`sweep: ${files.length} file(s) for ${unit}`);
+    return 0;
+}
+function main(argv) {
+    if (!existsSync('.git')) {
+        console.error('sweep: run from the repository root');
+        return 64;
+    }
+    const missing = readMissingFlags(argv, ['--unit', '--older-than']);
+    if (missing.length > 0) {
+        console.error(`sweep: ${missing.join(', ')} given with no value`);
+        return 64;
+    }
+    const modes = ['--report', '--tmp', '--unit'].filter((flag) => argv.includes(flag));
+    if (modes.length > 1) {
+        console.error('usage: sweep.ts names one mode: --report | --tmp [--older-than MINUTES] | --unit UNIT [--delete]');
+        return 64;
+    }
+    if (argv.includes('--tmp')) {
+        const threshold = readThreshold(argv);
+        if (threshold === undefined) {
+            console.error('usage: sweep.ts --tmp [--older-than MINUTES]; MINUTES is a positive number');
+            return 64;
+        }
+        return runSweep(threshold);
+    }
+    if (argv.includes('--unit'))
+        return runUnit(readOption(argv, '--unit'), argv.includes('--delete'));
+    if (argv.length === 0 || argv.includes('--report'))
+        return runReport();
+    console.error('usage: sweep.ts --report | --tmp [--older-than MINUTES] | --unit UNIT [--delete]');
+    return 64;
+}
+process.exitCode = main(process.argv.slice(2));