@orkestrel/scaffold 0.0.101 → 0.0.103

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

@@ -32,22 +32,14 @@ function readsAsPath(token) {
     return token.includes('/');
 }
 function extractPaths(content) {
-    const found = new Set();
-    for (const match of content.matchAll(/`([^`\n]+)`/gu)) {
-        const token = (match[1] ?? '').replace(/\\/gu, '/').replace(/:\d+(?:[-–]\d+)?$/u, '');
-        if (readsAsPath(token))
-            found.add(token);
-    }
+    const found = new Set([...content.matchAll(/`([^`\n]+)`/gu)]
+        .map((match) => (match[1] ?? '').replace(/\\/gu, '/').replace(/:\d+(?:[-–]\d+)?$/u, ''))
+        .filter(readsAsPath));
     return [...found].sort();
 }
-function resolveBriefPath(directory, unit) {
-    const base = join(directory, `${unit}-brief.md`);
-    if (!existsSync(base))
-        return base;
-    let n = 2;
-    while (existsSync(join(directory, `${unit}-brief-${n}.md`)))
-        n += 1;
-    return join(directory, `${unit}-brief-${n}.md`);
+function resolveBriefPath(directory, unit, count = 1) {
+    const path = join(directory, count === 1 ? `${unit}-brief.md` : `${unit}-brief-${count}.md`);
+    return existsSync(path) ? resolveBriefPath(directory, unit, count + 1) : path;
 }
 function writeBrief(argv) {
     const unit = readOption(argv, '--unit');

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

@@ -12,14 +12,10 @@ import { basename, relative, resolve } from 'node:path';
 import { listFiles, normalizeSlashes, readMissingFlags, readOption } from "./helpers.js";
 const CITATION = /(?<![\w/\\.-])((?:\.{1,2}[/\\])?\.?[A-Za-z0-9_@][A-Za-z0-9_./\\@-]*\.[a-z]{1,5}):(\d+)(?:[-–](\d+))?(?![\w:])/gu;
 function indexBasenames(root) {
-    const index = new Map();
-    for (const file of listFiles(root)) {
-        const name = basename(file.path);
-        const paths = index.get(name) ?? [];
-        paths.push(normalizeSlashes(relative(root, file.path)));
-        index.set(name, paths);
-    }
-    return index;
+    return new Map([...Map.groupBy(listFiles(root), (file) => basename(file.path))].map(([name, files]) => [
+        name,
+        files.map((file) => normalizeSlashes(relative(root, file.path))),
+    ]));
 }
 function countLines(path) {
     const text = readFileSync(path, 'utf8');
@@ -29,13 +25,21 @@ function countLines(path) {
     // A trailing line break ends the last line rather than opening a phantom one.
     return lines.at(-1) === '' ? lines.length - 1 : lines.length;
 }
-function resolveFile(root, file, index) {
+function resolveDirect(root, file) {
     const direct = resolve(root, normalizeSlashes(file));
-    if (existsSync(direct) && statSync(direct).isFile())
+    return existsSync(direct) && statSync(direct).isFile() ? direct : undefined;
+}
+// A bare filename that no root-relative file matches is the one citation the basename index serves.
+function needsIndex(root, file) {
+    return resolveDirect(root, file) === undefined && !/[/\\]/u.test(file);
+}
+function resolveFile(root, file, index) {
+    const direct = resolveDirect(root, file);
+    if (direct !== undefined)
         return { path: direct, reason: undefined };
     if (/[/\\]/u.test(file))
         return { path: undefined, reason: 'file does not exist' };
-    const candidates = index().get(basename(file)) ?? [];
+    const candidates = index?.get(basename(file)) ?? [];
     const only = candidates.length === 1 ? candidates[0] : undefined;
     if (only !== undefined)
         return { path: resolve(root, only), reason: undefined };
@@ -45,7 +49,6 @@ function resolveFile(root, file, index) {
 }
 function judgeLines(path, line, end, counts) {
     const total = counts.get(path) ?? countLines(path);
-    counts.set(path, total);
     if (line < 1 || line > total)
         return `line ${line} is outside 1-${total}`;
     if (end !== undefined && (end < line || end > total))
@@ -64,24 +67,34 @@ function main(argv) {
         console.error('usage: cite.ts PATH [--root DIR] [--json]');
         return 64;
     }
-    let index;
-    const counts = new Map();
-    const unresolved = [];
-    let citations = 0;
-    for (const match of readFileSync(path, 'utf8').matchAll(CITATION)) {
-        const file = match[1];
-        const line = Number(match[2]);
-        const end = match[3] === undefined ? undefined : Number(match[3]);
-        if (file === undefined)
-            continue;
-        citations += 1;
-        const resolved = resolveFile(root, file, () => (index ??= indexBasenames(root)));
+    const named = [...readFileSync(path, 'utf8').matchAll(CITATION)].flatMap((match) => match[1] === undefined
+        ? []
+        : [
+            {
+                citation: match[0],
+                file: match[1],
+                line: Number(match[2]),
+                end: match[3] === undefined ? undefined : Number(match[3]),
+            },
+        ]);
+    const citations = named.length;
+    // The basename index walks the root, so it is built once and only when a citation needs it.
+    const index = named.some(({ file }) => needsIndex(root, file)) ? indexBasenames(root) : undefined;
+    const resolutions = named.map((entry) => ({
+        entry,
+        resolved: resolveFile(root, entry.file, index),
+    }));
+    // Each resolved file is counted once, however many citations name it.
+    const counts = new Map([...new Set(resolutions.flatMap(({ resolved }) => resolved.path ?? []))].map((file) => [
+        file,
+        countLines(file),
+    ]));
+    const unresolved = resolutions.flatMap(({ entry, resolved }) => {
         const reason = resolved.path === undefined
             ? (resolved.reason ?? 'file does not exist')
-            : judgeLines(resolved.path, line, end, counts);
-        if (reason !== undefined)
-            unresolved.push({ citation: match[0], reason });
-    }
+            : judgeLines(resolved.path, entry.line, entry.end, counts);
+        return reason === undefined ? [] : [{ citation: entry.citation, reason }];
+    });
     if (argv.includes('--json')) {
         console.log(JSON.stringify({ path, root, citations, unresolved }));
     }

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

@@ -45,13 +45,10 @@ export function readMissingFlags(argv, names) {
  * @returns The values in order, empty when the flag never appears.
  */
 export function readOptions(argv, name) {
-    const values = [];
-    argv.forEach((argument, index) => {
+    return argv.flatMap((argument, index) => {
         const value = argv[index + 1];
-        if (argument === name && value !== undefined && !value.startsWith('--'))
-            values.push(value);
+        return argument === name && value !== undefined && !value.startsWith('--') ? [value] : [];
     });
-    return values;
 }
 /**
  * Reads the values that follow a flag up to the next flag.
@@ -64,13 +61,9 @@ export function readList(argv, name) {
     const index = argv.indexOf(name);
     if (index === -1)
         return [];
-    const values = [];
-    for (const argument of argv.slice(index + 1)) {
-        if (argument.startsWith('--'))
-            break;
-        values.push(argument);
-    }
-    return values;
+    const rest = argv.slice(index + 1);
+    const end = rest.findIndex((argument) => argument.startsWith('--'));
+    return end === -1 ? rest : rest.slice(0, end);
 }
 /**
  * Normalizes a host path to forward slashes.

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

@@ -2,7 +2,8 @@
 //   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
+// expires the process tree is killed and the errors file records `capped=true`. A fractional cap
+// truncates to whole milliseconds, with 1 ms the least. --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
@@ -12,11 +13,20 @@
 // 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.
+// journal and errors path that are the same file and a cap that is not a number of seconds from 0
+// to 2147483.
 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";
+// The longest wait a Node timer holds is 2147483647 ms; floored to whole seconds, a longer cap would
+// throw from `AbortSignal.timeout` after the spawn or clamp to 1 ms and kill the command at once.
+const MAX_CAP_SECONDS = 2_147_483;
+// `AbortSignal.timeout` throws on a fractional delay, which `setTimeout` truncates and raises to 1 ms
+// from below, so the cap takes that form before the command starts.
+function computeCapMilliseconds(cap) {
+    return Math.max(1, Math.trunc(cap * 1000));
+}
 function readStatus() {
     const result = spawnSync('git', ['status', '--porcelain'], { encoding: 'utf8' });
     return result.status === 0 ? result.stdout : `git status failed: ${result.stderr}`;
@@ -53,12 +63,14 @@ async function main(argv) {
         journal === errors ||
         !Number.isFinite(cap) ||
         cap < 0 ||
+        cap > MAX_CAP_SECONDS ||
         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)');
+        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 from 0 to ${String(MAX_CAP_SECONDS)} (0 for none)`);
         return 64;
     }
     const status = own.includes('--status');
+    const capMilliseconds = cap > 0 ? computeCapMilliseconds(cap) : undefined;
     mkdirSync(dirname(journal), { recursive: true });
     mkdirSync(dirname(errors), { recursive: true });
     if (status)
@@ -72,17 +84,17 @@ async function main(argv) {
         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;
+    // The signal aborts once the cap elapses, so whether it aborted is whether the cap ended the run.
+    // The timer cannot be cleared, so a cap that elapses after the child exited kills nothing: a
+    // reused pid is not this command's.
+    const deadline = capMilliseconds === undefined ? undefined : AbortSignal.timeout(capMilliseconds);
+    deadline?.addEventListener('abort', () => {
+        if (child.pid !== undefined && child.exitCode === null && child.signalCode === null) {
+            killTree(child.pid);
+        }
+    }, { once: true });
     const exit = await waitForExit(child);
-    if (timer !== undefined)
-        clearTimeout(timer);
+    const capped = deadline?.aborted === true;
     closeSync(journalFd);
     closeSync(errorsFd);
     const durationMs = Date.now() - started;

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

@@ -35,6 +35,23 @@ function waitFor(ms) {
         setTimeout(resolve, ms);
     });
 }
+async function pollLogin(started, capSeconds, url, code) {
+    if (Date.now() - started >= capSeconds * 1000)
+        return { url, code, live: false };
+    await waitFor(POLL_MS);
+    const text = existsSync(JOURNAL) ? readFileSync(JOURNAL, 'utf8') : '';
+    const nextUrl = url ?? text.match(URL_PATTERN)?.[0];
+    if (url === undefined && nextUrl !== undefined)
+        console.error(`login: open ${nextUrl}`);
+    const nextCode = code ?? text.match(CODE_PATTERN)?.[1];
+    if (code === undefined && nextCode !== undefined) {
+        console.error(`login: enter the code ${nextCode}`);
+    }
+    if (readStatus('codex', ['login', 'status']).live) {
+        return { url: nextUrl, code: nextCode, live: true };
+    }
+    return pollLogin(started, capSeconds, nextUrl, nextCode);
+}
 async function loginCodex(capSeconds) {
     const before = readStatus('codex', ['login', 'status']);
     if (before.live) {
@@ -48,31 +65,7 @@ async function loginCodex(capSeconds) {
         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;
-        }
-    }
+    const { url, code, live } = await pollLogin(started, capSeconds);
     if (child.exitCode === null && child.pid !== undefined)
         killTree(child.pid);
     closeSync(journal);

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

@@ -13,19 +13,21 @@ import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'no
 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/)) {
+    return readFileSync(path, 'utf8')
+        .split(/\r\n|\n/)
+        .flatMap((line) => {
         if (line.trim() === '')
-            continue;
+            return [];
         try {
             const parsed = JSON.parse(line);
-            if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-                events.push(Object.fromEntries(Object.entries(parsed)));
-            }
+            return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+                ? [Object.fromEntries(Object.entries(parsed))]
+                : [];
         }
-        catch { }
-    }
-    return events;
+        catch {
+            return [];
+        }
+    });
 }
 function readAnswer(text) {
     return text === undefined || text.trim() === '' ? undefined : text;