reslop 0.2.7 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased][unreleased]
 
+## [0.3.0][] - 2026-10-12
+
+- Execute review results and plan in cli agents
+- Detect available agents and choose its model, effort, context
+- Show agent execution and progress; sessions, history in TUI
+- Import GitHub and GitLab issues into tasks
+- Run tests in the background
+- Codebase refactoring and optimization for simplicity and performance
+- Async repository reads and writes
+- Startup and diff rendering optimizations
+- Rename `.review` to `.plan`
+- Reorganize `.reslop` settings into sections
+- Dashboard and run panel improvements
+- Optional line numbers in diff and file views (ctrl+l)
+
 ## [0.2.7][] - 2026-10-03
 
 - Add tiling view for multi-repository environment
@@ -172,7 +187,8 @@
 - Feedback and todos that produce a repair plan for an agent
 - Intra-line highlighting in unified, mixed, and side-by-side layouts
 
-[unreleased]: https://github.com/tshemsedinov/reslop/compare/v0.2.7...HEAD
+[unreleased]: https://github.com/tshemsedinov/reslop/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/tshemsedinov/reslop/compare/v0.2.7...v0.3.0
 [0.2.7]: https://github.com/tshemsedinov/reslop/compare/v0.2.6...v0.2.7
 [0.2.6]: https://github.com/tshemsedinov/reslop/compare/v0.2.5...v0.2.6
 [0.2.5]: https://github.com/tshemsedinov/reslop/compare/v0.2.4...v0.2.5

package/README.md

@@ -17,20 +17,23 @@ Open a change, leave findings and a backlog, and prepare a repair plan for the a
 Review → Plan → Repair → Verify
 ```
 
-- Live dashboard: files, diffs, tasks, branches, commits, run, and npm, updated in real time
+- Live dashboard: files, diffs, tasks, branches, commits, run, agents, and npm, updated in real time
 - Leave feedback, a project backlog, and in-place code proposals as a repair plan
 - Review uncommitted git diffs, a given commit, a GitHub PR, or a GitLab MR
 - File-scope review mode: not just diffs, with editor mode
 - Stage, unstage, or revert each contiguous block of diff lines
 - Auto-reload local diffs when files change, keeping the current screen
-- Import GitHub PR and GitLab MR review comments into the local plan for AI
-- Commits list: brief and full, view a commit's diff, commit, amend, apply, edit, fixup, and delete
+- Import GitHub PR and GitLab MR review comments, and GitHub/GitLab issues, into tasks and the local plan
+- Commits list: brief and full, view a commit's diff, commit, update, amend, apply, edit, fixup, and delete
 - Branches: checkout, create, rebase, delete, pull, and push
 - npm scripts and bins: run, edit, and reorder; double-click to run; clean logs older than 5 days
 - Reduced test and lint output for agents: failures and a short summary, not passing noise
 - Review, renew, audit and update npm dependencies in `package.json` and the lockfile
 - Auto-update reslop patch and minor releases; confirm a new major
-- Work with git, npm and fetch in background
+- Work with git, npm, and fetch in the background; run tests in the background while you review
+- Execute the plan in local CLI agents: pick agent, model, and effort; watch progress; sessions, history, and continue or new runs
+- Agent defaults and extras in `.reslop` (grouped settings sections)
+- Optional line numbers in diff and file views (`Ctrl+L`)
 
 ## Install
 
@@ -47,9 +50,9 @@ Requires Node.js `>=18.15.0`.
 - `reslop path/file` show only that path or file (starts on the file list)
 - `reslop 7ac260c` show that commit (read-only)
 - `reslop https://github.com/metarhia/metacom/pull/555` GitHub/GitLab PR/MR
-- `reslop -n` start a new review even if the latest is still editing
+- `reslop https://github.com/metarhia/metacom/issues/550` import GitHub/GitLab issue
+- `reslop https://github.com/metarhia/metacom/issues` import all issues
 - `reslop -r` read-only mode
-- `reslop -light` light color theme (default dark)
 - `reslop t -- <program> [args]` run one program and print a reduced report
 
 Prefix each program in an npm script with `reslop t --`. Keep `&&` between those wraps, so each program is captured on its own and a failing step does not start the next one:
@@ -59,29 +62,28 @@ Prefix each program in an npm script with `reslop t --`. Keep `&&` between those
 "test": "reslop t -- npm run -s lint && reslop t -- node --test"
 ```
 
-The report is Markdown: failures, diagnostics, and a short summary. Passing results are omitted and similar problems are grouped. The reduced report and the raw output are both saved under `.log/`. The report names the raw file for an agent to read when a detail is missing. Set `RESLOP_OUTPUT=raw` to pass the command through unchanged. The review screen runs scripts in raw mode and applies its own filter once.
+The report is Markdown: failures, diagnostics, and a short summary. Passing results are omitted and similar problems are grouped. The reduced report is saved as `.log/<name>.log` and the raw output as `.log/<name>.raw`. The report names the raw file for an agent to read when a detail is missing. Set `RESLOP_OUTPUT=raw` to pass the command through unchanged. The review screen runs scripts in raw mode and applies its own filter once.
 
 Run the full check with `npm t`. Run one or more test files with `reslop t -- node --test <files>`. New reviews include those two commands in the agent instructions.
 
-`reslop t` records each run in `.log/.runs/` so that the dashboard can show commands started by an agent in another terminal.
+`reslop t` records each run as `.log/<name>.json` beside those files so that the dashboard can show commands started by an agent in another terminal.
 
-Reviews go in `.review/YYYY-MM-DD-NN.md` with frontmatter `status`:
+Reviews go in `.plan/YYYY-MM-DD-NN.md` with frontmatter `status`:
 
-- `editing`: still writing the review in reslop
-- `ready`: ready for AI to work through the checkboxes
+- `editing`: writing the review in reslop; AI works through the checkboxes
 - `partial`: AI started; some items remain
-- `done`: all items marked `[x]`
+- `done`: all items marked `[x]`; adding an issue in reslop sets it back to `editing`
+
+`ready` and `pending` in older reviews are read as `editing`.
 
 ## Future
 
-- Import issues from GitHub and GitLab
 - Search, blame, and file history in the review
 - Security and code-quality audit; propose a repair plan
 - Send anonymized code blocks for expert review
 - Send questions and the repair plan to experts for approval
 - Ask experts
 - Apply refactoring skills
-- Call agents, harnesses, and IDEs to execute prepared plans
 - Squash, cherry-pick, and interactive rebase
 - Merge, rename, and conflict resolution
 

package/bin/reslop.js

@@ -1,13 +1,11 @@
 #!/usr/bin/env node
 'use strict';
 
-const cli = require('../lib/cli.js');
-const { run, errorMessage } = cli;
-const session = require('../lib/session.js');
-const { LEAVE_TERM } = session;
+const { errorMessage } = require('../lib/common/utilities.js');
 
 const fail = (reason) => {
   try {
+    const { LEAVE_TERM } = require('../lib/session/terminal.js');
     process.stdout.write(LEAVE_TERM);
   } catch {
     // ignore
@@ -19,4 +17,9 @@ const fail = (reason) => {
 process.on('uncaughtException', fail);
 process.on('unhandledRejection', fail);
 
-run(process).then((code) => process.exit(code), fail);
+const start = () => {
+  if (process.argv[2] !== 't') return require('../lib/cli.js').run(process);
+  return require('../lib/report/run.js').runCapture(process, {});
+};
+
+start().then((code) => process.exit(code), fail);

package/lib/agents/agents.js

@@ -0,0 +1,504 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { jsonParse } = require('metautil');
+const { IS_WIN, runProc, spawnBase } = require('../common/process.js');
+const { trimText } = require('../common/utilities.js');
+const { commandEnv, PipeProcess } = require('../runs/process.js');
+const { ensurePlanAllows, PLAN_ALLOWS } = require('./allow.js');
+const models = require('./models.js');
+const { parseNameList, parseCursorModels, parseCursorWide } = models;
+const { parseJsonModels, catalogOf, emptyChoice, contextMenu } = models;
+const { parseJsonEfforts, parseHelpModels, optionValues } = models;
+
+const LIST_MS = 5000;
+const AUTH_NEED = /authentication required/i;
+const PERMISSION_FAIL =
+  /permissions?[ -]?(?:denied|denial)|denied permissions?/i;
+
+const plainEffort = (level) => level;
+const codexEffort = (level) => `model_reasoning_effort=${level}`;
+
+const bashAllow = (entry) => {
+  if (!entry.startsWith('Shell(') || !entry.endsWith(')')) return '';
+  const bin = entry.slice('Shell('.length, -1).split(/\s+/)[0];
+  if (!bin) return '';
+  return `Bash(${bin} *)`;
+};
+
+const BASH_ALLOWS = [...new Set(PLAN_ALLOWS.map(bashAllow).filter(Boolean))];
+
+// A piped session has no approval host. Preapproved shells can still run tests.
+const CLAUDE_PREFIX = [
+  '--print',
+  '--permission-mode',
+  'acceptEdits',
+  '--permission-prompts',
+  'none',
+  '--allowedTools',
+  ...BASH_ALLOWS,
+];
+
+const defineAgent = (spec) => ({
+  id: spec.id,
+  name: spec.name ?? spec.id,
+  title: spec.title,
+  bins: spec.bins,
+  models: spec.models,
+  modelFlag: spec.modelFlag ?? '--model',
+  effortFlag: spec.effortFlag ?? '',
+  effortValue: spec.effortValue ?? plainEffort,
+  efforts: spec.efforts ?? [],
+  modelParams: spec.modelParams === true,
+  prefix: spec.prefix ?? [],
+  promptFlag: spec.promptFlag ?? '',
+  login: spec.login ?? [],
+  status: spec.status ?? [],
+  contexts: spec.contexts ?? [],
+  resumeWith: spec.resumeWith ?? null,
+  listCmds: spec.listCmds,
+  parseModels: spec.parseModels ?? parseNameList,
+  wideModels: spec.wideModels ?? null,
+  partialList: spec.partialList === true,
+  modelEfforts: spec.modelEfforts ?? null,
+  effortCmds: spec.effortCmds ?? [],
+  allowlist: spec.allowlist === true,
+  denied: spec.denied ?? null,
+  savesExtra: spec.savesExtra === true,
+});
+
+const AGENTS = [
+  defineAgent({
+    id: 'claude',
+    title: 'Claude Code',
+    bins: ['claude'],
+    models: ['default', 'sonnet', 'opus', 'haiku', 'fable'],
+    effortFlag: '--effort',
+    efforts: ['default', 'low', 'medium', 'high', 'max'],
+    prefix: CLAUDE_PREFIX,
+    resumeWith: (id) => ['--resume', id],
+    // No command lists models: the help names the aliases and the efforts
+    listCmds: [['--help']],
+    parseModels: parseHelpModels,
+    partialList: true,
+    effortCmds: [['--help']],
+  }),
+  defineAgent({
+    id: 'opencode',
+    title: 'OpenCode',
+    bins: ['opencode'],
+    models: ['default', 'sonnet', 'opus', 'gpt-5'],
+    resumeWith: (id) => ['--session', id],
+    listCmds: [['models']],
+  }),
+  defineAgent({
+    id: 'cursor',
+    title: 'Cursor',
+    bins: ['cursor-agent', 'agent'],
+    models: ['default', 'auto', 'grok-4.6', 'composer-2', 'gpt-5', 'sonnet'],
+    modelParams: true,
+    efforts: ['default', 'low', 'medium', 'high', 'xhigh'],
+    prefix: ['--print', '--trust'],
+    allowlist: true,
+    login: ['login'],
+    status: ['status', '--format', 'json'],
+    contexts: ['256k', '1m'],
+    resumeWith: (id) => [`--resume=${id}`],
+    listCmds: [['--list-models'], ['models']],
+    parseModels: parseCursorModels,
+    wideModels: parseCursorWide,
+  }),
+  defineAgent({
+    id: 'codex',
+    title: 'Codex',
+    bins: ['codex'],
+    models: ['default', 'gpt-5.1-codex', 'gpt-5', 'o3'],
+    effortFlag: '-c',
+    effortValue: codexEffort,
+    efforts: ['default', 'low', 'medium', 'high', 'xhigh'],
+    // The TUI rejects a closed stdin; exec is the non-interactive entry
+    prefix: ['exec'],
+    resumeWith: (id) => ['resume', id],
+    listCmds: [
+      ['debug', 'models', '--bundled'],
+      ['debug', 'models'],
+      ['models'],
+    ],
+    parseModels: parseJsonModels,
+    modelEfforts: parseJsonEfforts,
+  }),
+  defineAgent({
+    id: 'agy',
+    title: 'Antigravity',
+    bins: ['agy'],
+    models: [
+      'default',
+      'gemini-3.8-flash-high',
+      'gemini-3.8-flash-medium',
+      'gemini-3.8-flash-low',
+      'gemini-3.7-flash-high',
+      'gemini-3.7-flash-medium',
+      'gemini-3.7-flash-low',
+      'gemini-3.6-flash-high',
+      'gemini-3.6-flash-medium',
+      'gemini-3.6-flash-low',
+      'gemini-3.1-pro-high',
+      'gemini-3.1-pro-low',
+      'claude-sonnet-4-6',
+      'claude-opus-4-6-thinking',
+      'gpt-oss-120b-medium',
+    ],
+    effortFlag: '--effort',
+    efforts: ['default', 'low', 'medium', 'high'],
+    promptFlag: '-p',
+    // Exits 0 after a refused tool call, so the output tells the outcome
+    denied: PERMISSION_FAIL,
+    // Extra flags in .reslop are the opt-in to run without confirmations
+    savesExtra: true,
+    resumeWith: (id) => ['--conversation', id],
+    listCmds: [['models']],
+    effortCmds: [['--help']],
+  }),
+];
+
+const agentSpec = (id) => AGENTS.find((spec) => spec.id === id) ?? null;
+
+const pathDirs = (env) => {
+  const raw = env.PATH ?? env.Path ?? '';
+  return raw.split(path.delimiter).filter(Boolean);
+};
+
+const winNames = (name, env) => {
+  const ext = env.PATHEXT || '.EXE;.CMD;.BAT;.COM';
+  const upper = name.toUpperCase();
+  const names = [name];
+  for (const item of ext.split(';').filter(Boolean)) {
+    const suffix = item.startsWith('.') ? item : `.${item}`;
+    if (upper.endsWith(suffix.toUpperCase())) return [name];
+    names.push(`${name}${suffix}`);
+  }
+  return names;
+};
+
+const binNames = (name, env) => (IS_WIN ? winNames(name, env) : [name]);
+
+const isBin = (file) => {
+  try {
+    if (!fs.statSync(file).isFile()) return false;
+    if (!IS_WIN) fs.accessSync(file, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const findBin = (name, env = process.env) => {
+  for (const dir of pathDirs(env)) {
+    for (const file of binNames(name, env)) {
+      const full = path.join(dir, file);
+      if (isBin(full)) return full;
+    }
+  }
+  return '';
+};
+
+const findAgentBin = (spec, env) => {
+  for (const name of spec.bins) {
+    const found = findBin(name, env);
+    if (found) return found;
+  }
+  return '';
+};
+
+const detectAgents = (env = process.env) =>
+  AGENTS.map((spec) => ({
+    id: spec.id,
+    name: spec.name,
+    spec,
+    models: spec.models.slice(),
+    wide: null,
+    listedEfforts: null,
+    modelEfforts: null,
+    bin: findAgentBin(spec, env),
+  }));
+
+const canLogin = (row) =>
+  Boolean(row && row.bin && row.spec && row.spec.login.length);
+
+const tryList = async (run, bin, args, options) => {
+  try {
+    return await run(bin, args, options);
+  } catch {
+    return null;
+  }
+};
+
+const listedOf = (listed) => {
+  const bare = Array.isArray(listed);
+  const given = bare ? { names: listed, wide: listed.wide } : listed;
+  const from = given && typeof given === 'object' ? given : {};
+  const efforts = Array.isArray(from.efforts) ? from.efforts : [];
+  const perModel = from.modelEfforts instanceof Map ? from.modelEfforts : null;
+  return {
+    names: Array.isArray(from.names) ? from.names : [],
+    wide: Array.isArray(from.wide) ? from.wide : null,
+    efforts: efforts.length ? efforts : null,
+    modelEfforts: perModel && perModel.size ? perModel : null,
+  };
+};
+
+// One answer per command line, so a command that serves two lists runs once
+class CliProbe {
+  constructor(bin, options) {
+    this.bin = bin;
+    this.run = options.run ?? runProc;
+    this.env = { ...process.env, ...options.env };
+    this.timeout = options.timeout ?? LIST_MS;
+    this.texts = new Map();
+  }
+
+  async read(args) {
+    const key = args.join(' ');
+    if (this.texts.has(key)) return this.texts.get(key);
+    const { env, timeout } = this;
+    const result = await tryList(this.run, this.bin, args, { env, timeout });
+    const { stdout = '', stderr = '' } = result ?? {};
+    const text = result ? `${stdout}\n${stderr}` : '';
+    this.texts.set(key, text);
+    return text;
+  }
+
+  async first(cmds, parse) {
+    for (const args of cmds) {
+      const text = await this.read(args);
+      const found = text ? parse(text) : [];
+      if (found.length) return { text, found };
+    }
+    return null;
+  }
+}
+
+const listModels = async (bin, spec, options = {}) => {
+  const listed = { names: [], wide: null, efforts: null, modelEfforts: null };
+  if (!bin || !spec) return listed;
+  const probe = new CliProbe(bin, options);
+  const models = await probe.first(spec.listCmds, spec.parseModels);
+  if (models) {
+    const { text } = models;
+    listed.names = models.found;
+    listed.wide = spec.wideModels ? spec.wideModels(text) : null;
+    listed.modelEfforts = spec.modelEfforts ? spec.modelEfforts(text) : null;
+  }
+  const levels = (text) => optionValues(text, spec.effortFlag);
+  const efforts = await probe.first(spec.effortCmds, levels);
+  if (efforts) listed.efforts = efforts.found;
+  return listed;
+};
+
+const splitArgs = (text) => trimText(text).split(/\s+/).filter(Boolean);
+
+const quoteArg = (text) => {
+  const arg = `${text ?? ''}`;
+  if (!arg) return '""';
+  if (!/[\s"'\\]/.test(arg)) return arg;
+  return `"${arg.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+};
+
+const commandLine = (launch) => {
+  if (!launch || !launch.ok || !launch.cmd) return '';
+  const args = launch.args ?? [];
+  const hasPrompt = launch.prompt && args.at(-1) === launch.prompt;
+  const shown = hasPrompt ? args.slice(0, -1) : args;
+  const plan = launch.plan ? quoteArg(launch.plan) : '';
+  const bin = path.basename(launch.cmd);
+  return [bin, ...shown.map(quoteArg), plan].filter(Boolean).join(' ');
+};
+
+const planRef = (reviewPath, cwd) => {
+  const file = `${reviewPath ?? ''}`;
+  if (!file || !cwd) return file;
+  const rel = path.relative(cwd, file);
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return file;
+  return rel.split(path.sep).join('/');
+};
+
+const planPrompt = (reviewPath) =>
+  `Read and execute repair plan at ${reviewPath}`;
+
+const needsAuth = (text) => AUTH_NEED.test(`${text ?? ''}`);
+
+const parsedAuth = (raw) => {
+  const start = raw.indexOf('{');
+  const end = raw.lastIndexOf('}');
+  if (start < 0 || end <= start) return null;
+  const body = raw.slice(start, end + 1);
+  const data = jsonParse(body);
+  if (!data || typeof data !== 'object') return null;
+  if (typeof data.isAuthenticated === 'boolean') return data.isAuthenticated;
+  if (data.status === 'authenticated') return true;
+  if (data.status === 'unauthenticated') return false;
+  if (data.status === 'partially-authenticated') return false;
+  return null;
+};
+
+const authState = (text) => {
+  const raw = trimText(text);
+  if (!raw) return null;
+  const parsed = parsedAuth(raw);
+  if (parsed !== null) return parsed;
+  if (/not logged in/i.test(raw)) return false;
+  if (/logged in/i.test(raw)) return true;
+  return null;
+};
+
+const probeAuth = async (row) => {
+  const args = row && row.spec ? row.spec.status : [];
+  if (!row || !row.bin || !args.length) return null;
+  const result = await runProc(row.bin, args, {
+    env: commandEnv(),
+    timeout: LIST_MS,
+  });
+  if (!result || result.error) return null;
+  const text = `${result.stdout ?? ''}\n${result.stderr ?? ''}`;
+  return authState(text);
+};
+
+const effortArgs = (spec, effort) => {
+  const level = trimText(effort);
+  if (!spec.effortFlag || !level || level === 'default') return [];
+  return [spec.effortFlag, spec.effortValue(level)];
+};
+
+const paramPart = (key, value) => {
+  const text = trimText(value);
+  if (!text) return '';
+  return `${key}=${text}`;
+};
+
+const withParams = (model, parts) => {
+  const body = parts.filter(Boolean).join(',');
+  if (!body || !model || model === 'default') return model;
+  return `${model}[${body}]`;
+};
+
+const effortParam = (model, effort) => {
+  const level = trimText(effort);
+  if (!level || level === 'default') return '';
+  if (`${model ?? ''}`.endsWith(`-${level}`)) return '';
+  return level;
+};
+
+const fastParam = (model, fast) => {
+  if (fast !== true) return '';
+  if (`${model ?? ''}`.endsWith('-fast')) return '';
+  return 'true';
+};
+
+const modelArg = (spec, resolved, context, fast) => {
+  const parts = [paramPart('context', context)];
+  const plain = spec.modelParams && !resolved.encoded;
+  if (!plain) return withParams(resolved.model, parts);
+  const level = effortParam(resolved.model, resolved.effort);
+  parts.push(paramPart('effort', level));
+  parts.push(paramPart('fast', fastParam(resolved.model, fast)));
+  return withParams(resolved.model, parts);
+};
+
+const createLaunch = (row, kind, args, plan = '', prompt = '') => {
+  const launch = {
+    ok: true,
+    cmd: row.bin,
+    args,
+    prompt,
+    plan,
+    id: row.id,
+    name: row.name,
+    kind,
+    command: '',
+  };
+  launch.command = commandLine(launch);
+  return launch;
+};
+
+const resumeArgs = (spec, sessionId) => {
+  const id = `${sessionId ?? ''}`;
+  if (!id || !spec.resumeWith) return [];
+  return spec.resumeWith(id);
+};
+
+const buildLaunch = (row, choice, reviewPath, cwd, sessionId = '') => {
+  if (!row || !row.bin) return { ok: false, error: 'not installed' };
+  if (!reviewPath) return { ok: false, error: 'no plan' };
+  const { spec } = row;
+  const picked = choice ?? emptyChoice(row);
+  const catalog = catalogOf(row.models);
+  const resolved = catalog.withFast(catalog.resolve(picked), picked.fast);
+  const asked = trimText(picked.context);
+  const menu = contextMenu(resolved.model, row.wide, catalog, spec.contexts);
+  const pass = menu.includes(asked) && asked !== menu[0] ? asked : '';
+  const model = modelArg(spec, resolved, pass, picked.fast);
+  const plan = planRef(reviewPath, cwd) || reviewPath;
+  const prompt = planPrompt(plan);
+  const continued = resumeArgs(spec, sessionId);
+  const args = [...spec.prefix, ...continued];
+  if (model && model !== 'default') args.push(spec.modelFlag, model);
+  if (!spec.modelParams && !resolved.encoded) {
+    args.push(...effortArgs(spec, resolved.effort));
+  }
+  args.push(...splitArgs(picked.extra));
+  if (spec.promptFlag) args.push(spec.promptFlag);
+  args.push(prompt);
+  const launch = createLaunch(row, 'run', args, plan, prompt);
+  const id = `${sessionId ?? ''}`;
+  if (id) launch.session = id;
+  return launch;
+};
+
+const buildLogin = (row) => {
+  if (!row || !row.bin) return { ok: false, error: 'not installed' };
+  if (!canLogin(row)) return { ok: false, error: 'no login' };
+  return createLaunch(row, 'login', row.spec.login.slice());
+};
+
+// The review screen forces raw output. An agent needs the reduced test report.
+const agentEnv = () => {
+  const env = commandEnv();
+  delete env.RESLOP_OUTPUT;
+  return env;
+};
+
+const startPipe = (cwd, launch, onData, onClose) => {
+  const options = spawnBase({ cwd, env: agentEnv(), detached: !IS_WIN });
+  const proc = new PipeProcess(onData, onClose);
+  proc.start(launch.cmd, launch.args, options).closeInput();
+  return proc;
+};
+
+// An agent that reads an allow list gets the plan entries before it runs
+const startAgent = (cwd, launch, onData, onClose) => {
+  const spec = agentSpec(launch.id);
+  const listed = launch.kind === 'run' && spec && spec.allowlist;
+  if (listed) ensurePlanAllows();
+  return startPipe(cwd, launch, onData, onClose);
+};
+
+module.exports = {
+  ...models,
+  AGENTS,
+  agentSpec,
+  findBin,
+  detectAgents,
+  canLogin,
+  listedOf,
+  listModels,
+  splitArgs,
+  planPrompt,
+  needsAuth,
+  authState,
+  probeAuth,
+  commandLine,
+  buildLaunch,
+  buildLogin,
+  startAgent,
+};