@agent-spaces/server 0.3.65 → 0.3.67

package/dist/adapters/agent-runtime.js

@@ -3,10 +3,12 @@
  */
 import { ClaudeCodeRuntime } from './claude-code-runtime/index.js';
 import { CodexRuntime } from './codex-runtime.js';
+import { HermesRuntime } from './hermes-runtime.js';
 import { LangChainRuntime } from './langchain-runtime.js';
 import { OpenAgentSdkRuntime } from './open-agent-sdk-runtime.js';
 export { ClaudeCodeRuntime } from './claude-code-runtime/index.js';
 export { CodexRuntime } from './codex-runtime.js';
+export { HermesRuntime } from './hermes-runtime.js';
 export { LangChainRuntime } from './langchain-runtime.js';
 export { OpenAgentSdkRuntime } from './open-agent-sdk-runtime.js';
 export function createAgentRuntime(configOrProvider = {}, model) {
@@ -22,6 +24,8 @@ export function createAgentRuntime(configOrProvider = {}, model) {
             return new CodexRuntime(config);
         case 'langchain':
             return new LangChainRuntime(config);
+        case 'hermes':
+            return new HermesRuntime(config);
     }
 }
 //# sourceMappingURL=agent-runtime.js.map

package/dist/adapters/codex-function-tool-bridge.js

@@ -0,0 +1,144 @@
+import { randomUUID } from 'node:crypto';
+import { createServer } from 'node:http';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
+const AGENT_SPACES_MCP_SERVER_NAME = 'agent-spaces';
+export async function startCodexFunctionToolBridge(functionTools, log) {
+    if (!functionTools?.length)
+        return undefined;
+    const toolsByName = new Map(functionTools.map((functionTool) => [functionTool.name, functionTool]));
+    const mcpServer = new Server({ name: AGENT_SPACES_MCP_SERVER_NAME, version: '0.1.0' }, {
+        capabilities: {
+            tools: { listChanged: false },
+        },
+        instructions: 'Agent Spaces built-in runtime tools for workspace data.',
+    });
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: randomUUID,
+        enableJsonResponse: true,
+    });
+    mcpServer.setRequestHandler(ListToolsRequestSchema, () => ({
+        tools: functionTools.map(toMcpTool),
+    }));
+    mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const functionTool = toolsByName.get(request.params.name);
+        if (!functionTool) {
+            throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
+        }
+        const result = await functionTool.execute(request.params.arguments ?? {});
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: stringifyToolResult(result),
+                },
+            ],
+            ...(isRecord(result) ? { structuredContent: result } : {}),
+        };
+    });
+    await mcpServer.connect(transport);
+    const httpServer = createServer(async (req, res) => {
+        try {
+            const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+            if (url.pathname !== '/mcp') {
+                res.writeHead(404).end('Not found');
+                return;
+            }
+            await transport.handleRequest(req, res);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log?.(`function tool bridge request failed | ${message}`);
+            if (!res.headersSent)
+                res.writeHead(500, { 'content-type': 'text/plain; charset=utf-8' });
+            if (!res.writableEnded)
+                res.end(message);
+        }
+    });
+    await listen(httpServer);
+    const address = httpServer.address();
+    if (!address || typeof address === 'string') {
+        await closeHttpServer(httpServer);
+        await mcpServer.close();
+        throw new Error('Failed to start Codex function tool bridge');
+    }
+    const url = `http://127.0.0.1:${address.port}/mcp`;
+    log?.(`function tool bridge started | url=${url} tools=${functionTools.map((tool) => tool.name).join(',')}`);
+    return {
+        name: AGENT_SPACES_MCP_SERVER_NAME,
+        url,
+        close: async () => {
+            await mcpServer.close();
+            await closeHttpServer(httpServer);
+            log?.('function tool bridge stopped');
+        },
+    };
+}
+function toMcpTool(functionTool) {
+    return {
+        name: functionTool.name,
+        description: functionTool.description,
+        inputSchema: normalizeToolInputSchema(functionTool.inputSchema),
+        annotations: toMcpToolAnnotations(functionTool),
+    };
+}
+function normalizeToolInputSchema(schema) {
+    if (schema.type === 'object')
+        return schema;
+    return {
+        type: 'object',
+        properties: normalizeSchemaProperties(schema.properties),
+        required: Array.isArray(schema.required) ? schema.required.map(String) : [],
+    };
+}
+function toMcpToolAnnotations(functionTool) {
+    if (!functionTool.annotations)
+        return undefined;
+    return {
+        readOnlyHint: functionTool.annotations.readOnly,
+        destructiveHint: functionTool.annotations.destructive,
+        openWorldHint: functionTool.annotations.openWorld,
+    };
+}
+function stringifyToolResult(result) {
+    if (result === undefined)
+        return 'null';
+    return JSON.stringify(result, null, 2) ?? String(result);
+}
+function normalizeSchemaProperties(properties) {
+    if (!isRecord(properties))
+        return {};
+    return Object.fromEntries(Object.entries(properties).filter((entry) => isRecord(entry[1])));
+}
+function listen(server) {
+    return new Promise((resolve, reject) => {
+        const onError = (err) => {
+            server.off('listening', onListening);
+            reject(err);
+        };
+        const onListening = () => {
+            server.off('error', onError);
+            resolve();
+        };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(0, '127.0.0.1');
+    });
+}
+function closeHttpServer(server) {
+    if (!server.listening)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        server.close((err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+//# sourceMappingURL=codex-function-tool-bridge.js.map

package/dist/adapters/codex-runtime.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, wri
 import { basename, extname, join } from 'node:path';
 import { Codex } from '@openai/codex-sdk';
 import { appendOutputStyleToPrompt, summarizeResult } from './agent-runtime-types.js';
+import { startCodexFunctionToolBridge } from './codex-function-tool-bridge.js';
 /**
  * Runtime backed by OpenAI's Codex SDK.
  * Spawns the bundled Codex CLI and consumes its structured JSONL event stream.
@@ -23,12 +24,15 @@ export class CodexRuntime {
         if (codexHome)
             prepareCodexHome(codexHome, agentDir);
         const skillNames = normalizeSkillNames(options?.skills, codexHome);
-        const configOverrides = buildCodexConfig(this.config, options, skillNames);
         const sandboxMode = normalizeSandboxMode(this.config.permissionMode);
         const approvalPolicy = normalizeApprovalPolicy(this.config.permissionMode);
-        d(`starting | cwd=${cwd} model=${this.config.model ?? 'default'} sandboxMode=${sandboxMode} approvalPolicy=${approvalPolicy} maxTurns=${options?.maxTurns ?? '∞'} mcpServers=${Object.keys(options?.mcpServers ?? {}).join(',') || '-'} skills=${skillNames.join(',') || '-'} codexHome=${codexHome ?? 'default'} sandboxDirs=${options?.sandboxDirs?.join(',') ?? '-'}`);
+        let functionToolBridge;
+        d(`starting | cwd=${cwd} model=${this.config.model ?? 'default'} sandboxMode=${sandboxMode} approvalPolicy=${approvalPolicy} maxTurns=${options?.maxTurns ?? '∞'} mcpServers=${Object.keys(options?.mcpServers ?? {}).join(',') || '-'} functionTools=${options?.functionTools?.map((tool) => tool.name).join(',') || '-'} skills=${skillNames.join(',') || '-'} codexHome=${codexHome ?? 'default'} sandboxDirs=${options?.sandboxDirs?.join(',') ?? '-'}`);
         d(`prompt: ${prompt.slice(0, 300)}${prompt.length > 300 ? '...' : ''}`);
         try {
+            functionToolBridge = await startCodexFunctionToolBridge(options?.functionTools, d);
+            const mcpServers = withFunctionToolBridge(options?.mcpServers, functionToolBridge);
+            const configOverrides = buildCodexConfig(this.config, mcpServers, skillNames);
             const codex = new Codex({
                 apiKey: this.config.apiKey,
                 baseUrl: shouldUseCodexOpenAIBaseUrl(this.config) ? this.config.baseURL : undefined,
@@ -127,6 +131,13 @@ export class CodexRuntime {
             return { success: false, summary: 'Codex execution failed', artifacts: [], error: message, output, sessionId: options?.resumeSessionId };
         }
         finally {
+            try {
+                await functionToolBridge?.close();
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                d(`function tool bridge close failed | ${message}`);
+            }
             this.abortController = null;
         }
     }
@@ -143,13 +154,13 @@ function buildEnv(config, codexHome) {
         CODEX_INTERNAL_ORIGINATOR_OVERRIDE: process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE || 'agent-spaces/server',
     });
 }
-function buildCodexConfig(runtimeConfig, options, skillNames) {
+function buildCodexConfig(runtimeConfig, rawMcpServers, skillNames) {
     const config = {};
     Object.assign(config, buildCodexProviderConfig(runtimeConfig));
     if (runtimeConfig.thinkingEnabled !== false) {
         config.model_reasoning_effort = runtimeConfig.thinkingEffort ?? 'medium';
     }
-    const mcpServers = normalizeMcpServers(options?.mcpServers);
+    const mcpServers = normalizeMcpServers(rawMcpServers);
     if (mcpServers)
         config.mcp_servers = mcpServers;
     if (skillNames.length > 0) {
@@ -157,6 +168,14 @@ function buildCodexConfig(runtimeConfig, options, skillNames) {
     }
     return removeUndefined(config);
 }
+function withFunctionToolBridge(mcpServers, bridge) {
+    if (!bridge)
+        return mcpServers;
+    return {
+        ...(mcpServers ?? {}),
+        [bridge.name]: { url: bridge.url },
+    };
+}
 function buildCodexProviderConfig(runtimeConfig) {
     if (!runtimeConfig.baseURL || shouldUseCodexOpenAIBaseUrl(runtimeConfig))
         return {};

package/dist/adapters/git.js

@@ -170,6 +170,12 @@ export async function gitStatus(workspaceId) {
     try {
         const upstream = await getUpstreamRef(git, result.branch);
         if (upstream) {
+            const counts = await git.raw(['rev-list', '--left-right', '--count', `HEAD...${upstream}`]);
+            const [ahead, behind] = counts.trim().split(/\s+/).map((value) => Number(value));
+            if (Number.isFinite(ahead))
+                result.ahead = ahead;
+            if (Number.isFinite(behind))
+                result.behind = behind;
             const remoteHeadHash = await git.revparse(['--short', upstream]);
             result.remoteHeadHash = remoteHeadHash.trim();
         }
@@ -376,7 +382,7 @@ export async function gitPush(workspaceId) {
     const remotes = await git.getRemotes(true);
     if (!remotes.length)
         throw new Error('No remote repository configured. Please add a remote first.');
-    await git.push('origin', branch);
+    await git.push('origin', branch, ['--set-upstream']);
 }
 export async function gitFetch(workspaceId) {
     const ws = getWorkspace(workspaceId);
@@ -392,6 +398,11 @@ export async function gitPull(workspaceId) {
     const git = getGit(ws);
     const status = await git.status();
     const branch = status.current || 'HEAD';
+    const upstream = await getUpstreamRef(git, branch);
+    if (upstream?.startsWith('origin/')) {
+        await git.pull('origin', upstream.slice('origin/'.length));
+        return;
+    }
     await git.pull('origin', branch);
 }
 export async function gitGetRemotes(workspaceId) {

package/dist/adapters/hermes-runtime.js

@@ -0,0 +1,210 @@
+import { spawn } from 'node:child_process';
+import { copyFileSync, existsSync, mkdirSync, readdirSync, rmSync, statSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+import { appendOutputStyleToPrompt, summarizeResult } from './agent-runtime-types.js';
+/**
+ * Runtime backed by the external Hermes CLI.
+ *
+ * Hermes does not currently expose a structured JS SDK here, so this adapter
+ * treats verbose CLI output as the source of truth and streams it as text.
+ */
+export class HermesRuntime {
+    config;
+    child = null;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    async execute(prompt, workingDir, options) {
+        const output = [];
+        const cwd = workingDir || process.cwd();
+        const startTime = Date.now();
+        const d = (message) => console.log(`[hermes] ${message}`);
+        const agentDir = options?.configDir;
+        const hermesHome = agentDir ? join(agentDir, '.hermes') : undefined;
+        if (hermesHome)
+            prepareHermesHome(hermesHome, agentDir);
+        const args = buildHermesArgs(appendOutputStyleToPrompt(prompt, options?.outputStyle), this.config, options);
+        d(`starting | cwd=${cwd} model=${this.config.model ?? 'profile-default'} provider=${this.config.provider ?? 'profile-default'} hermesHome=${hermesHome ?? 'default'} skills=${options?.skills?.join(',') || '-'}`);
+        return new Promise((resolve) => {
+            let settled = false;
+            let stdoutBuffer = '';
+            let stderrBuffer = '';
+            let sessionId = options?.resumeSessionId;
+            let emittedSessionId = sessionId;
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.child = null;
+                resolve(result);
+            };
+            try {
+                this.child = spawn('hermes', args, {
+                    cwd,
+                    env: buildEnv(this.config, hermesHome),
+                    windowsHide: true,
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                d(`failed to start | ${message}`);
+                finish({
+                    success: false,
+                    summary: 'Hermes execution failed',
+                    artifacts: [],
+                    error: message,
+                    output,
+                    sessionId,
+                });
+                return;
+            }
+            this.child.stdout.setEncoding('utf-8');
+            this.child.stderr.setEncoding('utf-8');
+            this.child.stdout.on('data', (chunk) => {
+                stdoutBuffer = consumeLines(stdoutBuffer + chunk, (line) => {
+                    if (!line)
+                        return;
+                    output.push(line);
+                    const parsedSessionId = extractSessionId(line);
+                    if (parsedSessionId && parsedSessionId !== emittedSessionId) {
+                        sessionId = parsedSessionId;
+                        emittedSessionId = parsedSessionId;
+                        options?.onEvent?.({ type: 'session', sessionId });
+                    }
+                    options?.onEvent?.({ type: 'output', line });
+                });
+            });
+            this.child.stderr.on('data', (chunk) => {
+                stderrBuffer = consumeLines(stderrBuffer + chunk, (line) => {
+                    if (!line)
+                        return;
+                    const formatted = `[stderr] ${line}`;
+                    output.push(formatted);
+                    options?.onEvent?.({ type: 'output', line: formatted });
+                });
+            });
+            this.child.on('error', (err) => {
+                const message = err.message.includes('ENOENT')
+                    ? 'Hermes CLI was not found. Install Hermes and ensure the `hermes` command is available on PATH.'
+                    : err.message;
+                d(`failed ${Date.now() - startTime}ms | ${message}`);
+                finish({
+                    success: false,
+                    summary: 'Hermes execution failed',
+                    artifacts: [],
+                    error: message,
+                    output,
+                    sessionId,
+                });
+            });
+            this.child.on('close', (code, signal) => {
+                stdoutBuffer = flushLine(stdoutBuffer, output, options);
+                stderrBuffer = flushLine(stderrBuffer, output, options, '[stderr] ');
+                const elapsed = Date.now() - startTime;
+                if (code === 0) {
+                    const text = lastMeaningfulLine(output);
+                    d(`done ${elapsed}ms`);
+                    finish({
+                        success: true,
+                        summary: summarizeResult(text),
+                        artifacts: [],
+                        output,
+                        sessionId,
+                    });
+                    return;
+                }
+                const error = signal
+                    ? `Hermes execution stopped by signal ${signal}`
+                    : `Hermes execution failed with exit code ${code ?? 'unknown'}`;
+                d(`failed ${elapsed}ms | ${error}`);
+                finish({
+                    success: false,
+                    summary: 'Hermes execution failed',
+                    artifacts: [],
+                    error,
+                    output,
+                    sessionId,
+                });
+            });
+        });
+    }
+    stop() {
+        this.child?.kill();
+    }
+}
+function buildHermesArgs(prompt, config, options) {
+    const args = ['chat', '-q', prompt, '--verbose'];
+    for (const skill of normalizeSkillNames(options?.skills))
+        args.push('-s', skill);
+    if (config.model)
+        args.push('--model', config.model);
+    if (config.provider)
+        args.push('--provider', String(config.provider));
+    return args;
+}
+function buildEnv(config, hermesHome) {
+    const apiKey = config.apiKey || process.env.HERMES_API_KEY || process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY;
+    return {
+        ...process.env,
+        HERMES_HOME: hermesHome || process.env.HERMES_HOME,
+        HERMES_API_KEY: apiKey,
+        HERMES_BASE_URL: config.baseURL || process.env.HERMES_BASE_URL,
+        OPENAI_API_KEY: config.apiKey || process.env.OPENAI_API_KEY,
+        OPENAI_BASE_URL: config.baseURL || process.env.OPENAI_BASE_URL,
+        ANTHROPIC_API_KEY: config.apiKey || process.env.ANTHROPIC_API_KEY,
+        NO_COLOR: process.env.NO_COLOR || '1',
+    };
+}
+function prepareHermesHome(hermesHome, agentDir) {
+    mkdirSync(hermesHome, { recursive: true });
+    const skillsDir = join(hermesHome, 'skills');
+    rmSync(skillsDir, { recursive: true, force: true });
+    mkdirSync(skillsDir, { recursive: true });
+    if (!agentDir)
+        return;
+    const sourceSkillsDir = join(agentDir, 'skills');
+    if (!existsSync(sourceSkillsDir))
+        return;
+    for (const file of readdirSync(sourceSkillsDir)) {
+        if (extname(file).toLowerCase() !== '.md')
+            continue;
+        const sourceFile = join(sourceSkillsDir, file);
+        if (!statSync(sourceFile).isFile())
+            continue;
+        copyFileSync(sourceFile, join(skillsDir, basename(file)));
+    }
+}
+function consumeLines(buffer, onLine) {
+    const lines = buffer.split(/\r?\n/);
+    const remainder = lines.pop() ?? '';
+    for (const line of lines)
+        onLine(stripAnsi(line).trimEnd());
+    return remainder;
+}
+function flushLine(buffer, output, options, prefix = '') {
+    const line = stripAnsi(buffer).trimEnd();
+    if (line) {
+        const formatted = `${prefix}${line}`;
+        output.push(formatted);
+        options?.onEvent?.({ type: 'output', line: formatted });
+    }
+    return '';
+}
+function extractSessionId(line) {
+    const match = line.match(/\bsession(?:\s+id)?\s*[:=]\s*([a-zA-Z0-9._:-]+)/i);
+    return match?.[1];
+}
+function normalizeSkillNames(skills) {
+    if (!Array.isArray(skills))
+        return [];
+    return skills
+        .map((skill) => basename(skill).replace(/\.md$/i, '').trim())
+        .filter(Boolean);
+}
+function lastMeaningfulLine(output) {
+    return [...output].reverse().find((line) => line.trim() && !line.startsWith('[stderr]')) ?? '';
+}
+function stripAnsi(value) {
+    return value.replace(/\u001b\[[0-9;]*m/g, '');
+}
+//# sourceMappingURL=hermes-runtime.js.map

package/dist/agents/issue-task-controller.js

@@ -4,12 +4,13 @@ import * as channelService from '../services/channel.js';
 import * as issueService from '../services/issue.js';
 import * as taskService from '../services/task.js';
 import * as workspaceService from '../services/workspace.js';
-import { mapWorkflowToTaskDrafts, validateWorkflowForRun } from '../services/workflow.js';
+import { getWorkflow, mapWorkflowToTaskDrafts, validateWorkflowForRun } from '../services/workflow.js';
 import { createIssueFunctionTools } from '../services/builtin-tools/index.js';
 import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
 import { prependPersistentAgentContext } from '../services/persistent-agent-context.js';
 import { completeIssueAgentProgress, createIssueAgentProgress, createIssueAgentProgressTracker } from './issue-agent-progress.js';
 import { wrapOnEventWithHooks } from '../services/hook-engine.js';
+import { executeCommandNode } from '../services/workflow-command-runner.js';
 const ACTIVE_TASK_STATUSES = ['running', 'reviewing', 'retrying', 'waiting_review'];
 const activeIssueRuntimes = new Map();
 export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, ctx) {
@@ -137,6 +138,13 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
     if (task.status !== 'pending') {
         return;
     }
+    // Check if this task came from a command workflow node
+    const workflow = findWorkflowForIssue(workspaceId, issue);
+    const commandNode = findCommandNodeForTask(workflow, task);
+    if (commandNode) {
+        await runCommandTask(workspaceId, issueId, taskId, commandNode, ctx);
+        return;
+    }
     const taskAgentPreset = findAgentForTask(workspaceId, issue, task);
     if (!taskAgentPreset) {
         if (issueService.getById(workspaceId, issueId)?.status === 'error')
@@ -274,6 +282,48 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
         await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
     }
 }
+async function runCommandTask(workspaceId, issueId, taskId, commandNode, ctx) {
+    const task = taskService.getById(workspaceId, taskId);
+    if (!task || task.status !== 'pending')
+        return;
+    const runningTask = taskService.updateStatus(workspaceId, taskId, 'running');
+    if (!runningTask)
+        return;
+    broadcastTaskUpdate(ctx, runningTask, 'pending');
+    ctx.broadcast('task.output', { taskId, data: `$ ${commandNode.data.script.split('\n')[0]}${commandNode.data.script.includes('\n') ? ' ...' : ''}` });
+    const result = await executeCommandNode(workspaceId, commandNode);
+    ctx.broadcast('task.output', { taskId, data: result.stdout });
+    if (result.stderr) {
+        ctx.broadcast('task.output', { taskId, data: result.stderr });
+    }
+    if (!result.success) {
+        const failedTask = taskService.updateStatus(workspaceId, taskId, 'failed', {
+            result: {
+                success: false,
+                summary: `Command failed with exit code ${result.exitCode}`,
+                artifacts: [],
+                error: result.stderr || `Exit code: ${result.exitCode}`,
+            },
+        });
+        broadcastTaskUpdate(ctx, failedTask, 'running');
+        await handleTaskFailure(workspaceId, issueId, taskId, {
+            success: false,
+            summary: `Command failed with exit code ${result.exitCode}`,
+            artifacts: [],
+            error: result.stderr || `Exit code: ${result.exitCode}`,
+        }, ctx);
+        return;
+    }
+    const completedTask = taskService.complete(workspaceId, taskId, {
+        success: true,
+        summary: result.stdout.slice(-500) || 'Command completed',
+        artifacts: [],
+    });
+    broadcastTaskUpdate(ctx, completedTask, 'running');
+    if (issueService.getById(workspaceId, issueId)?.continuousRun !== false) {
+        await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
+    }
+}
 export async function continueIssueTaskScheduling(workspaceId, issueId, ctx) {
     await scheduleRunnableIssueTasks(workspaceId, issueId, ctx, { force: true });
 }
@@ -402,7 +452,7 @@ export function createTasksFromWorkflow(workspaceId, issueId, template, ctx) {
     });
 }
 function ensureWorkflowAgentsForRun(workspaceId, issue, template, ctx) {
-    const workflowAgentIds = [...new Set(template.nodes.map((node) => node.data.agentConfigId).filter(Boolean))];
+    const workflowAgentIds = [...new Set(template.nodes.filter((n) => n.type === 'agent').map((node) => node.data.agentConfigId).filter(Boolean))];
     const mergedMembers = [...new Set([...(issue.members ?? []), ...workflowAgentIds])];
     const membersChanged = mergedMembers.length !== (issue.members ?? []).length
         || mergedMembers.some((member, index) => member !== issue.members?.[index]);
@@ -502,6 +552,23 @@ function unregisterActiveIssueRuntime(workspaceId, issueId, agentId) {
 function issueRunKey(workspaceId, issueId) {
     return `${workspaceId}:${issueId}`;
 }
+function findWorkflowForIssue(workspaceId, issue) {
+    if (!issue.workflowId)
+        return null;
+    return getWorkflow(issue.workflowId);
+}
+function findCommandNodeForTask(workflow, task) {
+    if (!workflow)
+        return null;
+    if (task.agentConfigId)
+        return null;
+    for (const node of workflow.nodes) {
+        if (node.type === 'command' && (task.title === node.data.label || task.description?.startsWith('Command:'))) {
+            return node;
+        }
+    }
+    return null;
+}
 function broadcastTaskUpdate(ctx, task, from) {
     if (!task)
         return;