@agent-spaces/server 0.1.2 → 0.2.1

package/dist/adapters/claude-code-runtime/index.js

@@ -31,8 +31,11 @@ export class ClaudeCodeRuntime {
         const apiKey = this.adapterRun ? 'default' : this.config.apiKey;
         const model = getClaudeCodeModel(this.config);
         const additionalDirectories = normalizeAdditionalDirectories(cwd, options?.sandboxDirs);
+        const sdkMcpServers = normalizeMcpServers(options?.mcpServers, options?.functionTools);
+        const sdkMcpServerNames = Object.keys(sdkMcpServers ?? {});
         d(`starting | cwd=${cwd} model=${model ?? 'default'} targetModel=${this.config.model ?? 'default'} provider=${this.config.provider ?? 'default'} baseURL=${baseURL ?? 'default'} permissionMode=${permissionMode} maxTurns=${options?.maxTurns ?? '∞'} tools=claude_code mcpServers=${Object.keys(options?.mcpServers ?? {}).join(',') || '-'} skills=${skillNames.join(',') || '-'} configDir=${configDir ?? 'default'} sandboxDirs=${additionalDirectories.join(',') || '-'} claudeExecutable=${claudeExecutable ?? 'sdk-default'}`);
         d(`prompt: ${prompt.slice(0, 300)}${prompt.length > 300 ? '...' : ''}`);
+        d(`sdk mcp servers | ${sdkMcpServerNames.join(',') || '-'}`);
         try {
             const queryOptions = {
                 cwd,
@@ -40,7 +43,7 @@ export class ClaudeCodeRuntime {
                 maxTurns: options?.maxTurns,
                 pathToClaudeCodeExecutable: claudeExecutable,
                 tools: { type: 'preset', preset: 'claude_code' },
-                mcpServers: normalizeMcpServers(options?.mcpServers, options?.functionTools),
+                mcpServers: sdkMcpServers,
                 skills: skillNames,
                 managedSettings: {
                     strictPluginOnlyCustomization: ['mcp'],

package/dist/adapters/git.js

@@ -18,18 +18,6 @@ function getGit(workspace) {
     if (existing)
         return existing;
     const git = simpleGit(workspace.boundDirs[0], getGitOptions());
-    git.outputHandler((_binary, stdout, stderr) => {
-        stderr.on('data', (chunk) => {
-            const text = chunk.toString().trim();
-            if (text)
-                console.log(`[git:${workspace.id}] ${text}`);
-        });
-        stdout.on('data', (chunk) => {
-            const text = chunk.toString().trim();
-            if (text)
-                console.log(`[git:${workspace.id}] ${text}`);
-        });
-    });
     gitInstances.set(workspace.id, git);
     return git;
 }
@@ -288,19 +276,12 @@ export async function gitClone(targetDir, url, onProgress) {
         throw new Error(`目录 ${cloneDir} 已存在`);
     }
     const git = simpleGit(getGitOptions());
-    git.outputHandler((_binary, stdout, stderr) => {
+    git.outputHandler((_binary, _stdout, stderr) => {
         stderr.on('data', (chunk) => {
-            const text = chunk.toString();
-            console.log(`[git:clone] ${text.trim()}`);
-            const parsed = parseCloneProgress(text);
+            const parsed = parseCloneProgress(chunk.toString());
             if (parsed)
                 onProgress(parsed);
         });
-        stdout.on('data', (chunk) => {
-            const text = chunk.toString().trim();
-            if (text)
-                console.log(`[git:clone] ${text}`);
-        });
     });
     await git.clone(url, cloneDir, ['--progress']);
     return cloneDir;

package/dist/agents/issue-agent-runner.js

@@ -1,38 +1,52 @@
-import { runPlanner } from './planner-agent.js';
-import { syncIssueTasksAfterPlanning } from './issue-task-controller.js';
+import { scheduleRunnableIssueTasks, createTasksFromWorkflow } from './issue-task-controller.js';
 import * as issueService from '../services/issue.js';
-import * as issueCommentService from '../services/issue-comment.js';
 import * as taskService from '../services/task.js';
 import * as agentService from '../services/agent.js';
-export async function runIssueAutomation(workspaceId, issueId, ctx, options = {}) {
+import * as workflowService from '../services/workflow.js';
+export async function runIssueAutomation(workspaceId, issueId, ctx) {
     const issue = issueService.getById(workspaceId, issueId);
     if (!issue) {
         console.warn(`[issue-runner] issue not found workspaceId=${workspaceId} issueId=${issueId}`);
         return;
     }
+    // Workflow template branch
+    if (issue.workflowId) {
+        const template = workflowService.getWorkflow(issue.workflowId);
+        if (template) {
+            try {
+                createTasksFromWorkflow(workspaceId, issueId, template, ctx);
+                return;
+            }
+            catch (err) {
+                console.warn(`Workflow execution failed for issue ${issueId}: ${err.message}.`);
+                markIssueError(workspaceId, issueId, `Workflow execution failed: ${err.message}`, ctx);
+                return;
+            }
+        }
+        else {
+            console.warn(`Workflow template ${issue.workflowId} not found`);
+            markIssueError(workspaceId, issueId, `Workflow template ${issue.workflowId} not found`, ctx);
+            return;
+        }
+    }
     const tasks = taskService.list(workspaceId, issueId);
-    const shouldPlan = options.forcePlanner || tasks.length === 0;
-    if (shouldPlan) {
-        await runPlanner(workspaceId, issueId, ctx);
+    if (tasks.length > 0) {
+        await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
         return;
     }
-    await syncIssueTasksAfterPlanning(workspaceId, issueId, {
-        planSummary: latestUserCommentSummary(workspaceId, issueId),
-        planOutput: [],
-    }, ctx);
-}
-export function shouldForcePlannerFromMentions(workspaceId, mentions) {
-    const mentionedIds = new Set(mentions);
-    return (agentService.listPresets(workspaceId) ?? []).some((agent) => mentionedIds.has(agent.id) && agent.role === 'planner' && agent.enabled !== false);
+    console.warn(`[issue-runner] no workflow configured for issue workspaceId=${workspaceId} issueId=${issueId}`);
+    markIssueError(workspaceId, issueId, 'No workflow configured for issue', ctx);
 }
 export function hasActiveIssueAutomation(workspaceId) {
     return agentService.list(workspaceId).some((session) => session.status === 'active' &&
-        ['planner', 'custom', 'executor', 'reviewer'].includes(session.role));
+        !['scheduler', 'bot'].includes(session.role));
 }
-function latestUserCommentSummary(workspaceId, issueId) {
-    const latest = [...issueCommentService.listIssueComments(workspaceId, issueId)]
-        .reverse()
-        .find((comment) => comment.senderId === 'user');
-    return latest?.content ?? '';
+function markIssueError(workspaceId, issueId, message, ctx) {
+    const issue = issueService.getById(workspaceId, issueId);
+    const updated = issueService.markError(workspaceId, issueId, message);
+    if (!updated)
+        return;
+    ctx.broadcast('issue.status_changed', { issueId, from: issue?.status ?? 'draft', to: 'error' });
+    ctx.broadcast('issue.updated', updated);
 }
 //# sourceMappingURL=issue-agent-runner.js.map

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

@@ -3,7 +3,8 @@ import * as agentService from '../services/agent.js';
 import * as channelService from '../services/channel.js';
 import * as issueService from '../services/issue.js';
 import * as taskService from '../services/task.js';
-import { onExecutorComplete } from '../hooks/agent-hooks.js';
+import * as workspaceService from '../services/workspace.js';
+import { mapWorkflowToTaskDrafts, validateWorkflowForRun } from '../services/workflow.js';
 import { createIssueFunctionTools } from '../services/builtin-tools.js';
 import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
 import { completeIssueAgentProgress, createIssueAgentProgress, createIssueAgentProgressTracker } from './issue-agent-progress.js';
@@ -14,9 +15,9 @@ export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, c
         console.warn(`[issue-task-controller] issue not found workspaceId=${workspaceId} issueId=${issueId}`);
         return;
     }
-    const taskSyncPreset = findTaskCreatorForIssue(workspaceId, issue, input.plannerPreset);
+    const taskSyncPreset = findTaskSyncAgentForIssue(workspaceId, issue, input.plannerPreset);
     if (!taskSyncPreset) {
-        console.warn(`[issue-task-controller] no task creator or executor member found workspaceId=${workspaceId} issueId=${issueId}`);
+        console.warn(`[issue-task-controller] no task sync agent member found workspaceId=${workspaceId} issueId=${issueId}`);
         updateIssueStatus(workspaceId, issueId, 'error', ctx);
         return;
     }
@@ -28,7 +29,7 @@ export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, c
     ctx.broadcast('agent.status_changed', { agentId: taskSyncAgent.id, from: fromStatus, to: 'active' });
     ctx.broadcast('agent.output', { agentId: taskSyncAgent.id, data: `Syncing issue tasks: ${issueId}` });
     const startTime = Date.now();
-    const taskSyncWorkingDir = agentService.resolveWorkingDir(workspaceId, taskSyncPreset);
+    const taskSyncWorkingDir = resolveIssueWorkspaceRoot(workspaceId);
     const progress = createIssueAgentProgress(workspaceId, issue, taskSyncPreset, taskSyncAgent.id, {
         runtime: taskSyncPreset.runtimeKind,
         model: taskSyncPreset.modelId,
@@ -122,13 +123,16 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
         console.warn(`[issue-task-controller] missing issue/task workspaceId=${workspaceId} issueId=${issueId} taskId=${taskId}`);
         return;
     }
-    const executorPreset = findExecutorForTask(workspaceId, issue, task);
-    if (!executorPreset) {
+    if (task.status !== 'pending') {
+        return;
+    }
+    const taskAgentPreset = findAgentForTask(workspaceId, issue, task);
+    if (!taskAgentPreset) {
         const missingExecutorResult = {
             success: false,
-            summary: 'No executor agent configured in issue channel members',
+            summary: 'No runnable agent configured in issue channel members',
             artifacts: [],
-            error: 'No executor member found for issue channel',
+            error: 'No runnable agent member found for issue channel',
         };
         const failed = taskService.updateStatus(workspaceId, taskId, 'failed', {
             result: {
@@ -142,69 +146,69 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
         await handleTaskFailure(workspaceId, issueId, taskId, missingExecutorResult, ctx);
         return;
     }
-    const executor = agentService.getOrCreateSessionForConfig(workspaceId, executorPreset);
-    ctx.broadcast('agent.started', executor);
-    const executorFromStatus = executor.status;
-    agentService.updateStatus(workspaceId, executor.id, 'active');
-    issueService.addAgent(workspaceId, issueId, executorPreset.id);
-    ctx.broadcast('agent.status_changed', { agentId: executor.id, from: executorFromStatus, to: 'active' });
-    const runningTask = taskService.assignAgent(workspaceId, taskId, executor.id);
+    const taskAgent = agentService.getOrCreateSessionForConfig(workspaceId, taskAgentPreset);
+    ctx.broadcast('agent.started', taskAgent);
+    const agentFromStatus = taskAgent.status;
+    agentService.updateStatus(workspaceId, taskAgent.id, 'active');
+    issueService.addAgent(workspaceId, issueId, taskAgentPreset.id);
+    ctx.broadcast('agent.status_changed', { agentId: taskAgent.id, from: agentFromStatus, to: 'active' });
+    const runningTask = taskService.assignAgent(workspaceId, taskId, taskAgent.id);
     if (!runningTask) {
-        agentService.complete(workspaceId, executor.id, 'Task not found');
+        agentService.complete(workspaceId, taskAgent.id, 'Task not found');
         return;
     }
     broadcastTaskUpdate(ctx, runningTask, task.status);
-    agentService.assignTask(workspaceId, executor.id, taskId);
-    const runtime = createRuntimeForPreset(executorPreset);
-    const executorWorkingDir = agentService.resolveWorkingDir(workspaceId, executorPreset);
+    agentService.assignTask(workspaceId, taskAgent.id, taskId);
+    const runtime = createRuntimeForPreset(taskAgentPreset);
+    const agentWorkingDir = resolveIssueWorkspaceRoot(workspaceId);
     const startTime = Date.now();
-    const progress = createIssueAgentProgress(workspaceId, issue, executorPreset, executor.id, {
-        runtime: executorPreset.runtimeKind,
-        model: executorPreset.modelId,
+    const progress = createIssueAgentProgress(workspaceId, issue, taskAgentPreset, taskAgent.id, {
+        runtime: taskAgentPreset.runtimeKind,
+        model: taskAgentPreset.modelId,
         taskId,
-        phase: 'executor',
+        phase: taskAgentPreset.role,
     });
-    const executorTracker = createIssueAgentProgressTracker({
+    const agentTracker = createIssueAgentProgressTracker({
         workspaceId,
         issue,
         progress,
-        agentSessionId: executor.id,
-        workspaceRoot: executorWorkingDir,
+        agentSessionId: taskAgent.id,
+        workspaceRoot: agentWorkingDir,
         onOutput: (line) => {
-            ctx.broadcast('agent.output', { agentId: executor.id, data: line });
+            ctx.broadcast('agent.output', { agentId: taskAgent.id, data: line });
             ctx.broadcast('task.output', { taskId, data: line });
         },
     });
-    ctx.broadcast('agent.output', { agentId: executor.id, data: `Executing task: ${runningTask.title}` });
+    ctx.broadcast('agent.output', { agentId: taskAgent.id, data: `Executing task: ${runningTask.title}` });
     ctx.broadcast('agent.output', {
-        agentId: executor.id,
-        data: `[debug] executor agentConfigId=${executorPreset.id} taskAgentConfigId=${runningTask.agentConfigId || '(fallback)'} runtime=${executorPreset.runtimeKind ?? 'open-agent-sdk'}`,
+        agentId: taskAgent.id,
+        data: `[debug] workflow agentConfigId=${taskAgentPreset.id} role=${taskAgentPreset.role} taskAgentConfigId=${runningTask.agentConfigId || '(fallback)'} runtime=${taskAgentPreset.runtimeKind ?? 'open-agent-sdk'}`,
     });
-    const result = await runtime.execute(buildExecutorPrompt(issue, runningTask, executorWorkingDir), executorWorkingDir, {
+    const result = await runtime.execute(buildTaskAgentPrompt(issue, runningTask, taskAgentPreset, agentWorkingDir), agentWorkingDir, {
         maxTurns: 100,
-        mcpServers: agentService.getMcpServers(executorPreset.mcps),
-        functionTools: createCurrentIssueTools(workspaceId, issue, executorPreset),
-        skills: agentService.getAvailableSkillNames(agentService.getAgentConfigDir(workspaceId, executorPreset), executorPreset.skills),
-        configDir: agentService.getAgentConfigDir(workspaceId, executorPreset),
-        sandboxDirs: runningTask.sandboxDirs ?? executorPreset.sandboxDirs,
-        onEvent: executorTracker.handleEvent,
+        mcpServers: agentService.getMcpServers(taskAgentPreset.mcps),
+        functionTools: createCurrentIssueTools(workspaceId, issue, taskAgentPreset),
+        skills: agentService.getAvailableSkillNames(agentService.getAgentConfigDir(workspaceId, taskAgentPreset), taskAgentPreset.skills),
+        configDir: agentService.getAgentConfigDir(workspaceId, taskAgentPreset),
+        sandboxDirs: runningTask.sandboxDirs ?? taskAgentPreset.sandboxDirs,
+        onEvent: agentTracker.handleEvent,
     });
-    if (executorTracker.output.length === 0) {
+    if (agentTracker.output.length === 0) {
         for (const line of result.output) {
-            executorTracker.output.push(line);
-            ctx.broadcast('agent.output', { agentId: executor.id, data: line });
+            agentTracker.output.push(line);
+            ctx.broadcast('agent.output', { agentId: taskAgent.id, data: line });
             ctx.broadcast('task.output', { taskId, data: line });
         }
     }
-    completeIssueAgentProgress(workspaceId, issue, progress, result.summary, executorTracker.output, {
-        runtime: executorPreset.runtimeKind,
-        model: executorPreset.modelId,
+    completeIssueAgentProgress(workspaceId, issue, progress, result.summary, agentTracker.output, {
+        runtime: taskAgentPreset.runtimeKind,
+        model: taskAgentPreset.modelId,
         duration: Date.now() - startTime,
         messageStatus: result.success ? 'completed' : 'error',
-        parts: executorTracker.buildParts({
-            sessionId: executor.id,
-            workspaceRoot: executorWorkingDir,
-            model: executorPreset.modelId,
+        parts: agentTracker.buildParts({
+            sessionId: taskAgent.id,
+            workspaceRoot: agentWorkingDir,
+            model: taskAgentPreset.modelId,
             usage: result.usage,
             success: result.success,
             error: result.error,
@@ -214,21 +218,22 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
         const failedTask = taskService.updateStatus(workspaceId, taskId, 'failed', { result });
         broadcastTaskUpdate(ctx, failedTask, 'running');
     }
-    agentService.complete(workspaceId, executor.id, result.success ? undefined : result.error || result.summary, {
-        runtime: executorPreset.runtimeKind,
-        model: executorPreset.modelId,
+    agentService.complete(workspaceId, taskAgent.id, result.success ? undefined : result.error || result.summary, {
+        runtime: taskAgentPreset.runtimeKind,
+        model: taskAgentPreset.modelId,
         summary: result.summary,
-        output: executorTracker.output.length ? executorTracker.output : result.output,
+        output: agentTracker.output.length ? agentTracker.output : result.output,
         durationMs: Date.now() - startTime,
         usage: result.usage,
         costUsd: result.costUsd,
     });
-    ctx.broadcast('agent.completed', { agentId: executor.id, result });
+    ctx.broadcast('agent.completed', { agentId: taskAgent.id, result });
     if (!result.success) {
         await handleTaskFailure(workspaceId, issueId, taskId, result, ctx);
         return;
     }
-    await onExecutorComplete(workspaceId, taskId, issueId, result, ctx);
+    const completedTask = taskService.complete(workspaceId, taskId, result);
+    broadcastTaskUpdate(ctx, completedTask, 'running');
     await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
 }
 export async function continueIssueTaskScheduling(workspaceId, issueId, ctx) {
@@ -274,7 +279,7 @@ function createTaskSyncTools(workspaceId, issue, preset, ctx) {
         },
     ];
 }
-function replaceIssueTasksFromDrafts(workspaceId, issueId, ctx, drafts) {
+export function replaceIssueTasksFromDrafts(workspaceId, issueId, ctx, drafts) {
     const issue = requireIssue(workspaceId, issueId);
     const validAgentIds = new Set(getIssueMemberPresets(workspaceId, issue).map((agent) => agent.id));
     const normalizedDrafts = drafts.map((task) => ({
@@ -307,25 +312,62 @@ function replaceIssueTasksFromDrafts(workspaceId, issueId, ctx, drafts) {
         ctx.broadcast('issue.updated', issueTasks);
     return updated;
 }
-function findExecutorForTask(workspaceId, issue, task) {
-    const assignable = getIssueMemberPresets(workspaceId, issue);
-    if (task.agentConfigId) {
-        const assigned = assignable.find((agent) => agent.id === task.agentConfigId && agent.role === 'executor');
-        if (assigned)
-            return assigned;
+export function createTasksFromWorkflow(workspaceId, issueId, template, ctx) {
+    const issue = requireIssue(workspaceId, issueId);
+    ensureWorkflowAgentsForRun(workspaceId, issue, template, ctx);
+    // Validate all agents exist, are enabled, and are in channel members
+    const channel = channelService.getChannel(workspaceId, issue.channelId);
+    const memberAgentIds = new Set(channel?.members ?? []);
+    const validationError = validateWorkflowForRun(workspaceId, template, memberAgentIds);
+    if (validationError) {
+        throw new Error(`Workflow validation failed: ${validationError}`);
     }
-    return assignable.find((agent) => agent.role === 'executor') ?? null;
-}
-function findTaskCreatorForIssue(workspaceId, issue, plannerPreset) {
-    return findIssueMemberAgent(workspaceId, issue, 'custom')
-        ?? plannerPreset
-        ?? findIssueMemberAgent(workspaceId, issue, 'executor');
+    const drafts = mapWorkflowToTaskDrafts(template);
+    issueService.updateStatus(workspaceId, issueId, 'planned');
+    ctx.broadcast('issue.status_changed', { issueId, oldStatus: issue.status, newStatus: 'planned' });
+    replaceIssueTasksFromDrafts(workspaceId, issueId, ctx, drafts);
+    issueService.updateStatus(workspaceId, issueId, 'in_progress');
+    ctx.broadcast('issue.status_changed', { issueId, oldStatus: 'planned', newStatus: 'in_progress' });
+    ctx.broadcast('issue.updated', issueService.getById(workspaceId, issueId));
+    scheduleRunnableIssueTasks(workspaceId, issueId, ctx).catch((err) => {
+        console.error(`[workflow] task scheduling failed for issue ${issueId}:`, err);
+    });
 }
-function findIssueMemberAgent(workspaceId, issue, role) {
+function ensureWorkflowAgentsForRun(workspaceId, issue, template, ctx) {
+    const workflowAgentIds = [...new Set(template.nodes.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]);
+    if (membersChanged) {
+        issue.members = mergedMembers;
+        const savedIssue = issueService.save(workspaceId, issue);
+        ctx.broadcast('issue.updated', savedIssue);
+    }
     const channel = channelService.getChannel(workspaceId, issue.channelId);
-    if (!channel)
+    const mergedChannelMembers = [...new Set([...(channel?.members ?? []), ...workflowAgentIds])];
+    const channelMembersChanged = mergedChannelMembers.length !== (channel?.members ?? []).length
+        || mergedChannelMembers.some((member, index) => member !== channel?.members?.[index]);
+    if (channelMembersChanged) {
+        const updatedChannel = channelService.updateChannel(workspaceId, issue.channelId, { members: mergedChannelMembers });
+        if (updatedChannel)
+            ctx.broadcast('channel.updated', updatedChannel);
+    }
+}
+function findAgentForTask(workspaceId, issue, task) {
+    const assignable = getIssueMemberPresets(workspaceId, issue);
+    if (!task.agentConfigId)
         return null;
-    return agentService.findEnabledPresetByRoleInMembers(workspaceId, channel.members, role);
+    return assignable.find((agent) => agent.id === task.agentConfigId) ?? null;
+}
+function findTaskSyncAgentForIssue(workspaceId, issue, plannerPreset) {
+    const assignable = getIssueMemberPresets(workspaceId, issue);
+    const findByRole = (role) => assignable.find((agent) => agent.role === role) ?? null;
+    return plannerPreset
+        ?? findByRole('task_creator')
+        ?? findByRole('agent')
+        ?? findByRole('custom')
+        ?? findByRole('executor')
+        ?? assignable.find((agent) => !['scheduler', 'bot'].includes(agent.role)) ?? null;
 }
 function getIssueMemberPresets(workspaceId, issue) {
     const channel = channelService.getChannel(workspaceId, issue.channelId);
@@ -390,6 +432,9 @@ function createRuntimeForPreset(preset) {
         ...getThinkingRuntimeConfig(preset),
     });
 }
+function resolveIssueWorkspaceRoot(workspaceId) {
+    return workspaceService.getById(workspaceId)?.boundDirs?.[0] || process.cwd();
+}
 function buildTaskSyncPrompt(issue, input, workingDir) {
     return [
         'You are the issue task synchronization controller.',
@@ -400,9 +445,9 @@ function buildTaskSyncPrompt(issue, input, workingDir) {
         'Use ReplaceIssueTasks to write tasks. Do not rely on private planner-only context.',
         'Create coarse-grained, independently deliverable tasks. Default to a single implementation task for one cohesive issue.',
         'NEVER create review/audit/审查 tasks. The review phase is handled automatically by the system after all implementation tasks complete — do not include it as a task.',
-        'Split into multiple tasks only when the issue clearly requires major cross-area work, such as separate frontend and backend changes, database/API contract changes plus UI changes, or independent workstreams that different executors can complete without stepping on each other.',
+        'Split into multiple tasks only when the issue clearly requires major cross-area work, such as separate frontend and backend changes, database/API contract changes plus UI changes, or independent workstreams that different agents can complete without stepping on each other.',
         'Do not split by tiny implementation steps such as "update types", "add route", "adjust UI text", "run tests", or "write docs" unless that item is itself a substantial deliverable.',
-        'Each task description should include the relevant implementation scope and expected verification, so executor agents do not need a separate task for every small step.',
+        'Each task description should include the relevant implementation scope and expected verification, so agents do not need a separate task for every small step.',
         'Assign only valid agentConfigId values from ViewCurrentChannelIssue.validAgentConfigIds. Express task dependencies with dependsOnKeys only when one task truly cannot start before another completes.',
         '',
         'Current issue:',
@@ -417,8 +462,9 @@ function buildTaskSyncPrompt(issue, input, workingDir) {
         input.planOutput?.join('\n').trim(),
     ].filter(Boolean).join('\n');
 }
-function buildExecutorPrompt(issue, task, workingDir) {
+function buildTaskAgentPrompt(issue, task, preset, workingDir) {
     return [
+        preset.systemPrompt?.trim(),
         'Before executing, call ViewCurrentChannelIssue with the current channel id to load the latest shared issue context and comments.',
         `The current workspace working directory is: ${workingDir}`,
         'Create and modify project files under this working directory. Do not place deliverables in /tmp unless the task explicitly asks for temporary scratch output.',
@@ -432,9 +478,10 @@ function buildExecutorPrompt(issue, task, workingDir) {
         '',
         'Current task:',
         `- Task id: ${task.id}`,
+        `- Assigned agent: ${preset.name} (${preset.role})`,
         `- Title: ${task.title}`,
         `- Description: ${task.description}`,
-    ].join('\n');
+    ].filter(Boolean).join('\n');
 }
 function createCurrentIssueTools(workspaceId, issue, preset) {
     const channel = channelService.getChannel(workspaceId, issue.channelId);

package/dist/agents/planner-agent.js

@@ -6,7 +6,6 @@ import * as issueService from '../services/issue.js';
 import { createAgentRuntime } from '../adapters/agent-runtime.js';
 import * as wsService from '../services/workspace.js';
 import * as channelService from '../services/channel.js';
-import { syncIssueTasksAfterPlanning } from './issue-task-controller.js';
 import { completeIssueAgentProgress, createIssueAgentProgress, createIssueAgentProgressTracker } from './issue-agent-progress.js';
 import { createIssueFunctionTools } from '../services/builtin-tools.js';
 import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
@@ -18,11 +17,8 @@ export async function runPlanner(workspaceId, issueId, ctx) {
     }
     const plannerPreset = findIssueMemberAgent(workspaceId, issue, 'planner');
     if (!plannerPreset) {
-        console.warn(`[planner] no planner member found; continuing with task creator workspaceId=${workspaceId} issueId=${issueId} channelId=${issue.channelId}`);
-        await syncIssueTasksAfterPlanning(workspaceId, issueId, {
-            planSummary: '',
-            planOutput: [],
-        }, ctx);
+        console.warn(`[planner] no planner member found workspaceId=${workspaceId} issueId=${issueId} channelId=${issue.channelId}`);
+        markIssueError(workspaceId, issueId, issue.status, 'Planner agent is not configured', ctx);
         return;
     }
     const planner = agentService.getOrCreateSessionForConfig(workspaceId, plannerPreset);
@@ -105,12 +101,13 @@ export async function runPlanner(workspaceId, issueId, ctx) {
             ctx.broadcast('issue.updated', erroredIssue);
         return;
     }
-    await syncIssueTasksAfterPlanning(workspaceId, issueId, {
-        plannerPreset,
-        plannerSessionId: planner.id,
-        planSummary: planResult.summary,
-        planOutput: tracker.output.length ? tracker.output : planResult.output,
-    }, ctx);
+    markIssueError(workspaceId, issueId, 'planned', 'Planner pipeline is disabled; issue automation is workflow-driven', ctx);
+}
+function markIssueError(workspaceId, issueId, from, message, ctx) {
+    const erroredIssue = issueService.markError(workspaceId, issueId, message);
+    ctx.broadcast('issue.status_changed', { issueId, from, to: 'error' });
+    if (erroredIssue)
+        ctx.broadcast('issue.updated', erroredIssue);
 }
 function findIssueMemberAgent(workspaceId, issue, role) {
     const channel = channelService.getChannel(workspaceId, issue.channelId);

package/dist/app.js

@@ -13,12 +13,17 @@ import workspaceRouter from './routes/workspace.js';
 import fileRouter from './routes/file.js';
 import channelRouter from './routes/channel.js';
 import issueRouter from './routes/issue.js';
+import workflowRouter from './routes/workflow.js';
 import agentRouter from './routes/agent.js';
 import taskRouter from './routes/task.js';
 import gitRouter from './routes/git.js';
 import llmRouter from './routes/llm.js';
 import authRouter from './routes/auth.js';
 import folderRouter from './routes/folder.js';
+import commandRouter from './routes/command.js';
+import skillRouter from './routes/skill.js';
+import mcpRouter from './routes/mcp.js';
+import subscriptionRouter from './routes/subscription.js';
 import { authMiddleware, verifyToken } from './middleware/auth.js';
 import { handleConnection } from './ws/handler.js';
 import { startScheduler, stopScheduler } from './agents/scheduler-agent.js';
@@ -69,12 +74,17 @@ app.use('/api/workspaces', workspaceRouter);
 app.use('/api/workspaces/:id/files', fileRouter);
 app.use('/api/workspaces/:id/channels', channelRouter);
 app.use('/api/workspaces/:id/issues', issueRouter);
+app.use('/api/workflows', workflowRouter);
+app.use('/api/workspaces/:id/commands', commandRouter);
 app.use('/api/workspaces/:id/agents', agentRouter);
 app.use('/api/workspaces/:id/tasks', taskRouter);
 app.use('/api/workspaces/:id/git', gitRouter);
 app.use('/api/agents', agentRouter);
 app.use('/api', llmRouter);
 app.use('/api/folder', folderRouter);
+app.use('/api/skills', skillRouter);
+app.use('/api/mcps', mcpRouter);
+app.use('/api/subscriptions', subscriptionRouter);
 // Serve static web frontend in production (after API routes, before catch-all)
 const webDir = resolveRuntimeDir('web');
 if (existsSync(webDir)) {

package/dist/hooks/agent-hooks.js

@@ -1,19 +1,16 @@
 /**
- * Agent hooks: chain executor completion to reviewer processing.
+ * Agent hooks retained for legacy callers.
  */
-import { runReviewer } from '../agents/reviewer-agent.js';
 /**
- * Hook: executor complete triggers reviewer.
- * This is the core hook in the agent orchestration pipeline.
+ * Workflow task execution completes tasks directly. Review steps should be
+ * modeled as workflow nodes instead of this hardcoded hook.
  */
-export async function onExecutorComplete(workspaceId, taskId, issueId, result, ctx) {
+export async function onExecutorComplete(workspaceId, taskId, issueId, result, _ctx) {
     console.log(`[hook:onExecutorComplete] entered workspaceId=${workspaceId} taskId=${taskId} issueId=${issueId} success=${result.success} summary=${JSON.stringify(result.summary)}`);
     if (!result.success) {
         console.warn(`[hook:onExecutorComplete] task ${taskId} failed: ${result.error}`);
         return;
     }
-    console.log(`[hook:onExecutorComplete] triggering reviewer taskId=${taskId} issueId=${issueId}`);
-    await runReviewer(workspaceId, taskId, issueId, result, ctx);
-    console.log(`[hook:onExecutorComplete] reviewer completed taskId=${taskId} issueId=${issueId}`);
+    console.log(`[hook:onExecutorComplete] reviewer hook skipped; workflow controls task order taskId=${taskId} issueId=${issueId}`);
 }
 //# sourceMappingURL=agent-hooks.js.map

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-spaces/server",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "type": "module",
   "main": "app.js",
   "packageManager": "pnpm@10.17.1",