@agent-spaces/server 0.3.62 → 0.3.64

package/dist/adapters/agent-runtime-types.js

@@ -1,7 +1,19 @@
+import { resolveOutputStyleContent } from '../services/output-style.js';
 export function summarizeResult(text) {
     const normalized = text.trim().replace(/\s+/g, ' ');
     if (!normalized)
         return 'Completed agent execution';
     return normalized.length > 160 ? `${normalized.slice(0, 157)}...` : normalized;
 }
+export function appendOutputStyleToPrompt(prompt, outputStyle) {
+    const style = resolveOutputStyleContent(outputStyle)?.trim();
+    if (!style)
+        return prompt;
+    return [
+        prompt.trimEnd(),
+        '',
+        'Output style instructions:',
+        style,
+    ].join('\n');
+}
 //# sourceMappingURL=agent-runtime-types.js.map

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

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { summarizeResult } from '../agent-runtime-types.js';
+import { prepareClaudeOutputStyleFile } from '../../services/output-style.js';
 import { normalizeAdditionalDirectories, normalizePermissionMode, normalizeSkillNames, prepareConfigDir, resolveBundledClaudeExecutable, buildEnv, normalizeMcpServers } from './sdk-config.js';
 import { startClaudeAdapterIfNeeded, getClaudeCodeModel } from './adapter-pool.js';
 import { extractThinkingEvents, extractToolUseEvents, extractToolResultEvent, logToolDebug, formatMessage, isAskUserQuestionAutoResult, countUsageTokens, formatUsageLine, normalizeUsage } from './message-format.js';
@@ -25,6 +26,7 @@ export class ClaudeCodeRuntime {
         if (configDir)
             prepareConfigDir(configDir, agentDir);
         const skillNames = normalizeSkillNames(options?.skills, configDir);
+        const outputStyleFile = configDir ? prepareClaudeOutputStyleFile(configDir, options?.outputStyle) : undefined;
         const claudeExecutable = resolveBundledClaudeExecutable();
         this.adapterRun = await startClaudeAdapterIfNeeded(this.config);
         const baseURL = this.adapterRun?.url ?? this.config.baseURL;
@@ -46,6 +48,7 @@ export class ClaudeCodeRuntime {
                 tools: { type: 'preset', preset: 'claude_code' },
                 mcpServers: sdkMcpServers,
                 skills: skillNames,
+                outputStyle: outputStyleFile,
                 managedSettings: {
                     strictPluginOnlyCustomization: ['mcp'],
                 },

package/dist/adapters/claude-code-runtime/message-format.js

@@ -24,7 +24,7 @@ export function formatMessage(message) {
         case 'tool_progress':
             return `${message.tool_name} running (${message.elapsed_time_seconds}s)`;
         case 'tool_use_summary':
-            return message.summary;
+            return null;
         default:
             return null;
     }

package/dist/adapters/codex-runtime.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { basename, extname, join } from 'node:path';
 import { Codex } from '@openai/codex-sdk';
-import { summarizeResult } from './agent-runtime-types.js';
+import { appendOutputStyleToPrompt, summarizeResult } from './agent-runtime-types.js';
 /**
  * Runtime backed by OpenAI's Codex SDK.
  * Spawns the bundled Codex CLI and consumes its structured JSONL event stream.
@@ -48,7 +48,7 @@ export class CodexRuntime {
             const thread = options?.resumeSessionId
                 ? codex.resumeThread(options.resumeSessionId, threadOptions)
                 : codex.startThread(threadOptions);
-            const { events } = await thread.runStreamed(prompt, {
+            const { events } = await thread.runStreamed(appendOutputStyleToPrompt(prompt, options?.outputStyle), {
                 signal: this.abortController.signal,
             });
             let resultText = '';

package/dist/adapters/git.js

@@ -36,26 +36,36 @@ function getGit(workspace) {
 }
 function mapStatus(raw) {
     const files = [];
+    const addOrUpdate = (file) => {
+        const existing = files.find(x => x.path === file.path);
+        if (existing) {
+            Object.assign(existing, file, {
+                staged: existing.staged || file.staged,
+                conflicted: existing.conflicted || file.conflicted,
+                status: file.conflicted ? 'conflicted' : existing.status,
+            });
+        }
+        else {
+            files.push(file);
+        }
+    };
     for (const f of raw.staged) {
-        files.push({ path: f, status: mapStatusCode(raw.files.find(r => r.path === f)?.index) });
+        addOrUpdate({ path: f, status: mapStatusCode(raw.files.find(r => r.path === f)?.index), staged: true });
     }
     for (const f of raw.modified) {
-        if (!files.find(x => x.path === f)) {
-            files.push({ path: f, status: 'modified' });
-        }
+        addOrUpdate({ path: f, status: 'modified' });
     }
     for (const f of raw.not_added) {
-        files.push({ path: f, status: 'untracked' });
+        addOrUpdate({ path: f, status: 'untracked' });
     }
     for (const f of raw.deleted) {
-        if (!files.find(x => x.path === f)) {
-            files.push({ path: f, status: 'deleted' });
-        }
+        addOrUpdate({ path: f, status: 'deleted' });
     }
     for (const f of raw.created) {
-        if (!files.find(x => x.path === f)) {
-            files.push({ path: f, status: 'added' });
-        }
+        addOrUpdate({ path: f, status: 'added', staged: raw.staged.includes(f) });
+    }
+    for (const f of raw.conflicted) {
+        addOrUpdate({ path: f, status: 'conflicted', conflicted: true });
     }
     return {
         branch: raw.current || 'HEAD',
@@ -67,6 +77,73 @@ function mapStatus(raw) {
         deletions: 0,
     };
 }
+async function getUpstreamRef(git, branch) {
+    const upstream = await git.raw(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'])
+        .then(v => v.trim())
+        .catch(() => '');
+    if (upstream)
+        return upstream;
+    if (!branch || branch === 'HEAD')
+        return null;
+    const originBranch = `origin/${branch}`;
+    const hasOriginBranch = await git.raw(['rev-parse', '--verify', '--quiet', originBranch])
+        .then(() => true)
+        .catch(() => false);
+    return hasOriginBranch ? originBranch : null;
+}
+function splitConflictSides(content) {
+    const left = [];
+    const right = [];
+    let mode = 'both';
+    let hasConflict = false;
+    for (const line of content.split('\n')) {
+        if (line.startsWith('<<<<<<< ')) {
+            hasConflict = true;
+            mode = 'left';
+            continue;
+        }
+        if (line.startsWith('=======')) {
+            mode = 'right';
+            continue;
+        }
+        if (line.startsWith('>>>>>>> ')) {
+            mode = 'both';
+            continue;
+        }
+        if (mode === 'both' || mode === 'left')
+            left.push(line);
+        if (mode === 'both' || mode === 'right')
+            right.push(line);
+    }
+    return { left: left.join('\n'), right: right.join('\n'), hasConflict };
+}
+async function buildWorkingDiff(git, rootDir, filePath, conflicted = false) {
+    const binary = isBinaryPath(filePath);
+    const workingContent = binary ? '' : await readFile(join(rootDir, filePath), 'utf-8').catch(() => '');
+    if (!binary && conflicted) {
+        const conflict = splitConflictSides(workingContent);
+        if (conflict.hasConflict) {
+            return {
+                path: filePath,
+                oldContent: conflict.left,
+                newContent: conflict.right,
+                isBinary: false,
+                isNew: false,
+                isDeleted: false,
+                isConflict: true,
+            };
+        }
+    }
+    const oldContent = binary ? '' : await git.show([`HEAD:${filePath}`]).catch(() => '');
+    return {
+        path: filePath,
+        oldContent,
+        newContent: workingContent,
+        isBinary: binary,
+        isNew: !oldContent,
+        isDeleted: !workingContent,
+    };
+}
 function mapStatusCode(code) {
     switch (code) {
         case 'A': return 'added';
@@ -83,6 +160,19 @@ export async function gitStatus(workspaceId) {
     const git = getGit(ws);
     const raw = await git.status();
     const result = mapStatus(raw);
+    try {
+        const headHash = await git.revparse(['--short', 'HEAD']);
+        result.headHash = headHash.trim();
+    }
+    catch { }
+    try {
+        const upstream = await getUpstreamRef(git, result.branch);
+        if (upstream) {
+            const remoteHeadHash = await git.revparse(['--short', upstream]);
+            result.remoteHeadHash = remoteHeadHash.trim();
+        }
+    }
+    catch { }
     if (!result.clean) {
         try {
             // Tracked changes: modified/deleted/renamed
@@ -122,66 +212,73 @@ export async function gitDiff(workspaceId, filePath) {
         throw new Error('Workspace not found');
     const git = getGit(ws);
     const diffs = [];
+    const status = await git.status();
+    const conflicted = new Set(status.conflicted);
     if (filePath) {
-        const diff = await git.diff([filePath]);
-        const oldContent = await git.show([`HEAD:${filePath}`]).catch(() => '');
-        const newContent = await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${filePath}`, 'utf-8')).catch(() => '');
-        diffs.push({
-            path: filePath,
-            oldContent: isBinaryPath(filePath) ? '' : oldContent,
-            newContent: isBinaryPath(filePath) ? '' : newContent,
-            isBinary: isBinaryPath(filePath),
-            isNew: !oldContent,
-            isDeleted: !newContent,
-        });
+        diffs.push(await buildWorkingDiff(git, ws.boundDirs[0], filePath, conflicted.has(filePath)));
     }
     else {
         const raw = await git.diff(['--name-only']);
-        const files = raw.split('\n').filter(Boolean);
+        const cachedRaw = await git.diff(['--cached', '--name-only']);
+        const files = Array.from(new Set([
+            ...raw.split('\n').filter(Boolean),
+            ...cachedRaw.split('\n').filter(Boolean),
+            ...status.not_added,
+            ...status.conflicted,
+        ]));
         for (const f of files) {
-            const binary = isBinaryPath(f);
-            const oldContent = binary ? '' : await git.show([`HEAD:${f}`]).catch(() => '');
-            const newContent = binary ? '' : await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
-            diffs.push({
-                path: f,
-                oldContent,
-                newContent,
-                isBinary: binary,
-                isNew: !oldContent,
-                isDeleted: !newContent,
-            });
-        }
-        // Also check untracked (staged new files)
-        const status = await git.status();
-        for (const f of status.not_added) {
-            const binary = isBinaryPath(f);
-            const newContent = binary ? '' : await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
-            if (newContent || binary) {
-                diffs.push({
-                    path: f,
-                    oldContent: '',
-                    newContent: binary ? '' : newContent,
-                    isBinary: binary,
-                    isNew: true,
-                    isDeleted: false,
-                });
-            }
+            diffs.push(await buildWorkingDiff(git, ws.boundDirs[0], f, conflicted.has(f)));
         }
     }
     return diffs;
 }
+export async function gitStage(workspaceId, filePath) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.add(filePath);
+}
+export async function gitUnstage(workspaceId, filePath) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.raw(['restore', '--staged', '--', filePath]).catch(async () => {
+        await git.raw(['reset', 'HEAD', '--', filePath]);
+    });
+}
+export async function gitResolveFile(workspaceId, filePath, content, stage = true) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await writeFile(join(ws.boundDirs[0], filePath), content, 'utf-8');
+    if (stage)
+        await git.add(filePath);
+}
 export async function gitLog(workspaceId, maxCount = 50) {
     const ws = getWorkspace(workspaceId);
     if (!ws)
         throw new Error('Workspace not found');
     const git = getGit(ws);
-    const log = await git.log({ maxCount });
-    return log.all.map(entry => ({
-        hash: entry.hash.substring(0, 7),
-        message: entry.message,
-        author: entry.author_name,
-        date: entry.date,
-    }));
+    const status = await git.status();
+    const upstream = await getUpstreamRef(git, status.current || 'HEAD');
+    const refs = upstream ? ['HEAD', upstream] : ['HEAD'];
+    const pretty = '%H%x1f%s%x1f%an%x1f%aI%x1e';
+    const raw = await git.raw(['log', `--max-count=${maxCount}`, `--pretty=format:${pretty}`, ...refs]);
+    return raw.split('\x1e')
+        .map(record => record.trim())
+        .filter(Boolean)
+        .map(record => {
+        const [hash = '', message = '', author = '', date = ''] = record.split('\x1f');
+        return {
+            hash: hash.substring(0, 7),
+            message,
+            author,
+            date,
+        };
+    });
 }
 export async function gitCommit(workspaceId, message) {
     const ws = getWorkspace(workspaceId);
@@ -274,6 +371,13 @@ export async function gitPush(workspaceId) {
         throw new Error('No remote repository configured. Please add a remote first.');
     await git.push('origin', branch);
 }
+export async function gitFetch(workspaceId) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.fetch('origin');
+}
 export async function gitPull(workspaceId) {
     const ws = getWorkspace(workspaceId);
     if (!ws)

package/dist/adapters/langchain-runtime.js

@@ -1,6 +1,6 @@
 import { createAgent, initChatModel, tool } from 'langchain';
 import { z } from 'zod';
-import { summarizeResult } from './agent-runtime-types.js';
+import { appendOutputStyleToPrompt, summarizeResult } from './agent-runtime-types.js';
 /**
  * Runtime backed by LangChain.js.
  * Uses LangChain's provider-neutral createAgent API and adapts Agent Spaces tools.
@@ -27,7 +27,7 @@ export class LangChainRuntime {
                 tools: buildLangChainTools(options?.functionTools, output, options),
                 systemPrompt: options?.systemPrompt,
             });
-            const result = await agent.invoke({ messages: [{ role: 'user', content: prompt }] }, {
+            const result = await agent.invoke({ messages: [{ role: 'user', content: appendOutputStyleToPrompt(prompt, options?.outputStyle) }] }, {
                 signal: this.abortController?.signal,
                 recursionLimit: options?.maxTurns ? Math.max(2, options.maxTurns * 2 + 1) : undefined,
             });

package/dist/adapters/open-agent-sdk-runtime.js

@@ -1,5 +1,5 @@
 import { createAgent } from '@codeany/open-agent-sdk';
-import { summarizeResult } from './agent-runtime-types.js';
+import { appendOutputStyleToPrompt, summarizeResult } from './agent-runtime-types.js';
 /**
  * Runtime backed by @codeany/open-agent-sdk.
  * Runs the agent loop in-process with the SDK's built-in tools.
@@ -35,7 +35,7 @@ export class OpenAgentSdkRuntime {
             });
             d('agent created, sending prompt...');
             d('tool debug | open-agent-sdk runtime does not expose per-tool stream events through prompt(); only final text/usage is available here');
-            const result = await this.agent.prompt(prompt);
+            const result = await this.agent.prompt(appendOutputStyleToPrompt(prompt, options?.outputStyle));
             const elapsed = Date.now() - startTime;
             const inputTokens = result.usage.input_tokens;
             const outputTokens = result.usage.output_tokens;

package/dist/agents/agent-designer.js

@@ -28,13 +28,36 @@ export async function generateAgentDesign(userPrompt) {
         apiBase: maskUrl(config.apiBase),
         promptLength: prompt.length,
     });
-    const content = await requestDesign(config, prompt);
+    const content = await requestText(config, buildDesignSystemPrompt(config), prompt);
     console.info('[agent-designer] model text extracted', {
         length: content.length,
         preview: content.slice(0, 500),
     });
     return normalizeDesign(parseJsonObject(content));
 }
+export async function optimizeAgentPrompt(userPrompt, currentPrompt) {
+    const prompt = userPrompt.trim();
+    if (!prompt)
+        throw new Error('prompt is required');
+    const config = resolveModelConfig();
+    if (!config) {
+        throw new Error(`Configure model settings for ${AGENT_GENERATOR_PRESET_ID} before optimizing prompts.`);
+    }
+    console.info('[agent-designer] optimizing agent prompt', {
+        agentId: AGENT_GENERATOR_PRESET_ID,
+        provider: config.modelProvider ?? inferProvider(config.apiBase),
+        modelId: config.modelId,
+        apiBase: maskUrl(config.apiBase),
+        promptLength: prompt.length,
+        currentPromptLength: currentPrompt.trim().length,
+    });
+    const content = await requestText(config, buildOptimizationSystemPrompt(config), buildPromptOptimizationUserPrompt(prompt, currentPrompt));
+    console.info('[agent-designer] optimized prompt received', {
+        length: content.length,
+        preview: content.slice(0, 500),
+    });
+    return { systemPrompt: normalizePrompt(content) };
+}
 function resolveModelConfig() {
     const preset = readAgentTemplate(AGENT_GENERATOR_PRESET_ID);
     if (preset?.apiBase && preset.apiKey && preset.modelId) {
@@ -51,14 +74,17 @@ function resolveModelConfig() {
     return null;
 }
 async function requestDesign(config, userPrompt) {
+    return requestText(config, buildDesignSystemPrompt(config), userPrompt);
+}
+async function requestText(config, systemPrompt, userPrompt) {
     const provider = config.modelProvider ?? inferProvider(config.apiBase);
     if (provider === 'anthropic-messages')
-        return requestAnthropic(config, userPrompt);
+        return requestAnthropic(config, systemPrompt, userPrompt);
     if (provider === 'gemini-generate-content')
-        return requestGemini(config, userPrompt);
-    return requestOpenAICompatible(config, userPrompt, provider === 'openai-responses' || provider === 'openai-responses-to-anthropic-messages');
+        return requestGemini(config, systemPrompt, userPrompt);
+    return requestOpenAICompatible(config, systemPrompt, userPrompt, provider === 'openai-responses' || provider === 'openai-responses-to-anthropic-messages');
 }
-async function requestOpenAICompatible(config, userPrompt, useResponsesApi) {
+async function requestOpenAICompatible(config, systemPrompt, userPrompt, useResponsesApi) {
     const url = joinUrl(config.apiBase, useResponsesApi ? '/responses' : '/chat/completions');
     const response = await fetch(url, {
         method: 'POST',
@@ -69,14 +95,14 @@ async function requestOpenAICompatible(config, userPrompt, useResponsesApi) {
         body: JSON.stringify(useResponsesApi
             ? {
                 model: config.modelId,
-                input: `${buildSystemPrompt(config)}\n\nUser request:\n${userPrompt}`,
+                input: `${systemPrompt}\n\nUser request:\n${userPrompt}`,
                 temperature: config.temperature ?? 0.2,
                 max_output_tokens: config.maxTokens,
             }
             : {
                 model: config.modelId,
                 messages: [
-                    { role: 'system', content: buildSystemPrompt(config) },
+                    { role: 'system', content: systemPrompt },
                     { role: 'user', content: userPrompt },
                 ],
                 temperature: config.temperature ?? 0.2,
@@ -88,7 +114,7 @@ async function requestOpenAICompatible(config, userPrompt, useResponsesApi) {
         throw new Error(body.error || `Agent design generation failed with status ${response.status}`);
     return body.text;
 }
-async function requestAnthropic(config, userPrompt) {
+async function requestAnthropic(config, systemPrompt, userPrompt) {
     const response = await fetch(getAnthropicMessagesUrl(config.apiBase), {
         method: 'POST',
         headers: {
@@ -98,7 +124,7 @@ async function requestAnthropic(config, userPrompt) {
         },
         body: JSON.stringify({
             model: config.modelId,
-            system: buildSystemPrompt(config),
+            system: systemPrompt,
             messages: [{ role: 'user', content: userPrompt }],
             max_tokens: config.maxTokens ?? 4096,
             temperature: config.temperature ?? 0.2,
@@ -109,7 +135,7 @@ async function requestAnthropic(config, userPrompt) {
         throw new Error(body.error || `Agent design generation failed with status ${response.status}`);
     return body.text;
 }
-async function requestGemini(config, userPrompt) {
+async function requestGemini(config, systemPrompt, userPrompt) {
     const response = await fetch(joinUrl(config.apiBase, `/models/${encodeURIComponent(config.modelId)}:generateContent`), {
         method: 'POST',
         headers: {
@@ -117,7 +143,7 @@ async function requestGemini(config, userPrompt) {
             'Content-Type': 'application/json',
         },
         body: JSON.stringify({
-            systemInstruction: { parts: [{ text: buildSystemPrompt(config) }] },
+            systemInstruction: { parts: [{ text: systemPrompt }] },
             contents: [{ role: 'user', parts: [{ text: userPrompt }] }],
             generationConfig: {
                 temperature: config.temperature ?? 0.2,
@@ -130,12 +156,40 @@ async function requestGemini(config, userPrompt) {
         throw new Error(body.error || `Agent design generation failed with status ${response.status}`);
     return body.text;
 }
-function buildSystemPrompt(config) {
+function buildDesignSystemPrompt(config) {
     const custom = config.systemPrompt?.trim();
     if (!custom)
         return SYSTEM_PROMPT;
     return `${custom}\n\n${SYSTEM_PROMPT}`;
 }
+function buildOptimizationSystemPrompt(config) {
+    const custom = config.systemPrompt?.trim();
+    const base = [
+        'You optimize agent system prompts.',
+        'Return only the rewritten prompt text.',
+        'Do not wrap the result in markdown fences.',
+        'Do not add commentary, bullets about the process, or any explanation outside the prompt.',
+        'Keep the prompt actionable, concise, and directly usable as a system prompt.',
+        'Preserve important constraints from the current prompt unless the user request clearly asks to change them.',
+    ].join('\n');
+    if (!custom)
+        return base;
+    return `${custom}\n\n${base}`;
+}
+function buildPromptOptimizationUserPrompt(userRequest, currentPrompt) {
+    return [
+        'User request:',
+        userRequest,
+        '',
+        'Current system prompt:',
+        currentPrompt.trim() || '(empty)',
+        '',
+        'Rewrite the current system prompt according to the user request. Return only the final prompt text.',
+    ].join('\n');
+}
+function normalizePrompt(text) {
+    return text.trim().replace(/^```(?:markdown|md)?\s*/i, '').replace(/\s*```$/i, '');
+}
 async function readResponseBody(response) {
     const raw = await response.text();
     if (!raw)

package/dist/agents/commit-agent.js

@@ -42,6 +42,7 @@ export async function runCommitAgent(workspaceId) {
     }), workingDir, {
         maxTurns: 1,
         systemPrompt,
+        outputStyle: commitAgent.outputStyle,
     });
     agentService.complete(workspaceId, session.id, result.success ? undefined : result.error, {
         runtime: commitAgent.runtimeKind,

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

@@ -74,7 +74,9 @@ export function createIssueAgentProgress(workspaceId, issue, preset, agentSessio
     return { message, comment };
 }
 export function completeIssueAgentProgress(workspaceId, issue, progress, summary, output, metadata) {
-    const content = output.join('\n').trim() || summary;
+    const parts = metadata.parts;
+    const finalText = [...(parts ?? [])].reverse().find((part) => part.type === 'text')?.text.trim();
+    const content = finalText || summary.trim() || output.join('\n').trim();
     if (!content.trim())
         return;
     const message = messageService.updateMessage(workspaceId, issue.channelId, progress.message.id, {
@@ -88,7 +90,7 @@ export function completeIssueAgentProgress(workspaceId, issue, progress, summary
             summary,
             duration: metadata.duration,
         },
-        parts: metadata.parts,
+        parts,
     });
     if (message)
         broadcastToWorkspace(workspaceId, 'channel.message.updated', message);

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

@@ -9,6 +9,11 @@ export async function runIssueAutomation(workspaceId, issueId, ctx) {
         console.warn(`[issue-runner] issue not found workspaceId=${workspaceId} issueId=${issueId}`);
         return;
     }
+    const tasks = taskService.list(workspaceId, issueId);
+    if (tasks.length > 0) {
+        await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
+        return;
+    }
     // Workflow template branch
     if (issue.workflowId) {
         const template = workflowService.getWorkflow(issue.workflowId);
@@ -29,11 +34,6 @@ export async function runIssueAutomation(workspaceId, issueId, ctx) {
             return;
         }
     }
-    const tasks = taskService.list(workspaceId, issueId);
-    if (tasks.length > 0) {
-        await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
-        return;
-    }
     console.warn(`[issue-runner] no workflow configured for issue workspaceId=${workspaceId} issueId=${issueId}`);
 }
 export function hasActiveIssueAutomation(workspaceId) {