@agent-spaces/server 0.3.61 → 0.3.63

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'],
                 },
@@ -84,9 +87,12 @@ export class ClaudeCodeRuntime {
                     options?.onEvent?.({ type: 'session', sessionId });
                 }
                 const toolUses = extractToolUseEvents(message);
+                let sawAskUserQuestion = false;
                 for (const toolUse of toolUses) {
                     if (toolUse.name === 'AskUserQuestion') {
                         pendingAskUserQuestionToolIds.add(toolUse.id);
+                        waitingForUserAnswer = true;
+                        sawAskUserQuestion = true;
                     }
                 }
                 const toolResult = extractToolResultEvent(message);
@@ -133,8 +139,24 @@ export class ClaudeCodeRuntime {
                         error = message.errors.join('\n') || message.subtype;
                     }
                 }
+                if (sawAskUserQuestion)
+                    break;
             }
             const elapsed = Date.now() - startTime;
+            if (waitingForUserAnswer) {
+                d(`waiting for user answer ${elapsed}ms | turns=${turns} tokens=${tokenCount}`);
+                if (usageLine)
+                    output.push(usageLine);
+                return {
+                    success: true,
+                    summary: 'Waiting for user answer',
+                    artifacts: [],
+                    output,
+                    usage,
+                    costUsd,
+                    sessionId,
+                };
+            }
             if (!sawResult) {
                 const runtimeError = extractRuntimeError([...stderrLines, ...output])
                     || 'Claude Code execution stopped before reporting a final result';

package/dist/adapters/claude-code-runtime/sdk-config.js

@@ -1,6 +1,6 @@
-import { copyFileSync, existsSync, mkdirSync, readdirSync, rmSync, statSync } from 'node:fs';
+import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { extname, isAbsolute, resolve } from 'node:path';
+import { basename, extname, isAbsolute, resolve } from 'node:path';
 import { join } from 'node:path';
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicBridgeProvider } from './types.js';
@@ -125,7 +125,7 @@ export function normalizeSkillNames(skills, configDir) {
     if (!Array.isArray(skills))
         return [];
     return skills
-        .map((skill) => skill.trim().replace(/\.md$/i, ''))
+        .map(sanitizeSkillName)
         .filter((skill) => Boolean(skill) && hasSkillContent(skill, configDir));
 }
 export function prepareConfigDir(configDir, agentDir) {
@@ -138,19 +138,43 @@ export function prepareConfigDir(configDir, agentDir) {
     mkdirSync(targetSkillsDir, { recursive: true });
     if (!existsSync(sourceSkillsDir))
         return;
-    for (const file of readdirSync(sourceSkillsDir)) {
-        if (extname(file).toLowerCase() !== '.md')
+    for (const entry of readdirSync(sourceSkillsDir)) {
+        const source = join(sourceSkillsDir, entry);
+        const sourceStat = statSync(source);
+        if (sourceStat.isDirectory()) {
+            const skillName = sanitizeSkillName(entry);
+            if (!skillName)
+                continue;
+            const sourceSkillFile = join(source, 'SKILL.md');
+            const targetSkillDir = join(targetSkillsDir, skillName);
+            if (existsSync(sourceSkillFile) && statSync(sourceSkillFile).size > 0) {
+                cpSync(source, targetSkillDir, { recursive: true, force: true });
+            }
             continue;
-        copyFileSync(join(sourceSkillsDir, file), join(targetSkillsDir, file));
+        }
+        if (!sourceStat.isFile() || extname(entry).toLowerCase() !== '.md')
+            continue;
+        const skillName = sanitizeSkillName(entry);
+        if (!skillName || sourceStat.size === 0)
+            continue;
+        const targetSkillDir = join(targetSkillsDir, skillName);
+        mkdirSync(targetSkillDir, { recursive: true });
+        writeFileSync(join(targetSkillDir, 'SKILL.md'), readFileSync(source, 'utf-8'), 'utf-8');
+        copyFileSync(source, join(targetSkillsDir, `${skillName}.md`));
     }
 }
 function hasSkillContent(skill, configDir) {
     if (!configDir)
         return true;
-    const skillFile = join(configDir, 'skills', `${skill}.md`);
-    if (!existsSync(skillFile))
-        return false;
-    return statSync(skillFile).size > 0;
+    const skillFile = join(configDir, 'skills', skill, 'SKILL.md');
+    if (existsSync(skillFile) && statSync(skillFile).size > 0)
+        return true;
+    const legacySkillFile = join(configDir, 'skills', `${skill}.md`);
+    return existsSync(legacySkillFile) && statSync(legacySkillFile).size > 0;
+}
+function sanitizeSkillName(name) {
+    const raw = basename(name).replace(/\.md$/i, '').trim();
+    return raw.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
 }
 export function normalizePermissionMode(permissionMode) {
     if (permissionMode === 'default' ||

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

@@ -3,6 +3,19 @@ import { getWorkspace } from '../storage/workspace-store.js';
 import { writeFile, readFile, mkdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join, basename } from 'node:path';
+const BINARY_EXTENSIONS = new Set([
+    'png', 'jpg', 'jpeg', 'gif', 'bmp', 'ico', 'webp', 'svg', 'tiff', 'tif',
+    'mp3', 'mp4', 'wav', 'avi', 'mov', 'mkv', 'flv', 'wmv', 'webm',
+    'zip', 'tar', 'gz', 'bz2', 'xz', '7z', 'rar', 'dmg', 'iso',
+    'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx',
+    'woff', 'woff2', 'ttf', 'otf', 'eot',
+    'exe', 'dll', 'so', 'dylib', 'bin', 'dat',
+    'sqlite', 'db', 'pyc', 'o', 'obj', 'class', 'jar', 'wasm',
+]);
+function isBinaryPath(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    return ext ? BINARY_EXTENSIONS.has(ext) : true;
+}
 const gitInstances = new Map();
 function getGitOptions() {
     const proxy = process.env.HTTPS_PROXY || process.env.https_proxy
@@ -115,9 +128,9 @@ export async function gitDiff(workspaceId, filePath) {
         const newContent = await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${filePath}`, 'utf-8')).catch(() => '');
         diffs.push({
             path: filePath,
-            oldContent,
-            newContent,
-            isBinary: false,
+            oldContent: isBinaryPath(filePath) ? '' : oldContent,
+            newContent: isBinaryPath(filePath) ? '' : newContent,
+            isBinary: isBinaryPath(filePath),
             isNew: !oldContent,
             isDeleted: !newContent,
         });
@@ -126,13 +139,14 @@ export async function gitDiff(workspaceId, filePath) {
         const raw = await git.diff(['--name-only']);
         const files = raw.split('\n').filter(Boolean);
         for (const f of files) {
-            const oldContent = await git.show([`HEAD:${f}`]).catch(() => '');
-            const newContent = await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
+            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: false,
+                isBinary: binary,
                 isNew: !oldContent,
                 isDeleted: !newContent,
             });
@@ -140,13 +154,14 @@ export async function gitDiff(workspaceId, filePath) {
         // Also check untracked (staged new files)
         const status = await git.status();
         for (const f of status.not_added) {
-            const newContent = await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
-            if (newContent) {
+            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,
-                    isBinary: false,
+                    newContent: binary ? '' : newContent,
+                    isBinary: binary,
                     isNew: true,
                     isDeleted: false,
                 });
@@ -337,9 +352,10 @@ export async function gitCommitDiff(workspaceId, commitHash) {
     const files = nameOnlyRaw.split('\n').filter(Boolean);
     const diffs = [];
     for (const f of files) {
-        const oldContent = await git.show([`${commitHash}^:${f}`]).catch(() => '');
-        const newContent = await git.show([`${commitHash}:${f}`]).catch(() => '');
-        diffs.push({ path: f, oldContent, newContent, isBinary: false, isNew: !oldContent, isDeleted: !newContent });
+        const binary = isBinaryPath(f);
+        const oldContent = binary ? '' : await git.show([`${commitHash}^:${f}`]).catch(() => '');
+        const newContent = binary ? '' : await git.show([`${commitHash}:${f}`]).catch(() => '');
+        diffs.push({ path: f, oldContent, newContent, isBinary: binary, isNew: !oldContent, isDeleted: !newContent });
     }
     return diffs;
 }

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-message-parts.js

@@ -46,7 +46,7 @@ export function createAgentMessagePartsTracker(input) {
             output.push(event.line);
             input.onOutput?.(event.line);
         },
-        buildParts({ sessionId, workspaceRoot, model, usage, success, error }) {
+        buildParts({ sessionId, workspaceRoot, model, usage, persistentContext, success, error }) {
             return buildAgentMessageParts({
                 sessionId,
                 workspaceRoot,
@@ -55,6 +55,7 @@ export function createAgentMessagePartsTracker(input) {
                 output,
                 reasoning,
                 toolDetails,
+                persistentContext,
                 success,
                 error,
             });
@@ -69,7 +70,7 @@ function buildAgentMessageParts(input) {
         : '';
     const usage = input.usage ?? extractUsage(lines);
     const parts = [];
-    const chainItems = buildChainItems(lines, finalTextRange, finalText, input.workspaceRoot, input.toolDetails);
+    const chainItems = buildChainItems(lines, finalTextRange, finalText, input.workspaceRoot, input.toolDetails, input.persistentContext);
     const reasoningText = normalizeReasoningText(input.reasoning);
     if (reasoningText) {
         parts.push({
@@ -181,12 +182,17 @@ function findFinalTextRange(lines) {
     }
     return { start, end };
 }
-function buildChainItems(lines, finalTextRange, finalText, workspaceRoot, toolDetails) {
+function buildChainItems(lines, finalTextRange, finalText, workspaceRoot, toolDetails, persistentContext) {
     let toolIndex = 0;
     let messageIndex = 0;
     const items = [];
     const toolDetailMatchCounts = new Map();
     let messageBuffer = [];
+    const persistentContextItem = buildPersistentContextToolItem(persistentContext);
+    if (persistentContextItem) {
+        items.push(persistentContextItem);
+        toolIndex += 1;
+    }
     const flushMessageBuffer = () => {
         if (messageBuffer.length === 0)
             return;
@@ -229,6 +235,7 @@ function buildToolTodo(line, index, workspaceRoot, toolDetails, toolDetailMatchC
     const detailId = findToolDetailId(line, toolDetails, toolDetailMatchCounts);
     return {
         id: `tool-${index}`,
+        kind: 'tool',
         title: summary.title,
         description: summary.description,
         status: 'completed',
@@ -238,6 +245,23 @@ function buildToolTodo(line, index, workspaceRoot, toolDetails, toolDetailMatchC
         detailId,
     };
 }
+function buildPersistentContextToolItem(persistentContext) {
+    const counts = persistentContext?.counts;
+    if (!counts?.total)
+        return null;
+    const description = [
+        counts.claudeMd ? `${counts.claudeMd} claude.md` : null,
+        counts.agentsMd ? `${counts.agentsMd} AGENTS.md` : null,
+    ].filter(Boolean).join(', ') || `${counts.total} instruction files`;
+    return {
+        id: 'tool-persistent-context',
+        kind: 'tool',
+        title: 'Load claude.md',
+        description,
+        status: 'completed',
+        toolName: 'LoadClaudeMd',
+    };
+}
 function summarizeToolLine(line, workspaceRoot) {
     const trimmed = line.trim();
     const toolName = extractToolName(trimmed);

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) {

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

@@ -9,7 +9,9 @@ import { createIssueFunctionTools } from '../services/builtin-tools.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';
 const ACTIVE_TASK_STATUSES = ['running', 'reviewing', 'retrying', 'waiting_review'];
+const activeIssueRuntimes = new Map();
 export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, ctx) {
     const issue = issueService.getById(workspaceId, issueId);
     if (!issue) {
@@ -31,6 +33,7 @@ export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, c
     ctx.broadcast('agent.output', { agentId: taskSyncAgent.id, data: `Syncing issue tasks: ${issueId}` });
     const startTime = Date.now();
     const taskSyncWorkingDir = resolveIssueWorkspaceRoot(workspaceId);
+    const workspace = workspaceService.getById(workspaceId);
     const progress = createIssueAgentProgress(workspaceId, issue, taskSyncPreset, taskSyncAgent.id, {
         runtime: taskSyncPreset.runtimeKind,
         model: taskSyncPreset.modelId,
@@ -53,7 +56,8 @@ export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, c
         skills: [],
         configDir: agentService.getAgentConfigDir(workspaceId, taskSyncPreset),
         sandboxDirs: taskSyncPreset.sandboxDirs,
-        onEvent: taskSyncTracker.handleEvent,
+        outputStyle: taskSyncPreset.outputStyle,
+        onEvent: wrapOnEventWithHooks(taskSyncTracker.handleEvent.bind(taskSyncTracker), workspaceId, workspace?.hooksEnabled),
     });
     if (taskSyncTracker.output.length === 0) {
         for (const line of result.output) {
@@ -101,7 +105,10 @@ export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, c
     updateIssueStatus(workspaceId, issueId, 'in_progress', ctx);
     await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
 }
-export async function scheduleRunnableIssueTasks(workspaceId, issueId, ctx) {
+export async function scheduleRunnableIssueTasks(workspaceId, issueId, ctx, _options = {}) {
+    const issue = issueService.getById(workspaceId, issueId);
+    if (!issue)
+        return;
     const tasks = taskService.list(workspaceId, issueId);
     const doneIds = new Set(tasks.filter((task) => task.status === 'done').map((task) => task.id));
     const hasActive = tasks.some((task) => ACTIVE_TASK_STATUSES.includes(task.status));
@@ -113,7 +120,8 @@ export async function scheduleRunnableIssueTasks(workspaceId, issueId, ctx) {
         }
         return;
     }
-    for (const task of runnable) {
+    const tasksToRun = issue.continuousRun === false ? runnable.slice(0, 1) : runnable;
+    for (const task of tasksToRun) {
         await runIssueTask(workspaceId, issueId, task.id, ctx);
     }
 }
@@ -129,6 +137,8 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
     }
     const taskAgentPreset = findAgentForTask(workspaceId, issue, task);
     if (!taskAgentPreset) {
+        if (issueService.getById(workspaceId, issueId)?.status === 'error')
+            return;
         const missingExecutorResult = {
             success: false,
             summary: 'No runnable agent configured in issue channel members',
@@ -161,6 +171,7 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
     broadcastTaskUpdate(ctx, runningTask, task.status);
     agentService.assignTask(workspaceId, taskAgent.id, taskId);
     const runtime = createRuntimeForPreset(taskAgentPreset);
+    registerActiveIssueRuntime(workspaceId, issueId, taskAgent.id, runtime);
     const agentWorkingDir = resolveIssueWorkspaceRoot(workspaceId);
     const startTime = Date.now();
     const progress = createIssueAgentProgress(workspaceId, issue, taskAgentPreset, taskAgent.id, {
@@ -180,20 +191,40 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
             ctx.broadcast('task.output', { taskId, data: line });
         },
     });
+    const workspace = workspaceService.getById(workspaceId);
     ctx.broadcast('agent.output', { agentId: taskAgent.id, data: `Executing task: ${runningTask.title}` });
     ctx.broadcast('agent.output', {
         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(buildIssueAgentPrompt(workspaceId, buildTaskAgentPrompt(issue, runningTask, taskAgentPreset, agentWorkingDir), agentWorkingDir, taskAgentPreset), agentWorkingDir, {
-        maxTurns: 100,
-        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,
-    });
+    let result;
+    try {
+        result = await runtime.execute(buildIssueAgentPrompt(workspaceId, buildTaskAgentPrompt(issue, runningTask, taskAgentPreset, agentWorkingDir), agentWorkingDir, taskAgentPreset), agentWorkingDir, {
+            maxTurns: 100,
+            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,
+            outputStyle: taskAgentPreset.outputStyle,
+            onEvent: wrapOnEventWithHooks(agentTracker.handleEvent.bind(agentTracker), workspaceId, workspace?.hooksEnabled),
+        });
+    }
+    finally {
+        unregisterActiveIssueRuntime(workspaceId, issueId, taskAgent.id);
+    }
+    if (issueService.getById(workspaceId, issueId)?.status === 'error') {
+        const failedTask = taskService.updateStatus(workspaceId, taskId, 'failed', {
+            result: {
+                success: false,
+                summary: 'Interrupted by user',
+                artifacts: [],
+                error: 'Interrupted by user',
+            },
+        });
+        broadcastTaskUpdate(ctx, failedTask, 'running');
+        return;
+    }
     if (agentTracker.output.length === 0) {
         for (const line of result.output) {
             agentTracker.output.push(line);
@@ -235,10 +266,42 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
     }
     const completedTask = taskService.complete(workspaceId, taskId, result);
     broadcastTaskUpdate(ctx, completedTask, 'running');
-    await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
+    if (issueService.getById(workspaceId, issueId)?.continuousRun !== false) {
+        await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
+    }
 }
 export async function continueIssueTaskScheduling(workspaceId, issueId, ctx) {
-    await scheduleRunnableIssueTasks(workspaceId, issueId, ctx);
+    await scheduleRunnableIssueTasks(workspaceId, issueId, ctx, { force: true });
+}
+export function stopIssueAutomation(workspaceId, issueId, reason = 'Interrupted by user') {
+    const key = issueRunKey(workspaceId, issueId);
+    const runtimes = activeIssueRuntimes.get(key);
+    if (runtimes) {
+        for (const [agentId, runtime] of runtimes.entries()) {
+            try {
+                runtime.stop();
+            }
+            catch {
+                // Runtime may already be unwinding.
+            }
+            agentService.complete(workspaceId, agentId, reason);
+        }
+        activeIssueRuntimes.delete(key);
+    }
+    const activeTasks = taskService.list(workspaceId, issueId)
+        .filter((task) => ACTIVE_TASK_STATUSES.includes(task.status));
+    return activeTasks.map((task) => {
+        const from = task.status;
+        const failed = taskService.updateStatus(workspaceId, task.id, 'failed', {
+            result: {
+                success: false,
+                summary: reason,
+                artifacts: [],
+                error: reason,
+            },
+        });
+        return failed ? { task: failed, from } : null;
+    }).filter((item) => Boolean(item));
 }
 function createTaskSyncTools(workspaceId, issue, preset, ctx) {
     return [
@@ -417,6 +480,24 @@ async function handleTaskFailure(workspaceId, issueId, taskId, result, ctx) {
     ctx.broadcast('issue.status_changed', { issueId, from: issue?.status ?? 'in_progress', to: 'error' });
     ctx.broadcast('issue.updated', updated);
 }
+function registerActiveIssueRuntime(workspaceId, issueId, agentId, runtime) {
+    const key = issueRunKey(workspaceId, issueId);
+    const runtimes = activeIssueRuntimes.get(key) ?? new Map();
+    runtimes.set(agentId, runtime);
+    activeIssueRuntimes.set(key, runtimes);
+}
+function unregisterActiveIssueRuntime(workspaceId, issueId, agentId) {
+    const key = issueRunKey(workspaceId, issueId);
+    const runtimes = activeIssueRuntimes.get(key);
+    if (!runtimes)
+        return;
+    runtimes.delete(agentId);
+    if (runtimes.size === 0)
+        activeIssueRuntimes.delete(key);
+}
+function issueRunKey(workspaceId, issueId) {
+    return `${workspaceId}:${issueId}`;
+}
 function broadcastTaskUpdate(ctx, task, from) {
     if (!task)
         return;