reslop 0.3.1 → 0.3.3

package/lib/agents/agents.js

@@ -2,164 +2,181 @@
 
 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 { IS_WIN, npmBin, npmOpts, spawnBase } = require('../common/process.js');
 const { commandEnv, PipeProcess } = require('../runs/process.js');
-const { ensurePlanAllows, PLAN_ALLOWS } = require('./allow.js');
+const { trimText } = require('../common/utilities.js');
+const { COMMANDS } = 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 GITDIR_PREFIX = 'gitdir:';
-
-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 { choiceOf } = models;
+const { startRun, probeSession } = require('./run.js');
+const registry = require('./registry.js');
+const { installedRegistryAgent } = registry;
+const { localBin, scriptUrl } = require('./script.js');
+const { resolveGitDirs } = require('../git/dir.js');
+
+const CODEX_SANDBOX = 'sandbox_workspace_write';
+const CODEX_ROOTS = 'writable_roots';
+const AGY_SERVER = IS_WIN ? 'agy_acp_server.exe' : 'agy_acp_server.par';
+const AGY_ARGS = process.platform === 'linux' ? ['--uid='] : [];
+
+const realPath = (file) => {
+  try {
+    return fs.realpathSync.native(file);
+  } catch {
+    return path.resolve(file);
+  }
 };
 
-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,
-];
+// workspace-write remounts .git read-only unless that path is itself writable.
+const gitWriteRoots = (cwd) => {
+  if (!cwd) return [];
+  const dirs = resolveGitDirs(cwd);
+  if (!dirs) return [];
+  const roots = [realPath(dirs.gitDir), realPath(dirs.commonDir)];
+  return [...new Set(roots)];
+};
+
+// The adapter merges this into the session config of codex
+const codexEnv = (cwd, env = process.env) => {
+  const roots = gitWriteRoots(cwd);
+  if (!roots.length || env.CODEX_CONFIG) return {};
+  const config = { [CODEX_SANDBOX]: { [CODEX_ROOTS]: roots } };
+  return { CODEX_CONFIG: JSON.stringify(config) };
+};
 
+const antigravityEnv = (cwd, row) => {
+  if (!row || !row.bin) return {};
+  const name = IS_WIN ? 'localharness_external.exe' : 'localharness_external';
+  const helper = path.join(path.dirname(row.bin), name);
+  return fs.existsSync(helper) ? { ANTIGRAVITY_HARNESS_PATH: helper } : {};
+};
+
+// Each agent is reached through the command that serves ACP on its stdio:
+// its own subcommand, or the adapter that wraps its SDK
 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,
+  commands: spec.commands,
+  package: spec.package ?? '',
+  // The cli of the agent that an adapter starts, as { bin, package }
+  requires: spec.requires ?? null,
+  registry: spec.registry ?? '',
+  // The install scripts of the vendor, as { unix, win } https urls
+  script: spec.script ?? null,
+  installLabel: spec.installLabel ?? '',
+  hint: spec.hint ?? '',
+  // A program of the vendor that does not serve ACP, as { bin, hint }
+  related: spec.related ?? null,
+  mode: spec.mode ?? '',
+  env: spec.env ?? (() => ({})),
 });
 
 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']],
+    commands: [['claude-agent-acp'], ['claude-code-acp']],
+    package: '@agentclientprotocol/claude-agent-acp',
+    // Edits are accepted by the agent, the rest is asked of the run
+    mode: 'acceptEdits',
   }),
   defineAgent({
     id: 'opencode',
     title: 'OpenCode',
-    bins: ['opencode'],
-    models: ['default', 'sonnet', 'opus', 'gpt-5'],
-    resumeWith: (id) => ['--session', id],
-    listCmds: [['models']],
+    commands: [['opencode', 'acp']],
+    package: 'opencode-ai',
   }),
   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,
+    commands: [
+      ['cursor-agent', 'acp'],
+      ['agent', 'acp'],
+    ],
+    hint: 'needs the Cursor CLI from cursor.com/cli',
   }),
   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,
+    commands: [['codex-acp']],
+    package: '@agentclientprotocol/codex-acp',
+    mode: 'workspace-write',
+    env: codexEnv,
   }),
   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',
+    commands: [[AGY_SERVER, ...AGY_ARGS], ['agy-acp']],
+    registry: 'antigravity-acp',
+    installLabel: 'Google Antigravity ACP',
+    hint: 'install Google Antigravity ACP',
+    related: {
+      bin: 'agy',
+      hint: 'agy installed; install Google Antigravity ACP',
+    },
+    env: antigravityEnv,
+  }),
+  defineAgent({
+    id: 'junie',
+    title: 'Junie',
+    commands: [['junie', '--acp=true']],
+    package: '@jetbrains/junie',
+  }),
+  defineAgent({
+    id: 'copilot',
+    title: 'Copilot',
+    commands: [['copilot', '--acp']],
+    package: '@github/copilot',
+  }),
+  defineAgent({
+    id: 'pi',
+    title: 'Pi',
+    commands: [['pi-acp']],
+    package: 'pi-acp',
+    requires: { bin: 'pi', package: '@earendil-works/pi-coding-agent' },
+  }),
+  defineAgent({
+    id: 'kiro',
+    title: 'Kiro',
+    commands: [['kiro-cli', 'acp', '--agent-engine=v3']],
+    script: {
+      unix: 'https://cli.kiro.dev/install',
+      win: 'https://cli.kiro.dev/install.ps1',
+    },
+    installLabel: 'Kiro CLI from cli.kiro.dev',
+    hint: 'install the Kiro CLI from cli.kiro.dev',
+  }),
+  defineAgent({
+    id: 'cline',
+    title: 'Cline',
+    commands: [['cline', '--acp']],
+    package: 'cline',
+  }),
+  // Windsurf's agent is now the Devin CLI of Cognition; the editor has no ACP
+  defineAgent({
+    id: 'devin',
+    title: 'Devin for Windsurf',
+    commands: [['devin', 'acp']],
+    script: {
+      unix: 'https://cli.devin.ai/install.sh',
+      win: 'https://static.devin.ai/cli/setup.ps1',
+    },
+    installLabel: 'Devin CLI from cli.devin.ai',
+    hint: 'install the Devin CLI, the agent of Windsurf',
+    related: {
+      bin: 'windsurf',
+      hint: 'windsurf installed; install the Devin CLI',
+    },
+  }),
+  defineAgent({
+    id: 'kilo',
+    title: 'Kilo Code',
+    commands: [
+      ['kilo', 'acp'],
+      ['kilocode', 'acp'],
     ],
-    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']],
+    package: '@kilocode/cli',
   }),
 ];
 
@@ -194,8 +211,8 @@ const isBin = (file) => {
   }
 };
 
-const findBin = (name, env = process.env) => {
-  for (const dir of pathDirs(env)) {
+const findIn = (dirs, name, env) => {
+  for (const dir of dirs) {
     for (const file of binNames(name, env)) {
       const full = path.join(dir, file);
       if (isBin(full)) return full;
@@ -204,352 +221,178 @@ const findBin = (name, env = process.env) => {
   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 findBin = (name, env = process.env) => findIn(pathDirs(env), name, env);
 
-const tryList = async (run, bin, args, options) => {
-  try {
-    return await run(bin, args, options);
-  } catch {
-    return null;
-  }
+// An install script may put its command in a directory missing from PATH
+const commandDirs = (spec, env) => {
+  const dirs = pathDirs(env);
+  const local = spec.script ? localBin(env) : '';
+  return local && !dirs.includes(local) ? [...dirs, local] : dirs;
 };
 
-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();
+const findCommand = (spec, env) => {
+  const dirs = commandDirs(spec, env);
+  for (const [name, ...args] of spec.commands) {
+    const bin = findIn(dirs, name, env);
+    if (bin) return { bin, args };
   }
-
-  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;
+  if (spec.registry) {
+    const installed = installedRegistryAgent(spec.registry, { env });
+    if (installed) return installed;
   }
+  return { bin: '', args: [] };
+};
 
-  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;
+// npm packages still missing: the adapter and the cli of the agent it starts
+const missingPackages = (spec, env, found) => {
+  const names = [];
+  if (!found.bin && spec.package) names.push(spec.package);
+  const cli = spec.requires;
+  if (cli && !findBin(cli.bin, env)) names.push(cli.package);
+  return names;
 };
 
-const splitArgs = (text) => trimText(text).split(/\s+/).filter(Boolean);
+// What a missing agent takes: npm packages, a registry binary, or a script
+const installHint = (spec, env, packages) => {
+  if (packages.length) return `npm i -g ${packages.join(' ')}`;
+  if (spec.package) return `npm i -g ${spec.package}`;
+  const { related } = spec;
+  if (related && findBin(related.bin, env)) return related.hint;
+  return spec.hint;
+};
 
-const quoteArg = (text) => {
-  const arg = `${text ?? ''}`;
-  if (!arg) return '""';
-  if (!/[\s"'\\]/.test(arg)) return arg;
-  return `"${arg.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+const detectAgent = (spec, env) => {
+  const found = findCommand(spec, env);
+  const packages = missingPackages(spec, env, found);
+  const command = packages.length ? { bin: '', args: [] } : found;
+  return {
+    id: spec.id,
+    name: spec.name,
+    spec,
+    package: packages.join(' ') || spec.package,
+    packages,
+    installable: Boolean(spec.package || spec.registry || spec.script),
+    installLabel: spec.installLabel,
+    hint: installHint(spec, env, packages),
+    catalog: null,
+    ...command,
+  };
 };
 
-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 detectAgents = (env = process.env) =>
+  AGENTS.map((spec) => detectAgent(spec, env));
+
+const listModels = (row, options = {}) => {
+  if (!row || !row.bin) return Promise.resolve(null);
+  return probeSession(row, options);
 };
 
 const planRef = (reviewPath, cwd) => {
   const file = `${reviewPath ?? ''}`;
   if (!file || !cwd) return file;
-  const rel = path.relative(cwd, file);
+  const rel = path.relative(cwd, path.resolve(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;
-};
+// A refusal reads to an agent as a person saying no, and it stops to ask
+const UNATTENDED = [
+  'You are running unattended: nobody can answer questions or approve',
+  'commands. Change files with your edit tools. The shell is limited to',
+  `${COMMANDS.join(', ')} and read-only filters such as cat, grep,`,
+  'head and tail. When a command is refused, do the step another way',
+  'and continue with the plan.',
+].join(' ');
 
-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 statOf = (file) => {
-  try {
-    return fs.statSync(file);
-  } catch {
-    return null;
-  }
-};
-
-const readFirstLine = (file) => {
-  try {
-    return fs.readFileSync(file, 'utf8').split('\n')[0] ?? '';
-  } catch {
-    return '';
-  }
-};
-
-const realPath = (file) => {
-  try {
-    return fs.realpathSync.native(file);
-  } catch {
-    return path.resolve(file);
-  }
-};
-
-const gitDirOf = (dot) => {
-  const line = readFirstLine(dot).trim();
-  if (!line.startsWith(GITDIR_PREFIX)) return '';
-  const raw = line.slice(GITDIR_PREFIX.length).trim();
-  if (!raw) return '';
-  return path.resolve(path.dirname(dot), raw);
-};
-
-const commonGitDir = (gitDir) => {
-  const raw = readFirstLine(path.join(gitDir, 'commondir')).trim();
-  if (!raw) return gitDir;
-  return path.resolve(gitDir, raw);
-};
-
-// workspace-write remounts .git read-only unless that path is itself writable.
-const gitWriteRoots = (cwd) => {
-  if (!cwd) return [];
-  const dot = path.join(path.resolve(cwd), '.git');
-  const stat = statOf(dot);
-  if (!stat) return [];
-  if (stat.isDirectory()) return [realPath(dot)];
-  if (!stat.isFile()) return [];
-  const gitDir = gitDirOf(dot);
-  if (!gitDir) return [];
-  const roots = [realPath(gitDir), realPath(commonGitDir(gitDir))];
-  return [...new Set(roots)];
-};
-
-const tomlQuote = (text) => {
-  const escaped = text.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
-  return `"${escaped}"`;
-};
-
-const codexGitArgs = (cwd) => {
-  const roots = gitWriteRoots(cwd);
-  if (!roots.length) return [];
-  const listed = roots.map(tomlQuote).join(',');
-  const value = `sandbox_workspace_write.writable_roots=[${listed}]`;
-  return ['--sandbox', 'workspace-write', '-c', value];
-};
-
-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 planPrompt = (reviewPath) =>
+  `Read and execute repair plan at ${reviewPath}\n\n${UNATTENDED}`;
 
-const modelArg = (spec, resolved, context, fast) => {
-  const parts = [paramPart('context', context)];
-  const brackets = spec.modelParams && !resolved.encoded;
-  if (!brackets || resolved.params === false) {
-    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);
+// What a run is shown as: the settings it was started with and its plan
+const launchLabel = (launch) => {
+  const { choice } = launch;
+  const fast = choice.fast ? 'fast' : '';
+  const parts = [launch.name, choice.model, choice.effort, fast];
+  return [...parts, choice.context, launch.plan].filter(Boolean).join(' ');
 };
 
-const createLaunch = (row, kind, args, plan = '', prompt = '') => {
+const buildLaunch = (row, picked, reviewPath, cwd, sessionId = '') => {
+  if (!row || !row.bin) return { ok: false, error: 'not installed' };
+  if (!reviewPath) return { ok: false, error: 'no plan' };
+  const plan = planRef(reviewPath, cwd) || reviewPath;
   const launch = {
     ok: true,
-    cmd: row.bin,
-    args,
-    prompt,
-    plan,
     id: row.id,
     name: row.name,
-    kind,
+    kind: 'run',
+    cmd: row.bin,
+    args: (row.args ?? []).slice(),
+    mode: row.spec.mode,
+    env: row.spec.env(cwd, row),
+    choice: choiceOf(picked),
+    plan,
+    prompt: planPrompt(plan),
+    session: trimText(sessionId),
     command: '',
   };
-  launch.command = commandLine(launch);
+  launch.command = launchLabel(launch);
   return launch;
 };
 
-const resumeArgs = (spec, sessionId) => {
-  const id = `${sessionId ?? ''}`;
-  if (!id || !spec.resumeWith) return [];
-  return spec.resumeWith(id);
-};
+// A helper of reslop downloads a registry binary or runs a vendor script
+const helperInstall = (row, installer, file, arg) => ({
+  installer,
+  cmd: process.execPath,
+  args: [path.join(__dirname, file), arg],
+  command: `install ${row.spec.installLabel || row.name}`,
+});
 
-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' };
+// The package lands in the global prefix of npm, where PATH finds its command
+const installCommand = (row) => {
   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));
+  if (spec.registry) {
+    return helperInstall(row, 'registry', 'registry.js', spec.registry);
   }
-  if (spec.id === 'codex') args.push(...codexGitArgs(cwd));
-  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;
+  if (spec.script) {
+    const url = scriptUrl(spec.script);
+    return helperInstall(row, 'script', 'script.js', url);
+  }
+  const names = row.packages ?? [spec.package].filter(Boolean);
+  if (!names.length) return null;
+  const args = ['install', '--global', ...names];
+  const command = `npm ${args.join(' ')}`;
+  return { installer: 'npm', cmd: npmBin(), args, command };
+};
+
+const buildInstall = (row) => {
+  if (!row) return { ok: false, error: 'no agent' };
+  if (row.bin) return { ok: false, error: 'installed' };
+  const install = installCommand(row);
+  if (!install) return { ok: false, error: row.hint || 'no installer' };
+  return {
+    ok: true,
+    id: row.id,
+    name: row.name,
+    kind: 'install',
+    ...install,
+    plan: '',
+    session: '',
+  };
 };
 
-const startPipe = (cwd, launch, onData, onClose) => {
-  const options = spawnBase({ cwd, env: agentEnv(), detached: !IS_WIN });
+const startInstall = (cwd, launch, onData, onClose) => {
+  const extra = { cwd, env: commandEnv(), detached: !IS_WIN };
+  const options =
+    launch.installer === 'npm' ? npmOpts(extra) : spawnBase(extra);
   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);
+  if (launch.kind === 'install') {
+    return startInstall(cwd, launch, onData, onClose);
+  }
+  return startRun(cwd, launch, onData, onClose, launch.env);
 };
 
 module.exports = {
@@ -558,16 +401,9 @@ module.exports = {
   agentSpec,
   findBin,
   detectAgents,
-  canLogin,
-  listedOf,
   listModels,
-  splitArgs,
   planPrompt,
-  needsAuth,
-  authState,
-  probeAuth,
-  commandLine,
   buildLaunch,
-  buildLogin,
+  buildInstall,
   startAgent,
 };