@phnx-labs/agents-cli 1.20.49 → 1.20.51

package/dist/lib/agents.js

@@ -21,6 +21,7 @@ import { latestFileMtimeMs } from './fs-walk.js';
 import { damerauLevenshtein } from './fuzzy.js';
 import { getCacheDir, getVersionsDir, getShimsDir, getCliVersionCachePath } from './state.js';
 import { resolveVersion, getVersionHomePath, getBinaryPath } from './versions.js';
+import { supports } from './capabilities.js';
 const execFileAsync = promisify(execFile);
 const HOME = os.homedir();
 /**
@@ -212,7 +213,7 @@ export const AGENTS = {
         // Claude Code has no headless Anthropic-hosted dispatch CLI (only
         // --remote-control, which bridges a *local* session). Its cloud is Rush.
         cloudProvider: 'rush',
-        capabilities: { hooks: true, mcp: true, allowlist: true, skills: true, commands: true, plugins: true, subagents: true, rules: { file: 'CLAUDE.md' }, workflows: true, modes: ['plan', 'edit', 'auto', 'skip'], rulesImports: true },
+        capabilities: { hooks: true, mcp: true, mcpHttp: true, mcpHeaders: true, allowlist: true, skills: true, commands: true, plugins: true, subagents: true, rules: { file: 'CLAUDE.md' }, workflows: true, modes: ['plan', 'edit', 'auto', 'skip'], rulesImports: true },
     },
     // codex hooks: gated to >= 0.116.0 (introduced [features] codex_hooks flag).
     codex: {
@@ -232,7 +233,7 @@ export const AGENTS = {
         variableSyntax: '$ARGUMENTS',
         supportsHooks: true,
         cloudProvider: 'codex',
-        capabilities: { hooks: { since: '0.116.0' }, mcp: true, allowlist: false, skills: true, commands: { until: '0.117.0' }, plugins: { since: '0.128.0' }, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['plan', 'edit', 'skip'] },
+        capabilities: { hooks: { since: '0.116.0' }, mcp: true, mcpHttp: true, mcpHeaders: false, allowlist: false, skills: true, commands: { until: '0.117.0' }, plugins: { since: '0.128.0' }, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['plan', 'edit', 'skip'] },
     },
     gemini: {
         id: 'gemini',
@@ -261,7 +262,7 @@ export const AGENTS = {
             url: 'https://developers.googleblog.com/an-important-update-transitioning-gemini-cli-to-antigravity-cli/',
         },
         // gemini hooks: shipped in v0.26.0 (Jan 2026); older binaries silently ignore the `hooks` key.
-        capabilities: { hooks: { since: '0.26.0' }, mcp: true, allowlist: false, skills: true, commands: true, plugins: false, subagents: false, rules: { file: 'GEMINI.md' }, workflows: false, modes: ['plan', 'edit', 'skip'], rulesImports: true },
+        capabilities: { hooks: { since: '0.26.0' }, mcp: true, mcpHttp: true, mcpHeaders: false, allowlist: false, skills: true, commands: true, plugins: false, subagents: false, rules: { file: 'GEMINI.md' }, workflows: false, modes: ['plan', 'edit', 'skip'], rulesImports: true },
     },
     cursor: {
         id: 'cursor',
@@ -279,7 +280,7 @@ export const AGENTS = {
         format: 'markdown',
         variableSyntax: '$ARGUMENTS',
         supportsHooks: false,
-        capabilities: { hooks: false, mcp: true, allowlist: false, skills: true, commands: true, plugins: false, subagents: false, rules: { file: '.cursorrules' }, workflows: false, modes: ['edit', 'skip'] },
+        capabilities: { hooks: false, mcp: true, mcpHttp: false, mcpHeaders: false, allowlist: false, skills: true, commands: true, plugins: false, subagents: false, rules: { file: '.cursorrules' }, workflows: false, modes: ['edit', 'skip'] },
     },
     opencode: {
         id: 'opencode',
@@ -296,7 +297,7 @@ export const AGENTS = {
         format: 'markdown',
         variableSyntax: '$ARGUMENTS',
         supportsHooks: false,
-        capabilities: { hooks: false, mcp: true, allowlist: false, skills: true, commands: true, plugins: false, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['plan', 'edit'] },
+        capabilities: { hooks: false, mcp: true, mcpHttp: false, mcpHeaders: false, allowlist: false, skills: true, commands: true, plugins: false, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['plan', 'edit'] },
     },
     openclaw: {
         id: 'openclaw',
@@ -314,7 +315,7 @@ export const AGENTS = {
         format: 'markdown',
         variableSyntax: '{{ARGUMENTS}}',
         supportsHooks: true,
-        capabilities: { hooks: true, mcp: true, allowlist: false, skills: true, commands: false, plugins: true, subagents: true, rules: { file: 'workspace/AGENTS.md' }, workflows: false, modes: ['plan', 'edit', 'skip'] },
+        capabilities: { hooks: true, mcp: true, mcpHttp: false, mcpHeaders: false, allowlist: false, skills: true, commands: false, plugins: true, subagents: true, rules: { file: 'workspace/AGENTS.md' }, workflows: false, modes: ['plan', 'edit', 'skip'] },
     },
     copilot: {
         id: 'copilot',
@@ -336,7 +337,7 @@ export const AGENTS = {
         format: 'markdown',
         variableSyntax: '$ARGUMENTS',
         supportsHooks: false,
-        capabilities: { hooks: false, mcp: true, allowlist: false, skills: true, commands: true, plugins: true, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['plan', 'edit', 'auto', 'skip'] },
+        capabilities: { hooks: false, mcp: true, mcpHttp: false, mcpHeaders: false, allowlist: false, skills: true, commands: true, plugins: true, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['plan', 'edit', 'auto', 'skip'] },
     },
     amp: {
         id: 'amp',
@@ -353,7 +354,7 @@ export const AGENTS = {
         format: 'markdown',
         variableSyntax: '$ARGUMENTS',
         supportsHooks: false,
-        capabilities: { hooks: false, mcp: true, allowlist: false, skills: true, commands: true, plugins: false, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['plan', 'edit'] },
+        capabilities: { hooks: false, mcp: true, mcpHttp: false, mcpHeaders: false, allowlist: false, skills: true, commands: true, plugins: false, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['plan', 'edit'] },
     },
     kiro: {
         id: 'kiro',
@@ -371,7 +372,7 @@ export const AGENTS = {
         format: 'markdown',
         variableSyntax: '$ARGUMENTS',
         supportsHooks: false,
-        capabilities: { hooks: false, mcp: true, allowlist: false, skills: true, commands: true, plugins: false, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['edit'] },
+        capabilities: { hooks: false, mcp: true, mcpHttp: false, mcpHeaders: false, allowlist: false, skills: true, commands: true, plugins: false, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['edit'] },
     },
     goose: {
         id: 'goose',
@@ -389,7 +390,7 @@ export const AGENTS = {
         format: 'markdown',
         variableSyntax: '$ARGUMENTS',
         supportsHooks: false,
-        capabilities: { hooks: false, mcp: true, allowlist: false, skills: false, commands: false, plugins: false, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['edit'] },
+        capabilities: { hooks: false, mcp: true, mcpHttp: false, mcpHeaders: false, allowlist: false, skills: false, commands: false, plugins: false, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['edit'] },
     },
     // Google Antigravity CLI (`agy`) — official replacement for Gemini CLI as of IO 2026.
     // configDir nests inside `~/.gemini/` since agy shares the parent dir with the Gemini
@@ -418,7 +419,7 @@ export const AGENTS = {
         variableSyntax: '{{args}}',
         supportsHooks: true,
         cloudProvider: 'antigravity',
-        capabilities: { hooks: true, mcp: true, allowlist: true, skills: true, commands: true, plugins: true, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['edit', 'skip'], rulesImports: false },
+        capabilities: { hooks: true, mcp: true, mcpHttp: false, mcpHeaders: false, allowlist: true, skills: true, commands: true, plugins: true, subagents: false, rules: { file: 'AGENTS.md' }, workflows: false, modes: ['edit', 'skip'], rulesImports: false },
     },
     // xAI Grok Build CLI (`grok`) — early beta, SuperGrok Heavy. Auth via OAuth on
     // first launch, or XAI_API_KEY env var for headless. MCP servers configured inline
@@ -445,6 +446,8 @@ export const AGENTS = {
         capabilities: {
             hooks: true,
             mcp: true,
+            mcpHttp: false,
+            mcpHeaders: false,
             allowlist: true, // maps to Grok's granular Bash/Edit/Write/Read/Grep/WebFetch/MCPTool rules
             skills: true,
             commands: false, // covered by skills
@@ -481,6 +484,8 @@ export const AGENTS = {
         capabilities: {
             hooks: true,
             mcp: true,
+            mcpHttp: false,
+            mcpHeaders: false,
             allowlist: true,
             skills: true,
             commands: false,
@@ -540,6 +545,8 @@ export const AGENTS = {
         capabilities: {
             hooks: true,
             mcp: true,
+            mcpHttp: false,
+            mcpHeaders: false,
             allowlist: false,
             skills: false,
             commands: true,
@@ -708,11 +715,6 @@ export async function getAllCliStates() {
     }
     return states;
 }
-/** Check whether the agent's config directory exists on disk. */
-export function isConfigured(agentId) {
-    const agent = AGENTS[agentId];
-    return fs.existsSync(agent.configDir);
-}
 /**
  * Agents that `agents setup` probes for pre-existing native installations
  * (i.e., a config dir present before agents-cli took over). Add an agent here
@@ -1310,31 +1312,16 @@ function buildIdentityKey(agentId, parts) {
         return null;
     return `${agentId}:${encoded.join(':')}`;
 }
-/** Check whether a named MCP server is registered with the agent's CLI. */
-export async function isMcpRegistered(agentId, mcpName) {
-    const agent = AGENTS[agentId];
-    if (!agent.capabilities.mcp || !(await isCliInstalled(agentId))) {
-        return false;
-    }
-    try {
-        const { stdout } = await execFileAsync(agent.cliCommand, ['mcp', 'list']);
-        return stdout.toLowerCase().includes(mcpName.toLowerCase());
-    }
-    catch {
-        /* mcp list command failed */
-        return false;
-    }
-}
 /** Register an MCP server with an agent's CLI via `mcp add`. */
 export async function registerMcp(agentId, name, command, scope = 'user', transport = 'stdio', options) {
     const agent = AGENTS[agentId];
     if (!agent.capabilities.mcp) {
         return { success: false, error: 'Agent does not support MCP' };
     }
-    if (transport === 'http' && agentId !== 'claude' && agentId !== 'codex' && agentId !== 'gemini') {
+    if (transport === 'http' && !supports(agentId, 'mcpHttp').ok) {
         return { success: false, error: 'skipped: agent does not support HTTP MCP registration' };
     }
-    if (transport === 'http' && options?.headers && Object.keys(options.headers).length > 0 && agentId !== 'claude') {
+    if (transport === 'http' && options?.headers && Object.keys(options.headers).length > 0 && !supports(agentId, 'mcpHeaders').ok) {
         return { success: false, error: 'skipped: HTTP MCP headers are only supported for Claude registration' };
     }
     if (!options?.binary && !(await isCliInstalled(agentId))) {

package/dist/lib/auto-dispatch-linear.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Concrete Linear gateway for auto-dispatch.
+ *
+ * Talks to the Linear GraphQL API. The API key is read from the LINEAR_API_KEY
+ * env var, falling back to the macOS keychain generic-password `linear-api-key`
+ * (how the rest of the stack stores it). If no key is resolvable, the gateway is
+ * absent and the daemon skips auto-dispatch entirely.
+ *
+ * "Started" (Doing) and "unstarted" (Todo) are Linear state *types*, so we never
+ * hardcode a team's custom state names. `startIssue` resolves the team's first
+ * started-type state (cached per team) and moves the issue there — the existing
+ * factory webhook turns that transition into a real run.
+ */
+import type { LinearGateway } from './auto-dispatch.js';
+/** Resolve the Linear API key from env or (on macOS) the keychain. Null if absent. */
+export declare function resolveLinearApiKey(): string | null;
+/** Build a real Linear gateway, or null when no API key is configured. */
+export declare function createLinearGateway(): LinearGateway | null;

package/dist/lib/auto-dispatch-linear.js

@@ -0,0 +1,107 @@
+/**
+ * Concrete Linear gateway for auto-dispatch.
+ *
+ * Talks to the Linear GraphQL API. The API key is read from the LINEAR_API_KEY
+ * env var, falling back to the macOS keychain generic-password `linear-api-key`
+ * (how the rest of the stack stores it). If no key is resolvable, the gateway is
+ * absent and the daemon skips auto-dispatch entirely.
+ *
+ * "Started" (Doing) and "unstarted" (Todo) are Linear state *types*, so we never
+ * hardcode a team's custom state names. `startIssue` resolves the team's first
+ * started-type state (cached per team) and moves the issue there — the existing
+ * factory webhook turns that transition into a real run.
+ */
+import { execFileSync } from 'child_process';
+const LINEAR_API = 'https://api.linear.app/graphql';
+/** Resolve the Linear API key from env or (on macOS) the keychain. Null if absent. */
+export function resolveLinearApiKey() {
+    const fromEnv = process.env.LINEAR_API_KEY?.trim();
+    if (fromEnv)
+        return fromEnv;
+    if (process.platform === 'darwin') {
+        try {
+            const out = execFileSync('security', ['find-generic-password', '-s', 'linear-api-key', '-w'], {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            const key = out.trim();
+            if (key)
+                return key;
+        }
+        catch {
+            // not in keychain — fall through
+        }
+    }
+    return null;
+}
+async function gql(apiKey, query, variables) {
+    const res = await fetch(LINEAR_API, {
+        method: 'POST',
+        headers: { Authorization: apiKey, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ query, variables }),
+    });
+    if (!res.ok)
+        throw new Error(`Linear API HTTP ${res.status}`);
+    const json = (await res.json());
+    if (json.errors?.length)
+        throw new Error(`Linear API: ${json.errors.map((e) => e.message).join('; ')}`);
+    if (!json.data)
+        throw new Error('Linear API: empty response');
+    return json.data;
+}
+/** Build a real Linear gateway, or null when no API key is configured. */
+export function createLinearGateway() {
+    const apiKey = resolveLinearApiKey();
+    if (!apiKey)
+        return null;
+    // Cache the resolved started-state id per team so we don't re-query each dispatch.
+    const startedStateByTeam = new Map();
+    async function resolveStartedState(teamId) {
+        const cached = startedStateByTeam.get(teamId);
+        if (cached)
+            return cached;
+        const data = await gql(apiKey, `query($t:String!){ workflowStates(filter:{ team:{ id:{ eq:$t } }, type:{ eq:"started" } }, first:10){ nodes{ id type position } } }`, { t: teamId });
+        const nodes = data.workflowStates.nodes.slice().sort((a, b) => a.position - b.position);
+        const state = nodes[0];
+        if (!state)
+            throw new Error(`no started-type workflow state for team ${teamId}`);
+        startedStateByTeam.set(teamId, state.id);
+        return state.id;
+    }
+    // team id per issue, captured during fetchDelegatedTodo, so startIssue can resolve state.
+    const teamByIssue = new Map();
+    return {
+        async countInFlight(linearProjectId) {
+            const data = await gql(apiKey, `query($p:ID!){ issues(filter:{ project:{ id:{ eq:$p } }, state:{ type:{ eq:"started" } }, delegate:{ null:false } }, first:250){ nodes{ id } } }`, { p: linearProjectId });
+            return data.issues.nodes.length;
+        },
+        async fetchDelegatedTodo(linearProjectId) {
+            const data = await gql(apiKey, `query($p:ID!){ issues(filter:{ project:{ id:{ eq:$p } }, state:{ type:{ eq:"unstarted" } }, delegate:{ null:false } }, first:50){ nodes{ id identifier title priority delegate{ name } team{ id } } } }`, { p: linearProjectId });
+            const out = [];
+            for (const n of data.issues.nodes) {
+                if (!n.delegate?.name)
+                    continue;
+                if (n.team?.id)
+                    teamByIssue.set(n.id, n.team.id);
+                out.push({ id: n.id, identifier: n.identifier, title: n.title ?? '', priority: n.priority ?? 0, delegateName: n.delegate.name });
+            }
+            return out;
+        },
+        async markStarted(issueId, delegateName) {
+            const teamId = teamByIssue.get(issueId);
+            if (!teamId)
+                throw new Error(`unknown team for issue ${issueId} (fetch it first)`);
+            const stateId = await resolveStartedState(teamId);
+            const data = await gql(apiKey, `mutation($id:String!,$s:String!){ issueUpdate(id:$id, input:{ stateId:$s }){ success } }`, { id: issueId, s: stateId });
+            if (!data.issueUpdate.success)
+                throw new Error(`issueUpdate failed for ${issueId}`);
+            // Leave a trail so the auto-dispatch is visible in the ticket history.
+            try {
+                await gql(apiKey, `mutation($i:String!,$b:String!){ commentCreate(input:{ issueId:$i, body:$b }){ success } }`, { i: issueId, b: `Auto-dispatched to **${delegateName}** by the factory (moved Todo → Doing).` });
+            }
+            catch {
+                // comment is best-effort — the state change is what matters
+            }
+        },
+    };
+}

package/dist/lib/auto-dispatch-provider.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Concrete Dispatcher for auto-dispatch — runs a ticket through agents-cli's own
+ * cloud-provider abstraction (`resolveProvider().dispatch()`), the same layer as
+ * `agents cloud run`. Rush (Prix) is one provider among rush/codex/factory; a
+ * project pins its provider via `provider` in projects.json, else the delegate
+ * agent's native cloud is used. This is what removes the hidden Prix coupling —
+ * auto-dispatch no longer depends on the prix/api webhook.
+ */
+import type { Dispatcher } from './auto-dispatch.js';
+export declare function createProviderDispatcher(): Dispatcher;

package/dist/lib/auto-dispatch-provider.js

@@ -0,0 +1,25 @@
+/**
+ * Concrete Dispatcher for auto-dispatch — runs a ticket through agents-cli's own
+ * cloud-provider abstraction (`resolveProvider().dispatch()`), the same layer as
+ * `agents cloud run`. Rush (Prix) is one provider among rush/codex/factory; a
+ * project pins its provider via `provider` in projects.json, else the delegate
+ * agent's native cloud is used. This is what removes the hidden Prix coupling —
+ * auto-dispatch no longer depends on the prix/api webhook.
+ */
+import { resolveProvider } from './cloud/registry.js';
+export function createProviderDispatcher() {
+    return {
+        async dispatch({ agent, prompt, repo, provider }) {
+            const p = resolveProvider(provider, agent);
+            const caps = p.capabilities();
+            if (!caps.available) {
+                throw new Error(`cloud provider '${p.id}' is not available (auth/binary missing)`);
+            }
+            if (!caps.dispatch) {
+                throw new Error(`cloud provider '${p.id}' does not support dispatch`);
+            }
+            const task = await p.dispatch({ agent, prompt, repo });
+            return { id: task.id };
+        },
+    };
+}

package/dist/lib/auto-dispatch.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Auto-dispatch — pull side of the factory dispatch loop.
+ *
+ * Polls Linear for issues that are delegated to an agent and still in Todo for a
+ * managed project, and — up to a per-project concurrency cap — DISPATCHES each
+ * through agents-cli's own cloud-provider abstraction (`resolveProvider().dispatch()`),
+ * then marks the ticket Doing so it isn't picked up twice.
+ *
+ * The dispatch goes through the same provider layer as `agents cloud run`, so Rush
+ * (Prix) is just one provider among rush/codex/factory — NOT a hidden requirement.
+ * A project may pin its provider via `provider` in ~/.agents/factory/projects.json.
+ *
+ * OPT-IN: a project auto-dispatches ONLY when `autoDispatch: true` AND `maxAgents > 0`.
+ * Nothing global is on by default.
+ */
+/** The subset of a managed project this module needs (mirror of the shared JSON). */
+export interface AutoDispatchProject {
+    id: string;
+    name: string;
+    linearProjectId?: string;
+    repoSlug?: string;
+    autoDispatch?: boolean;
+    maxAgents?: number;
+    provider?: string;
+}
+/** A Linear issue that is a candidate for dispatch. */
+export interface DelegatedIssue {
+    id: string;
+    identifier: string;
+    title: string;
+    delegateName: string;
+    priority: number;
+}
+/** One planned dispatch: which issue, to which agent, in which project. */
+export interface PlannedDispatch {
+    projectId: string;
+    repoSlug?: string;
+    provider?: string;
+    issueId: string;
+    identifier: string;
+    title: string;
+    delegateName: string;
+}
+/** Path to the shared factory project registry (written by the factory UI). */
+export declare function factoryProjectsPath(): string;
+/** Read the project registry rows this module cares about. */
+export declare function readAutoDispatchProjects(): AutoDispatchProject[];
+/** A project is eligible only when it has explicitly opted in with a positive cap. */
+export declare function isEligible(p: AutoDispatchProject): boolean;
+/**
+ * PURE planner. Given eligible projects, in-flight counts, and delegated-Todo
+ * issues per project, decide which issues to dispatch — never exceeding
+ * `maxAgents` in-flight. Highest Linear priority first.
+ */
+export declare function planAutoDispatch(projects: AutoDispatchProject[], inFlightByProject: Record<string, number>, delegatedTodoByProject: Record<string, DelegatedIssue[]>): PlannedDispatch[];
+/** Map Linear priority to a sortable rank (urgent first, none last). */
+export declare function priorityRank(priority: number): number;
+/** Build the prompt an auto-dispatched agent receives for a ticket. */
+export declare function dispatchPrompt(identifier: string, title: string): string;
+/** Linear I/O surface — discovery + bookkeeping (NOT the dispatch trigger). */
+export interface LinearGateway {
+    /** Count issues in a started ("Doing") state whose delegate is set, per project. */
+    countInFlight(linearProjectId: string): Promise<number>;
+    /** Fetch delegated issues in an unstarted ("Todo") state for a project. */
+    fetchDelegatedTodo(linearProjectId: string): Promise<DelegatedIssue[]>;
+    /** After a successful dispatch: move the issue Todo -> Doing so it isn't re-picked. */
+    markStarted(issueId: string, delegateName: string): Promise<void>;
+}
+/** Dispatch surface — runs a ticket through agents-cli's cloud/local provider layer. */
+export interface Dispatcher {
+    dispatch(opts: {
+        agent: string;
+        prompt: string;
+        repo?: string;
+        provider?: string;
+    }): Promise<{
+        id: string;
+    }>;
+}
+export interface AutoDispatchDeps {
+    projects: AutoDispatchProject[];
+    linear: LinearGateway;
+    dispatcher: Dispatcher;
+    log?: (level: 'INFO' | 'WARN' | 'ERROR', msg: string) => void;
+}
+/** One tick: read state per eligible project, plan, dispatch, then mark started. */
+export declare function autoDispatchTick(deps: AutoDispatchDeps): Promise<PlannedDispatch[]>;

package/dist/lib/auto-dispatch.js

@@ -0,0 +1,142 @@
+/**
+ * Auto-dispatch — pull side of the factory dispatch loop.
+ *
+ * Polls Linear for issues that are delegated to an agent and still in Todo for a
+ * managed project, and — up to a per-project concurrency cap — DISPATCHES each
+ * through agents-cli's own cloud-provider abstraction (`resolveProvider().dispatch()`),
+ * then marks the ticket Doing so it isn't picked up twice.
+ *
+ * The dispatch goes through the same provider layer as `agents cloud run`, so Rush
+ * (Prix) is just one provider among rush/codex/factory — NOT a hidden requirement.
+ * A project may pin its provider via `provider` in ~/.agents/factory/projects.json.
+ *
+ * OPT-IN: a project auto-dispatches ONLY when `autoDispatch: true` AND `maxAgents > 0`.
+ * Nothing global is on by default.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { homedir } from 'os';
+/** Path to the shared factory project registry (written by the factory UI). */
+export function factoryProjectsPath() {
+    return path.join(homedir(), '.agents', 'factory', 'projects.json');
+}
+/** Read the project registry rows this module cares about. */
+export function readAutoDispatchProjects() {
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(factoryProjectsPath(), 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const r of raw) {
+        if (!r || typeof r !== 'object')
+            continue;
+        const o = r;
+        if (typeof o.id !== 'string' || typeof o.name !== 'string')
+            continue;
+        out.push({
+            id: o.id,
+            name: o.name,
+            linearProjectId: typeof o.linearProjectId === 'string' ? o.linearProjectId : undefined,
+            repoSlug: typeof o.repoSlug === 'string' ? o.repoSlug : undefined,
+            autoDispatch: o.autoDispatch === true,
+            maxAgents: typeof o.maxAgents === 'number' ? o.maxAgents : undefined,
+            provider: typeof o.provider === 'string' ? o.provider : undefined,
+        });
+    }
+    return out;
+}
+/** A project is eligible only when it has explicitly opted in with a positive cap. */
+export function isEligible(p) {
+    return p.autoDispatch === true && typeof p.maxAgents === 'number' && p.maxAgents > 0 && !!p.linearProjectId;
+}
+/**
+ * PURE planner. Given eligible projects, in-flight counts, and delegated-Todo
+ * issues per project, decide which issues to dispatch — never exceeding
+ * `maxAgents` in-flight. Highest Linear priority first.
+ */
+export function planAutoDispatch(projects, inFlightByProject, delegatedTodoByProject) {
+    const plan = [];
+    for (const p of projects) {
+        if (!isEligible(p))
+            continue;
+        const cap = p.maxAgents;
+        const slots = cap - (inFlightByProject[p.id] ?? 0);
+        if (slots <= 0)
+            continue;
+        const candidates = (delegatedTodoByProject[p.id] ?? [])
+            .slice()
+            .sort((a, b) => priorityRank(a.priority) - priorityRank(b.priority));
+        for (const issue of candidates.slice(0, slots)) {
+            plan.push({
+                projectId: p.id,
+                repoSlug: p.repoSlug,
+                provider: p.provider,
+                issueId: issue.id,
+                identifier: issue.identifier,
+                title: issue.title,
+                delegateName: issue.delegateName,
+            });
+        }
+    }
+    return plan;
+}
+/** Map Linear priority to a sortable rank (urgent first, none last). */
+export function priorityRank(priority) {
+    return priority === 0 ? 5 : priority;
+}
+/** Build the prompt an auto-dispatched agent receives for a ticket. */
+export function dispatchPrompt(identifier, title) {
+    return `Work on Linear ticket ${identifier}: ${title}. Read the ticket for full context, implement it, and open a PR when done.`;
+}
+/** One tick: read state per eligible project, plan, dispatch, then mark started. */
+export async function autoDispatchTick(deps) {
+    const log = deps.log ?? (() => { });
+    const eligible = deps.projects.filter(isEligible);
+    if (eligible.length === 0)
+        return [];
+    const inFlight = {};
+    const todo = {};
+    for (const p of eligible) {
+        const pid = p.linearProjectId;
+        try {
+            inFlight[p.id] = await deps.linear.countInFlight(pid);
+            todo[p.id] = await deps.linear.fetchDelegatedTodo(pid);
+        }
+        catch (err) {
+            log('WARN', `auto-dispatch: failed to read Linear state for '${p.name}': ${err.message}`);
+            inFlight[p.id] = Number.MAX_SAFE_INTEGER; // fail closed for this project
+            todo[p.id] = [];
+        }
+    }
+    const plan = planAutoDispatch(eligible, inFlight, todo);
+    const dispatched = [];
+    for (const d of plan) {
+        try {
+            const task = await deps.dispatcher.dispatch({
+                agent: d.delegateName.trim().toLowerCase(),
+                prompt: dispatchPrompt(d.identifier, d.title),
+                repo: d.repoSlug,
+                provider: d.provider,
+            });
+            // Bookkeeping only — dispatch already happened; moving to Doing keeps the
+            // ticket out of the next Todo poll. A failure here is non-fatal.
+            try {
+                await deps.linear.markStarted(d.issueId, d.delegateName);
+            }
+            catch (err) {
+                log('WARN', `auto-dispatch: dispatched ${d.identifier} but failed to mark Doing: ${err.message}`);
+            }
+            dispatched.push(d);
+            log('INFO', `auto-dispatch: dispatched ${d.identifier} to ${d.delegateName} (task ${task.id})`);
+        }
+        catch (err) {
+            log('WARN', `auto-dispatch: failed to dispatch ${d.identifier}: ${err.message}`);
+        }
+    }
+    return dispatched;
+}

package/dist/lib/browser/cdp.js

@@ -1,3 +1,12 @@
+// The `ws` client, NOT the platform (undici) WebSocket: undici enforces a
+// non-configurable max decompressed message size, and a CDP response carrying
+// a base64 screenshot of a content-rich page blows past it — the socket dies
+// with code 1006 ("Max decompressed message size exceeded") while the command
+// is pending. `ws` offers no permessage-deflate by default and takes an
+// explicit payload cap. (Reproduced live against a remote Edge over
+// `browser --host`: fresh blank newtab passed, reused content-rich newtab
+// failed on every Page.captureScreenshot.)
+import WSWebSocket from 'ws';
 const pipeTransports = new Map();
 export function registerPipeTransport(transport) {
     const id = `pipe://${process.pid}/${pipeTransports.size + 1}`;
@@ -26,7 +35,7 @@ export class CDPClient {
             return;
         }
         return new Promise((resolve, reject) => {
-            this.ws = new WebSocket(endpoint);
+            this.ws = new WSWebSocket(endpoint, { maxPayload: 256 * 1024 * 1024 });
             this.transport = 'websocket';
             this.ws.onopen = () => resolve();
             this.ws.onerror = () => reject(new Error('WebSocket error'));
@@ -102,7 +111,7 @@ export class CDPClient {
         this.transport = null;
     }
     get connected() {
-        return ((this.ws !== null && this.ws.readyState === WebSocket.OPEN) ||
+        return ((this.ws !== null && this.ws.readyState === WSWebSocket.OPEN) ||
             (this.pipe !== null && !this.pipe.write.destroyed));
     }
     get isOpen() {