@delegoapp/runner 0.1.0

package/README.md

@@ -0,0 +1,47 @@
+# @delegoapp/runner
+
+Local runner for [Delego](https://delegoapp.com). Polls the Delego relay, claims Linear-delegated jobs, and executes them through Codex CLI or Claude Code on your machine.
+
+## Install + pair (first time)
+
+1. In the Delego dashboard, go to **Runners → Pair a runner**. Enter a name, pick which executors this machine can run, and click "Generate command". Copy the command shown.
+2. Run that command on the machine where the runner will live. The first run consumes the pairing token and saves a long-lived bearer to `${XDG_CONFIG_HOME ?? ~/.config}/delego-runner/credentials.json` (mode `0600`).
+3. Subsequent runs need only the relay URL — the bearer is loaded automatically:
+
+   ```bash
+   npx -y @delegoapp/runner --relay-url https://your-dashboard.example
+   ```
+
+The process polls the relay continuously. Pass `--once` to run a single iteration and exit.
+
+## Configuration
+
+All flags also accept the matching `DELEGO_*` environment variable.
+
+| Flag | Env var | Default | Purpose |
+|------|---------|---------|---------|
+| `--relay-url` | `DELEGO_RELAY_URL` | (required) | Relay base URL |
+| `--pairing-token` | `DELEGO_PAIRING_TOKEN` | — | Single-use bearer, first run only (`drs_pair_*`) |
+| `--profile` | `DELEGO_PROFILE` | `default` | Credentials profile name |
+| `--workspace-root` | `DELEGO_WORKSPACE_ROOT` | `process.cwd()` | Where to clone/worktree repos |
+| `--git-clone-base-url` | `DELEGO_GIT_CLONE_BASE_URL` | `git@github.com:` | Base for `git clone` |
+| `--codex-command` | `DELEGO_CODEX_COMMAND` | `codex` | Codex CLI executable |
+| `--codex-args` | `DELEGO_CODEX_ARGS` | `exec --sandbox workspace-write` | Codex args before prompt |
+| `--claude-command` | `DELEGO_CLAUDE_COMMAND` | `claude` | Claude CLI executable |
+| `--claude-args` | `DELEGO_CLAUDE_ARGS` | `--print --verbose --output-format stream-json --dangerously-skip-permissions` | Claude args |
+| `--supported-executors` | `DELEGO_SUPPORTED_EXECUTORS` | `codex,claude` | Comma-separated executors this runner advertises |
+| `--executor-timeout-ms` | `DELEGO_EXECUTOR_TIMEOUT_MS` | `1800000` | Max executor runtime (ms) |
+| `--no-commit` | `DELEGO_CREATE_COMMIT=false` | (create commit by default) | Disable local commit creation |
+
+## Requirements
+
+- Node ≥ 20
+- `git` on `PATH`
+- `gh` on `PATH` (only if publishing a PR is enabled for the job)
+- `codex` or `claude` (or both) on `PATH` — at least one must match `--supported-executors`
+
+## Credentials
+
+Stored at `${XDG_CONFIG_HOME ?? ~/.config}/delego-runner/credentials.json` (mode `0600`). Each profile holds `{ relayUrl, runnerId, bearer, pairedAt }`. Override the path with `DELEGO_CREDENTIALS_PATH`.
+
+To rotate or remove a runner, use the dashboard — local credentials become invalid as soon as the server rotates the bearer.

package/dist/bin.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { run } from './run.js';
+run().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
+});

package/dist/config.js

@@ -0,0 +1,159 @@
+import { ADAPTERS, ADAPTERS_BY_ID, SUPPORTED_EXECUTOR_IDS, } from './executor/adapters/index.js';
+import { createRequire } from 'node:module';
+import { resolve } from 'node:path';
+const defaultHeartbeatIntervalMs = 10_000;
+const defaultPollIntervalMs = 10_000;
+const defaultCancellationPollIntervalMs = 5_000;
+const defaultExecutorTimeoutMs = 30 * 60_000;
+const PROFILE_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+const DEFAULT_PROFILE = 'default';
+const packageJson = createRequire(import.meta.url)('../package.json');
+const runnerVersion = packageJson.version ?? '0.0.0';
+function flagLine(flag, valueLabel, description) {
+    return `  ${`${flag} ${valueLabel}`.padEnd(38, ' ')}${description}`;
+}
+function executorFlagLines() {
+    const lines = [];
+    for (const adapter of ADAPTERS) {
+        lines.push(flagLine(adapter.flag.command, '<command>', `${adapter.displayName} CLI command (default: ${adapter.defaultCommand})`), flagLine(adapter.flag.args, '<args>', `${adapter.displayName} CLI args before the prompt (default: ${adapter.defaultArgs.join(' ')})`));
+    }
+    return lines;
+}
+function executorEnvNames() {
+    const names = [];
+    for (const adapter of ADAPTERS) {
+        names.push(adapter.env.command, adapter.env.args);
+    }
+    return names;
+}
+function usage() {
+    return [
+        'Usage: npx @delegoapp/runner --relay-url <url> [--pairing-token <drs_pair_...>] [--profile <name>]',
+        '',
+        'First run: pass --pairing-token <drs_pair_...> (mint one in the dashboard).',
+        'Subsequent runs: omit --pairing-token; the bearer is loaded from the stored profile.',
+        '',
+        'Pairing / profile:',
+        flagLine('--pairing-token', '<token>', 'Single-use drs_pair_... token; consumed on first run'),
+        flagLine('--profile', '<name>', `Credentials profile to read/write (default: ${DEFAULT_PROFILE}; pattern: ${PROFILE_PATTERN})`),
+        flagLine('--force', '', 'Suppress the warning when overwriting an existing profile'),
+        '',
+        'Real execution options:',
+        flagLine('--workspace-root', '<path>', 'Root containing local owner/repo or repo checkouts'),
+        flagLine('--git-clone-base-url', '<url>', 'Base URL for missing repo clones (default: git@github.com:)'),
+        ...executorFlagLines(),
+        flagLine('--supported-executors', '<list>', `Comma-separated executor capabilities to advertise (default: ${SUPPORTED_EXECUTOR_IDS.join(',')})`),
+        flagLine('--executor-timeout-ms', '<ms>', 'Maximum executor runtime (default: 1800000)'),
+        flagLine('--no-commit', '', 'Report changed files without creating a local commit'),
+        '',
+        `Environment fallbacks: DELEGO_RELAY_URL, DELEGO_PAIRING_TOKEN, DELEGO_PROFILE, DELEGO_WORKSPACE_ROOT, DELEGO_GIT_CLONE_BASE_URL, ${executorEnvNames().join(', ')}, DELEGO_SUPPORTED_EXECUTORS, DELEGO_CREATE_COMMIT`,
+        `Credentials path override: DELEGO_CREDENTIALS_PATH`,
+    ].join('\n');
+}
+export function validatePublishingPolicy(policy) {
+    if (policy.autoCreatePr && !policy.autoPush) {
+        throw new Error('Invalid publishing policy: autoCreatePr=true requires autoPush=true.');
+    }
+}
+function readArg(args, name) {
+    const index = args.indexOf(name);
+    if (index === -1) {
+        return null;
+    }
+    return args[index + 1] ?? null;
+}
+function readNumberOption(args, env, name, envName, fallback) {
+    const value = readArg(args, name) ?? env[envName];
+    return value ? Number(value) : fallback;
+}
+function splitArgs(value) {
+    if (!value) {
+        return [];
+    }
+    return value
+        .split(/\s+/)
+        .map((part) => part.trim())
+        .filter(Boolean);
+}
+function parseSupportedExecutors(value) {
+    if (!value) {
+        return [...SUPPORTED_EXECUTOR_IDS];
+    }
+    const executors = value
+        .split(',')
+        .map((part) => part.trim().toLowerCase())
+        .filter((part) => part in ADAPTERS_BY_ID);
+    if (executors.length === 0) {
+        throw new Error(`--supported-executors must include at least one of ${SUPPORTED_EXECUTOR_IDS.join(', ')}`);
+    }
+    return Array.from(new Set(executors));
+}
+function readExecutorOptions(args, env) {
+    const entries = ADAPTERS.map((adapter) => {
+        const command = readArg(args, adapter.flag.command) ??
+            env[adapter.env.command] ??
+            adapter.defaultCommand;
+        const argsValue = readArg(args, adapter.flag.args) ??
+            env[adapter.env.args] ??
+            adapter.defaultArgs.join(' ');
+        return [adapter.id, { command, args: splitArgs(argsValue) }];
+    });
+    return Object.fromEntries(entries);
+}
+export function readConfig(args, env = process.env) {
+    const relayUrlRaw = readArg(args, '--relay-url') ?? env.DELEGO_RELAY_URL ?? null;
+    const pairingToken = readArg(args, '--pairing-token') ?? env.DELEGO_PAIRING_TOKEN ?? null;
+    const profileName = readArg(args, '--profile') ?? env.DELEGO_PROFILE ?? DEFAULT_PROFILE;
+    const force = args.includes('--force');
+    if (!PROFILE_PATTERN.test(profileName)) {
+        throw new Error(`--profile must match ${PROFILE_PATTERN} (got ${JSON.stringify(profileName)})`);
+    }
+    if (pairingToken !== null && !pairingToken.startsWith('drs_pair_')) {
+        throw new Error('--pairing-token must start with drs_pair_');
+    }
+    const heartbeatIntervalMs = readNumberOption(args, env, '--heartbeat-interval-ms', 'DELEGO_HEARTBEAT_INTERVAL_MS', defaultHeartbeatIntervalMs);
+    const pollIntervalMs = readNumberOption(args, env, '--poll-interval-ms', 'DELEGO_POLL_INTERVAL_MS', defaultPollIntervalMs);
+    const cancellationPollIntervalMs = readNumberOption(args, env, '--cancellation-poll-interval-ms', 'DELEGO_CANCELLATION_POLL_INTERVAL_MS', defaultCancellationPollIntervalMs);
+    const executorTimeoutMs = readNumberOption(args, env, '--executor-timeout-ms', 'DELEGO_EXECUTOR_TIMEOUT_MS', defaultExecutorTimeoutMs);
+    const workspaceRoot = readArg(args, '--workspace-root') ??
+        env.DELEGO_WORKSPACE_ROOT ??
+        process.cwd();
+    const gitCloneBaseUrl = (readArg(args, '--git-clone-base-url') ??
+        env.DELEGO_GIT_CLONE_BASE_URL ??
+        'git@github.com:').replace(/\/+$/, '');
+    const executors = readExecutorOptions(args, env);
+    const createCommit = !args.includes('--no-commit') && env.DELEGO_CREATE_COMMIT !== 'false';
+    const mockExecuteOnce = args.includes('--mock-execute-once');
+    const supportedExecutors = parseSupportedExecutors(readArg(args, '--supported-executors') ?? env.DELEGO_SUPPORTED_EXECUTORS);
+    for (const [name, value, minimum] of [
+        ['--heartbeat-interval-ms', heartbeatIntervalMs, 1_000],
+        ['--poll-interval-ms', pollIntervalMs, 1_000],
+        ['--cancellation-poll-interval-ms', cancellationPollIntervalMs, 1_000],
+        ['--executor-timeout-ms', executorTimeoutMs, 1_000],
+    ]) {
+        if (!Number.isFinite(value) || value < minimum) {
+            throw new Error(`${name} must be at least ${minimum}`);
+        }
+    }
+    return {
+        relayUrl: relayUrlRaw ? relayUrlRaw.replace(/\/+$/, '') : null,
+        pairingToken,
+        profileName,
+        force,
+        once: args.includes('--once'),
+        mockExecuteOnce,
+        heartbeatIntervalMs,
+        pollIntervalMs,
+        cancellationPollIntervalMs,
+        workspaceRoot: resolve(workspaceRoot),
+        gitCloneBaseUrl,
+        executors,
+        executorTimeoutMs,
+        createCommit,
+        version: runnerVersion,
+        supportedExecutors,
+    };
+}
+export function usageMessage() {
+    return usage();
+}

package/dist/credentials-store.js

@@ -0,0 +1,76 @@
+import { chmodSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+const EMPTY_STORE = { version: 1, profiles: {} };
+export function resolveCredentialsPath(env) {
+    if (env.DELEGO_CREDENTIALS_PATH) {
+        return env.DELEGO_CREDENTIALS_PATH;
+    }
+    const base = env.XDG_CONFIG_HOME ?? join(env.HOME ?? homedir(), '.config');
+    return join(base, 'delego-runner', 'credentials.json');
+}
+export function readStore(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { version: 1, profiles: {} };
+        }
+        throw error;
+    }
+    try {
+        const stat = statSync(path);
+        if ((stat.mode & 0o077) !== 0) {
+            console.warn(`delego-runner: credentials file ${path} has permissions ${(stat.mode & 0o777).toString(8)}; ` +
+                `recommended is 0600. Restrict access with: chmod 600 ${path}`);
+        }
+    }
+    catch {
+        // stat failure on a file we just read is unlikely; ignore.
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`delego-runner: credentials file ${path} is not valid JSON: ${error.message}`);
+    }
+    if (!parsed ||
+        typeof parsed !== 'object' ||
+        parsed.version !== 1) {
+        throw new Error(`delego-runner: credentials file ${path} has unexpected shape (expected version: 1)`);
+    }
+    const store = parsed;
+    if (!store.profiles || typeof store.profiles !== 'object') {
+        return { version: 1, profiles: {} };
+    }
+    return store;
+}
+export function writeStore(path, store) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const tempPath = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+    writeFileSync(tempPath, JSON.stringify(store, null, 2), { mode: 0o600 });
+    renameSync(tempPath, path);
+    chmodSync(path, 0o600);
+}
+export function getProfile(store, profileName) {
+    return store.profiles[profileName];
+}
+export function upsertProfile(path, profileName, profile) {
+    const store = readStoreOrEmpty(path);
+    store.profiles[profileName] = profile;
+    writeStore(path, store);
+}
+function readStoreOrEmpty(path) {
+    try {
+        return readStore(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { ...EMPTY_STORE, profiles: {} };
+        }
+        throw error;
+    }
+}

package/dist/execution-prefs.js

@@ -0,0 +1,34 @@
+import { ADAPTERS, ADAPTERS_BY_ID, } from './executor/adapters/index.js';
+import { normalizeThinkingPreference, } from './thinking.js';
+export { promptThinkingInstruction } from './thinking.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stringOrNull(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+function normalizeExecutor(value) {
+    if (typeof value === 'string' && value in ADAPTERS_BY_ID) {
+        return value;
+    }
+    return ADAPTERS[0].id;
+}
+export function normalizeExecutionPreferences(job) {
+    const explicit = isRecord(job.executionPreferences)
+        ? job.executionPreferences
+        : null;
+    const requestPreferences = isRecord(job.requestPayload.executionPreferences)
+        ? job.requestPayload.executionPreferences
+        : null;
+    const nestedPreferences = requestPreferences && isRecord(requestPreferences.preferences)
+        ? requestPreferences.preferences
+        : null;
+    const executorValue = explicit?.executor ?? nestedPreferences?.executor;
+    const modelValue = explicit?.model ?? nestedPreferences?.model;
+    const thinkingValue = explicit?.thinking ?? nestedPreferences?.thinking;
+    return {
+        executor: normalizeExecutor(executorValue),
+        model: stringOrNull(modelValue),
+        thinking: normalizeThinkingPreference(thinkingValue),
+    };
+}

package/dist/executor/adapters/claude.js

@@ -0,0 +1,124 @@
+import { promptForJob } from '../prompt.js';
+const defaultArgs = [
+    '--print',
+    '--verbose',
+    '--output-format',
+    'stream-json',
+    '--dangerously-skip-permissions',
+];
+function summarizeToolInput(name, input) {
+    if (!input || typeof input !== 'object')
+        return '';
+    const record = input;
+    const candidateKeys = [
+        'file_path',
+        'path',
+        'command',
+        'pattern',
+        'url',
+        'description',
+    ];
+    for (const key of candidateKeys) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim()) {
+            const truncated = value.length > 120 ? `${value.slice(0, 117)}…` : value;
+            return ` ${truncated}`;
+        }
+    }
+    if (name === 'TodoWrite' && Array.isArray(record.todos)) {
+        return ` (${record.todos.length} todos)`;
+    }
+    return '';
+}
+function formatAssistantContent(content) {
+    const lines = [];
+    const replyParts = [];
+    let progress = null;
+    for (const block of content) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const entry = block;
+        if (entry.type === 'text' &&
+            typeof entry.text === 'string' &&
+            entry.text.trim()) {
+            lines.push(entry.text);
+            replyParts.push(entry.text);
+            if (!progress)
+                progress = entry.text.split(/\r?\n/)[0]?.trim() ?? null;
+        }
+        else if (entry.type === 'tool_use' && typeof entry.name === 'string') {
+            const detail = summarizeToolInput(entry.name, entry.input);
+            const formatted = `· ${entry.name}${detail}`;
+            lines.push(formatted);
+            if (!progress)
+                progress = `${entry.name}${detail}`;
+        }
+    }
+    return {
+        display: lines.join('\n'),
+        progress,
+        replyText: replyParts.length ? replyParts.join('\n\n') : null,
+    };
+}
+function formatStreamEvent(event) {
+    const type = typeof event.type === 'string' ? event.type : '';
+    if (type === 'system' && event.subtype === 'init') {
+        return { display: null, progress: null };
+    }
+    if (type === 'assistant' &&
+        event.message &&
+        typeof event.message === 'object') {
+        const content = event.message.content;
+        if (Array.isArray(content)) {
+            const { display, progress, replyText } = formatAssistantContent(content);
+            return {
+                display: display.length ? display : null,
+                progress,
+                finalReply: replyText,
+            };
+        }
+    }
+    if (type === 'user') {
+        return { display: null, progress: null };
+    }
+    if (type === 'result') {
+        const subtype = typeof event.subtype === 'string' ? event.subtype : 'completed';
+        const ms = typeof event.duration_ms === 'number' ? event.duration_ms : null;
+        const cost = typeof event.total_cost_usd === 'number' ? event.total_cost_usd : null;
+        const parts = [`claude: ${subtype}`];
+        if (ms !== null)
+            parts.push(`${(ms / 1000).toFixed(1)}s`);
+        if (cost !== null)
+            parts.push(`$${cost.toFixed(4)}`);
+        return { display: parts.join(' · '), progress: null };
+    }
+    return { display: null, progress: null };
+}
+export const claudeAdapter = {
+    id: 'claude',
+    displayName: 'Claude',
+    defaultCommand: 'claude',
+    defaultArgs,
+    flag: { command: '--claude-command', args: '--claude-args' },
+    env: { command: 'DELEGO_CLAUDE_COMMAND', args: 'DELEGO_CLAUDE_ARGS' },
+    buildInvocation({ job, command, args }) {
+        const out = [...args];
+        if (job.executionPreferences.model) {
+            out.push('--model', job.executionPreferences.model);
+        }
+        out.push(promptForJob(job));
+        return { command, args: out, summaryLabel: 'Claude' };
+    },
+    formatStdoutLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return { display: null, progress: null };
+        try {
+            const event = JSON.parse(trimmed);
+            return formatStreamEvent(event);
+        }
+        catch {
+            return { display: line, progress: null };
+        }
+    },
+};

package/dist/executor/adapters/codex.js

@@ -0,0 +1,20 @@
+import { promptForJob } from '../prompt.js';
+export const codexAdapter = {
+    id: 'codex',
+    displayName: 'Codex',
+    defaultCommand: 'codex',
+    defaultArgs: ['exec', '--sandbox', 'workspace-write'],
+    flag: { command: '--codex-command', args: '--codex-args' },
+    env: { command: 'DELEGO_CODEX_COMMAND', args: 'DELEGO_CODEX_ARGS' },
+    buildInvocation({ job, repositoryPath, command, args, }) {
+        const out = [...args];
+        if (job.executionPreferences.model) {
+            out.push('-m', job.executionPreferences.model);
+        }
+        if (job.executionPreferences.thinking) {
+            out.push('--config', `model_reasoning_effort="${job.executionPreferences.thinking}"`);
+        }
+        out.push('--cd', repositoryPath, promptForJob(job));
+        return { command, args: out, summaryLabel: 'Codex' };
+    },
+};

package/dist/executor/adapters/index.js

@@ -0,0 +1,6 @@
+import { claudeAdapter } from './claude.js';
+import { codexAdapter } from './codex.js';
+export const ADAPTERS = [codexAdapter, claudeAdapter];
+export const ADAPTERS_BY_ID = Object.fromEntries(ADAPTERS.map((adapter) => [adapter.id, adapter]));
+export const SUPPORTED_EXECUTOR_IDS = ADAPTERS.map((adapter) => adapter.id);
+export { claudeAdapter, codexAdapter };

package/dist/executor/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/dist/executor/process.js

@@ -0,0 +1,161 @@
+import { appendBoundedOutput } from '../git/command.js';
+import { pollCancellation, reportProgress, } from '../relay-client.js';
+import { ADAPTERS_BY_ID } from './adapters/index.js';
+import { spawn } from 'node:child_process';
+function terminateProcessGroup(child) {
+    if (!child.pid) {
+        return;
+    }
+    try {
+        process.kill(-child.pid, 'SIGTERM');
+    }
+    catch {
+        child.kill('SIGTERM');
+    }
+}
+function forceKillProcessGroup(child) {
+    if (!child.pid) {
+        return;
+    }
+    try {
+        process.kill(-child.pid, 'SIGKILL');
+    }
+    catch {
+        child.kill('SIGKILL');
+    }
+}
+export async function runExecutor(config, job, repositoryPath) {
+    const executorId = job.executionPreferences.executor;
+    const adapter = ADAPTERS_BY_ID[executorId];
+    const options = config.executors[executorId];
+    const invocation = adapter.buildInvocation({
+        job,
+        repositoryPath,
+        command: options.command,
+        args: options.args,
+    });
+    return new Promise((resolveExecutor, reject) => {
+        console.log(`executor: starting ${invocation.command} ${invocation.args.slice(0, -1).join(' ')} for ${job.id}`);
+        const child = spawn(invocation.command, invocation.args, {
+            cwd: repositoryPath,
+            detached: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        let timedOut = false;
+        let cancelled = false;
+        const finish = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            clearInterval(cancellationPoll);
+            resolveExecutor(result);
+        };
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            terminateProcessGroup(child);
+            setTimeout(() => forceKillProcessGroup(child), 5_000).unref();
+        }, config.executorTimeoutMs);
+        const cancellationPoll = setInterval(() => {
+            pollCancellation(config, job)
+                .then((requested) => {
+                if (!requested || settled || cancelled) {
+                    return;
+                }
+                cancelled = true;
+                terminateProcessGroup(child);
+                setTimeout(() => forceKillProcessGroup(child), 5_000).unref();
+            })
+                .catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`cancellation poll failed for ${job.id}: ${message}`);
+            });
+        }, config.cancellationPollIntervalMs);
+        let stdoutLineBuffer = '';
+        let finalReply = null;
+        const sendProgress = (summary) => {
+            void reportProgress(config, job, summary.slice(0, 240), {
+                stream: 'stdout',
+                executor: adapter.id,
+            }).catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`progress report failed for ${job.id}: ${message}`);
+            });
+        };
+        const handleFormattedLine = (line) => {
+            if (!adapter.formatStdoutLine)
+                return;
+            const formatted = adapter.formatStdoutLine(line);
+            if (formatted.display !== null) {
+                process.stdout.write(`${formatted.display}\n`);
+            }
+            if (formatted.progress) {
+                sendProgress(`${invocation.summaryLabel}: ${formatted.progress}`);
+            }
+            if (typeof formatted.finalReply === 'string' &&
+                formatted.finalReply.trim()) {
+                finalReply = formatted.finalReply;
+            }
+        };
+        child.stdout.on('data', (chunk) => {
+            stdout = appendBoundedOutput(stdout, chunk);
+            if (adapter.formatStdoutLine) {
+                stdoutLineBuffer += chunk.toString('utf8');
+                let newlineIndex = stdoutLineBuffer.indexOf('\n');
+                while (newlineIndex !== -1) {
+                    const line = stdoutLineBuffer.slice(0, newlineIndex);
+                    stdoutLineBuffer = stdoutLineBuffer.slice(newlineIndex + 1);
+                    handleFormattedLine(line);
+                    newlineIndex = stdoutLineBuffer.indexOf('\n');
+                }
+                return;
+            }
+            process.stdout.write(chunk);
+            const line = chunk
+                .toString('utf8')
+                .split(/\r?\n/)
+                .find((part) => part.trim().length > 0);
+            if (line) {
+                sendProgress(`${invocation.summaryLabel} output: ${line.trim()}`);
+            }
+        });
+        child.stderr.on('data', (chunk) => {
+            process.stderr.write(chunk);
+            stderr = appendBoundedOutput(stderr, chunk);
+        });
+        child.on('error', (error) => {
+            clearTimeout(timeout);
+            clearInterval(cancellationPoll);
+            reject(error);
+        });
+        child.on('close', (exitCode, signal) => {
+            if (adapter.formatStdoutLine && stdoutLineBuffer.trim()) {
+                handleFormattedLine(stdoutLineBuffer);
+                stdoutLineBuffer = '';
+            }
+            console.log(`executor: exited for ${job.id} with code ${exitCode ?? 'null'} signal ${signal ?? 'none'}`);
+            finish({
+                exitCode,
+                signal,
+                stdout,
+                stderr,
+                timedOut,
+                cancelled,
+                finalReply,
+            });
+        });
+    });
+}
+export function summarizeExecutorFailure(result) {
+    if (result.cancelled) {
+        return 'Executor was cancelled by relay request.';
+    }
+    if (result.timedOut) {
+        return 'Executor timed out and was terminated.';
+    }
+    return `Executor failed with exit code ${result.exitCode ?? 'unknown'}.`;
+}

package/dist/executor/prompt.js

@@ -0,0 +1,21 @@
+import { promptThinkingInstruction } from '../thinking.js';
+export function promptForJob(job) {
+    const thinkingInstruction = promptThinkingInstruction(job.executionPreferences.thinking);
+    return [
+        `Linear issue: ${job.linearIssue.identifier}${job.linearIssue.title ? ` - ${job.linearIssue.title}` : ''}`,
+        job.linearIssue.url ? `URL: ${job.linearIssue.url}` : null,
+        '',
+        `Requested executor: ${job.executionPreferences.executor}`,
+        job.executionPreferences.model
+            ? `Requested model: ${job.executionPreferences.model}`
+            : null,
+        thinkingInstruction,
+        '',
+        job.promptSummary,
+        '',
+        'Prompt context JSON:',
+        JSON.stringify(job.promptContext, null, 2),
+    ]
+        .filter((part) => part !== null)
+        .join('\n');
+}