@pixelbyte-software/pixcode 1.36.4 → 1.37.0

package/scripts/smoke/taskmaster-onboarding.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const installJobs = readFileSync('server/services/install-jobs.js', 'utf8');
+const taskmasterRoutes = readFileSync('server/routes/taskmaster.js', 'utf8');
+const onboarding = readFileSync('src/components/onboarding/view/Onboarding.tsx', 'utf8');
+const stepProgress = readFileSync('src/components/onboarding/view/subcomponents/OnboardingStepProgress.tsx', 'utf8');
+const taskStep = readFileSync('src/components/onboarding/view/subcomponents/TaskSystemStep.tsx', 'utf8');
+
+assert.ok(
+  installJobs.includes("'task-master': 'task-master'"),
+  'TaskMaster package should be verified by the sandbox CLI installer.',
+);
+
+assert.ok(
+  taskmasterRoutes.includes("router.post('/install'"),
+  'TaskMaster routes should expose an authenticated install endpoint.',
+);
+
+assert.ok(
+  taskmasterRoutes.includes("router.get('/install/:jobId/stream'"),
+  'TaskMaster install should expose the same resilient log stream pattern as provider installs.',
+);
+
+assert.ok(
+  taskmasterRoutes.includes("provider: 'taskmaster'") && taskmasterRoutes.includes("packageName: 'task-master'"),
+  'TaskMaster install route should install the task-master npm package under the taskmaster job provider.',
+);
+
+assert.ok(
+  onboarding.includes('TaskSystemStep') && onboarding.includes('currentStep < 2'),
+  'Onboarding should include a third Task system step before completion.',
+);
+
+assert.ok(
+  onboarding.includes("localStorage.setItem('tasks-enabled'"),
+  'Onboarding should persist the user task-system choice.',
+);
+
+assert.ok(
+  stepProgress.includes('Task System'),
+  'Onboarding progress should show the Task System step.',
+);
+
+assert.ok(
+  taskStep.includes('/api/taskmaster/installation-status') && taskStep.includes('/api/taskmaster/install'),
+  'TaskSystemStep should check and install TaskMaster through the backend API.',
+);
+
+console.log('taskmaster onboarding smoke passed');

package/scripts/smoke/update-issue-progress.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { existsSync, readFileSync } from 'node:fs';
+
+const parserPath = 'src/components/version-upgrade/utils/releaseIssueProgress.ts';
+const componentPath = 'src/components/version-upgrade/view/ReleaseIssueProgress.tsx';
+const modalPath = 'src/components/version-upgrade/view/VersionUpgradeModal.tsx';
+const trackingPath = 'RELEASE_TRACKING_v1.37.md';
+
+assert.ok(existsSync(parserPath), 'Release issue progress parser should exist.');
+assert.ok(existsSync(componentPath), 'Release issue progress component should exist.');
+assert.ok(existsSync(trackingPath), 'v1.37 release tracking document should exist.');
+
+const parserSource = readFileSync(parserPath, 'utf8');
+assert.ok(
+  parserSource.includes('RELEASE_ISSUE_PROGRESS_MARKER'),
+  'Parser should expose a stable release-note marker for issue progress blocks.',
+);
+assert.ok(
+  parserSource.includes('extractIssueProgress'),
+  'Parser should export extractIssueProgress for release body parsing.',
+);
+assert.ok(
+  parserSource.includes('DEFAULT_V137_ISSUE_PROGRESS'),
+  'Parser should provide a v1.37 fallback issue map until the release body is published.',
+);
+assert.ok(
+  parserSource.includes('\\[([xX ~-])\\]') || parserSource.includes('[x]'),
+  'Parser should understand checked issue/task rows.',
+);
+
+const componentSource = readFileSync(componentPath, 'utf8');
+assert.ok(
+  componentSource.includes('extractIssueProgress'),
+  'Component should render parsed issue progress from release notes.',
+);
+assert.ok(
+  componentSource.includes('completedCount'),
+  'Component should summarize completed issue progress.',
+);
+assert.ok(
+  componentSource.includes("version?.startsWith('1.37')") || componentSource.includes('version.startsWith'),
+  'Component should only use the v1.37 fallback for v1.37 release notes.',
+);
+
+const modalSource = readFileSync(modalPath, 'utf8');
+assert.ok(
+  modalSource.includes('ReleaseIssueProgress'),
+  'Version modal should include release issue progress.',
+);
+assert.ok(
+  modalSource.includes('releaseInfo.body'),
+  'Version modal should pass release body text to the issue progress view.',
+);
+
+const trackingSource = readFileSync(trackingPath, 'utf8');
+for (const issueNumber of [6, 7, 8, 9, 10, 11, 12, 13, 14]) {
+  assert.ok(
+    trackingSource.includes(`#${issueNumber}`),
+    `Release tracking should mention issue #${issueNumber}.`,
+  );
+}
+assert.ok(
+  trackingSource.includes('<!-- pixcode:issue-progress -->'),
+  'Release tracking should include the issue-progress marker block used in release notes.',
+);
+
+console.log('update issue progress smoke passed');

package/server/database/db.js

@@ -493,7 +493,7 @@ const credentialsDb = {
 // Notification preferences
 // ---------------------------------------------------------------------------
 const DEFAULT_NOTIFICATION_PREFERENCES = {
-    channels: { inApp: false, webPush: false },
+    channels: { inApp: true, webPush: false, telegram: true, desktop: true },
     events: { actionRequired: true, stop: true, error: true, updates: true },
 };
 
@@ -501,8 +501,10 @@ const normalizeNotificationPreferences = (value) => {
     const source = value && typeof value === 'object' ? value : {};
     return {
         channels: {
-            inApp: source.channels?.inApp === true,
+            inApp: source.channels?.inApp !== false,
             webPush: source.channels?.webPush === true,
+            telegram: source.channels?.telegram !== false,
+            desktop: source.channels?.desktop !== false,
         },
         events: {
             actionRequired: source.events?.actionRequired !== false,

package/server/index.js

@@ -99,6 +99,7 @@ import {
 import { primeCliBinPath } from './services/install-jobs.js';
 import { startEnabledPluginServers, stopAllPlugins, getPluginPort } from './utils/plugin-process-manager.js';
 import { initializeDatabase, sessionNamesDb, applyCustomSessionNames } from './database/db.js';
+import { setNotificationWebSocketServer } from './services/notification-orchestrator.js';
 import { configureWebPush } from './services/vapid-keys.js';
 import { validateApiKey, authenticateToken, authenticateWebSocket } from './middleware/auth.js';
 import { IS_PLATFORM } from './constants/config.js';
@@ -319,6 +320,7 @@ const wss = new WebSocketServer({
 
 // Make WebSocket server available to routes
 app.locals.wss = wss;
+setNotificationWebSocketServer(wss);
 
 app.use(cors({ exposedHeaders: ['X-Refreshed-Token'] }));
 app.use(express.json({
@@ -1813,6 +1815,7 @@ function handleChatConnection(ws, request) {
     console.log('[INFO] Chat WebSocket connected');
 
     // Add to connected clients for project updates
+    ws.userId = request?.user?.id ?? request?.user?.userId ?? null;
     connectedClients.add(ws);
 
     // Wrap WebSocket with writer for consistent interface with SSEStreamWriter

package/server/modules/orchestration/tasks/orchestration-task.routes.ts

@@ -48,11 +48,20 @@ export function createOrchestrationTaskRouter(): Router {
     try {
       const adapterId = typeof req.body?.adapterId === 'string' ? req.body.adapterId : '';
       const isolation = req.body?.isolation;
+      const projectPath = typeof req.body?.projectPath === 'string' ? req.body.projectPath : undefined;
+      const model = typeof req.body?.model === 'string' ? req.body.model : undefined;
+      const permissionMode = typeof req.body?.permissionMode === 'string' ? req.body.permissionMode : undefined;
       if (!adapterId) {
         res.status(400).json({ error: { code: 'ADAPTER_REQUIRED', message: 'adapterId is required' } });
         return;
       }
-      const task = await orchestrationTaskService.dispatch(req.params.id, { adapterId, isolation });
+      const task = await orchestrationTaskService.dispatch(req.params.id, {
+        adapterId,
+        isolation,
+        projectPath,
+        model,
+        permissionMode,
+      });
       res.json(task);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);

package/server/modules/orchestration/tasks/orchestration-task.service.ts

@@ -71,6 +71,12 @@ class OrchestrationTaskService {
         },
         metadata: {
           isolation: input.isolation ?? 'worktree',
+          model: input.model,
+          permissionMode: input.permissionMode,
+          workspace: {
+            kind: input.isolation ?? 'worktree',
+            projectPath: input.projectPath,
+          },
           orchestrationTaskId: task.id,
           taskmasterId: task.taskmasterId,
         },
@@ -86,6 +92,7 @@ class OrchestrationTaskService {
     task.adapterId = input.adapterId;
     task.adapterSelector = input.adapterId;
     task.workspaceKind = input.isolation ?? 'worktree';
+    task.workspacePath = input.projectPath;
     task.state = 'in_progress';
     task.updatedAt = Date.now();
     this.store.set(task);

package/server/modules/orchestration/tasks/orchestration-task.types.ts

@@ -26,4 +26,7 @@ export interface CreateOrchestrationTaskInput {
 export interface DispatchOrchestrationTaskInput {
   adapterId: string;
   isolation?: 'host' | 'worktree' | 'docker';
+  projectPath?: string;
+  model?: string;
+  permissionMode?: string;
 }

package/server/modules/orchestration/workflows/workflow-runner.ts

@@ -299,6 +299,56 @@ function handoffPrompt(agent: AgentAssignment, role: AgentRole): string {
   ].filter(Boolean).join('\n');
 }
 
+function handoffInitPrompt(agent: AgentAssignment, index: number): string {
+  return [
+    `You are preparing ${agent.label} for a strict Pixcode handoff chain.`,
+    `This is internal step ${index + 1}.`,
+    'Create a compact init packet for the next visible work step.',
+    'Use the original user goal and any prior compact handoff packet included above.',
+    agent.instruction ? `The explicit assignment for this agent is: ${agent.instruction}` : '',
+    'Output only this internal init packet:',
+    '- user goal in one sentence',
+    '- prior agent handoff summary, if present',
+    '- this agent responsibility',
+    '- exact constraints and blockers this agent must respect',
+    privacyGuardPrompt(),
+    'Do not perform the task yet. Do not mention that this is hidden from the user.',
+    'Respond in the same language as the user request.',
+  ].filter(Boolean).join('\n');
+}
+
+function handoffWorkPrompt(agent: AgentAssignment, index: number): string {
+  return [
+    `You are ${agent.label} in a strict Pixcode handoff chain.`,
+    `This is visible work step ${index + 1}.`,
+    'The internal init packet above is your starting context. Do the assigned work now.',
+    agent.instruction
+      ? `Your explicit assignment from the user is: ${agent.instruction}`
+      : 'Use the init packet and original user goal to choose the next useful work for this step.',
+    rolePrompt(agent.role ?? 'implementation'),
+    privacyGuardPrompt(),
+    'Report only user-facing progress, changed files, commands, verification, blockers, and next actions.',
+    'Respond in the same language as the user request.',
+  ].filter(Boolean).join('\n');
+}
+
+function handoffCompactPrompt(agent: AgentAssignment, index: number): string {
+  return [
+    `You are compacting ${agent.label}'s strict handoff output for the next Pixcode agent.`,
+    `This is internal compact step ${index + 1}.`,
+    'Read the prior visible work output included above and create a compact handoff packet.',
+    'Output only this internal compact packet:',
+    '- Ben ne yaptım / What I did',
+    '- Dokunduğum alanlar / Touched areas',
+    '- Kanıt, komut veya çıktı / Evidence, commands, outputs',
+    '- Sonraki ajan şunu bilsin / What the next agent must know',
+    '- Bloker veya risk / Blockers or risks',
+    privacyGuardPrompt(),
+    'Do not include raw logs unless they are essential. Keep it concise and actionable.',
+    'Respond in the same language as the user request.',
+  ].join('\n');
+}
+
 function compactOutputForContext(text: string): string {
   if (text.length <= MAX_OUTPUT_CONTEXT_CHARS) {
     return text;
@@ -595,32 +645,89 @@ function expandSequentialHandoffWorkflow(workflow: Workflow, metadata?: Record<s
     throw new Error('Select at least one CLI agent.');
   }
 
+  const nodes: WorkflowNode[] = agents.flatMap((agent, index): WorkflowNode[] => {
+    const initNodeId = safeAgentNodeId(agent, index, 'init');
+    const workNodeId = safeAgentNodeId(agent, index, 'work');
+    const compactNodeId = safeAgentNodeId(agent, index, 'compact');
+
+    return [
+      {
+        id: initNodeId,
+        adapterId: agent.adapterId,
+        agentInstanceId: agent.instanceId,
+        agentLabel: `${agent.label} Init`,
+        assignment: agent.instruction,
+        stage: 'handoff_init',
+        model: agent.model,
+        permissionMode: agent.permissionMode,
+        toolsSettings: agent.toolsSettings,
+        prompt: handoffInitPrompt(agent, index),
+        inputs: index === 0 ? [] : [safeAgentNodeId(agents[index - 1], index - 1, 'compact')],
+        output: 'message',
+        onFail: 'abort',
+        internal: true,
+      },
+      {
+        id: workNodeId,
+        adapterId: agent.adapterId,
+        agentInstanceId: agent.instanceId,
+        agentLabel: agent.label,
+        assignment: agent.instruction,
+        stage: agent.role ?? 'implementation',
+        model: agent.model,
+        permissionMode: agent.permissionMode,
+        toolsSettings: agent.toolsSettings,
+        prompt: handoffWorkPrompt(agent, index),
+        inputs: [initNodeId],
+        output: 'both',
+        onFail: 'abort',
+      },
+      {
+        id: compactNodeId,
+        adapterId: agent.adapterId,
+        agentInstanceId: agent.instanceId,
+        agentLabel: `${agent.label} Compact`,
+        assignment: agent.instruction,
+        stage: 'handoff_compact',
+        model: agent.model,
+        permissionMode: agent.permissionMode,
+        toolsSettings: agent.toolsSettings,
+        prompt: handoffCompactPrompt(agent, index),
+        inputs: [workNodeId],
+        output: 'message',
+        onFail: 'abort',
+        internal: true,
+      },
+    ];
+  });
+  const reportAgent = agents[0];
+  const lastCompactNodeId = safeAgentNodeId(agents[agents.length - 1], agents.length - 1, 'compact');
+
   return {
     ...workflow,
-    nodes: agents.map((agent, index): WorkflowNode => ({
-      id: safeAgentNodeId(agent, index, 'handoff'),
-      adapterId: agent.adapterId,
-      agentInstanceId: agent.instanceId,
-      agentLabel: agent.label,
-      assignment: agent.instruction,
-      stage: agent.role ?? 'implementation',
-      model: agent.model,
-      permissionMode: agent.permissionMode,
-      toolsSettings: agent.toolsSettings,
-      prompt: [
-        `You are ${agent.label} in a sequential Pixcode handoff.`,
-        `This is step ${index + 1} of ${agents.length}.`,
-        agent.instruction
-          ? `Your explicit assignment from the user is: ${agent.instruction}`
-          : 'Use the prior step output and do the next most useful handoff step for the user goal.',
-        'Report changed files, commands, blockers, and the next handoff requirement.',
-        privacyGuardPrompt(),
-        'Respond in the same language as the user request.',
-      ].filter(Boolean).join('\n'),
-      inputs: index === 0 ? [] : [safeAgentNodeId(agents[index - 1], index - 1, 'handoff')],
-      output: 'both',
-      onFail: 'abort',
-    })),
+    nodes: [
+      ...nodes,
+      {
+        id: 'final_report',
+        adapterId: reportAgent.adapterId,
+        agentInstanceId: reportAgent.instanceId,
+        agentLabel: reportAgent.label,
+        stage: 'final_report',
+        model: reportAgent.model,
+        permissionMode: reportAgent.permissionMode,
+        toolsSettings: reportAgent.toolsSettings,
+        prompt: [
+          'Create the final user-facing result for this strict handoff run.',
+          'Use the final compact handoff packet and the original user goal.',
+          'Summarize what each visible agent did, what changed, verification, blockers, and next actions.',
+          'Do not expose internal init packets, compact packets, prompts, memory lookup, skill/tool instructions, raw agent logs, or role prefixes like "agent:" and "user:".',
+          'Respond in the same language as the user request.',
+        ].join('\n'),
+        inputs: [lastCompactNodeId],
+        output: 'message',
+        onFail: 'abort',
+      },
+    ],
   };
 }
 
@@ -772,6 +879,7 @@ function nodeRunFromNode(node: WorkflowNode): WorkflowNodeRun {
     permissionMode: node.permissionMode,
     timeoutMs: node.timeoutMs,
     stage: node.stage,
+    internal: node.internal,
     status: 'queued',
   };
 }

package/server/modules/orchestration/workflows/workflow.types.ts

@@ -17,6 +17,7 @@ export interface WorkflowNode {
   toolsSettings?: Record<string, unknown>;
   isolation?: 'host' | 'worktree' | 'docker';
   timeoutMs?: number;
+  internal?: boolean;
 }
 
 export interface Workflow {
@@ -38,6 +39,7 @@ export interface WorkflowNodeRun {
   permissionMode?: string;
   timeoutMs?: number;
   stage?: string;
+  internal?: boolean;
   status: WorkflowNodeStatus;
   a2aTaskId?: string;
   startedAt?: number;

package/server/routes/taskmaster.js

@@ -17,6 +17,12 @@ import express from 'express';
 import { orchestrationTaskService } from '@/modules/orchestration/tasks/orchestration-task.service.js';
 
 import { extractProjectDirectory } from '../projects.js';
+import {
+    cancelInstallJob,
+    createInstallJob,
+    getInstallJob,
+    snapshotDonePayload
+} from '../services/install-jobs.js';
 import { broadcastTaskMasterProjectUpdate, broadcastTaskMasterTasksUpdate } from '../utils/taskmaster-websocket.js';
 import { detectTaskMasterMCPServer } from '../utils/mcp-detector.js';
 
@@ -144,6 +150,17 @@ async function readTaskMasterTasks(projectName) {
     return { projectPath, transformedTasks, currentTag };
 }
 
+function taskMasterExecutionDescription(task) {
+    return [
+        task.description ? `Description:\n${task.description}` : '',
+        task.details ? `Details:\n${task.details}` : '',
+        task.testStrategy ? `Test strategy:\n${task.testStrategy}` : '',
+        Array.isArray(task.dependencies) && task.dependencies.length
+            ? `Dependencies: ${task.dependencies.join(', ')}`
+            : '',
+    ].filter(Boolean).join('\n\n');
+}
+
 // API Routes
 
 /**
@@ -181,6 +198,121 @@ router.get('/installation-status', async (req, res) => {
     }
 });
 
+/**
+ * POST /api/taskmaster/install
+ * Install TaskMaster CLI into Pixcode's sandboxed CLI bin.
+ */
+router.post('/install', async (req, res) => {
+    try {
+        const job = createInstallJob({
+            provider: 'taskmaster',
+            installCmd: 'npm install -g task-master',
+            packageName: 'task-master'
+        });
+
+        res.json({
+            success: true,
+            jobId: job.id,
+            provider: 'taskmaster',
+            packageName: 'task-master',
+            startedAt: job.startedAt
+        });
+    } catch (error) {
+        console.error('TaskMaster install start error:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to start TaskMaster install',
+            message: error.message
+        });
+    }
+});
+
+/**
+ * GET /api/taskmaster/install/:jobId/stream
+ * Replay and stream TaskMaster install output.
+ */
+router.get('/install/:jobId/stream', async (req, res) => {
+    const job = getInstallJob(req.params.jobId);
+    if (!job || job.provider !== 'taskmaster') {
+        return res.status(404).json({
+            success: false,
+            error: 'Install job not found or already expired'
+        });
+    }
+
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    if (typeof res.flushHeaders === 'function') res.flushHeaders();
+
+    let closed = false;
+    const write = (event, payload) => {
+        if (closed) return;
+        try {
+            res.write(`event: ${event}\n`);
+            res.write(`data: ${JSON.stringify(payload)}\n\n`);
+        } catch {
+            // Socket is gone.
+        }
+    };
+
+    try { res.write(': start\n\n'); } catch { /* noop */ }
+    const heartbeat = setInterval(() => {
+        if (!closed) {
+            try { res.write(': ping\n\n'); } catch { /* noop */ }
+        }
+    }, 5000);
+
+    for (const entry of job.logs) {
+        write('log', { stream: entry.stream, chunk: entry.chunk });
+    }
+
+    const cleanup = () => {
+        if (closed) return;
+        closed = true;
+        clearInterval(heartbeat);
+        job.emitter.off('log', onLog);
+        job.emitter.off('done', onDone);
+    };
+    const onLog = (entry) => {
+        write('log', { stream: entry.stream, chunk: entry.chunk });
+    };
+    const onDone = (payload) => {
+        write('done', payload);
+        cleanup();
+        try { res.end(); } catch { /* noop */ }
+    };
+
+    if (job.status !== 'running') {
+        write('done', snapshotDonePayload(job));
+        cleanup();
+        try { res.end(); } catch { /* noop */ }
+        return;
+    }
+
+    job.emitter.on('log', onLog);
+    job.emitter.once('done', onDone);
+
+    req.on('close', cleanup);
+});
+
+/**
+ * DELETE /api/taskmaster/install/:jobId
+ * Cancel a running TaskMaster install job.
+ */
+router.delete('/install/:jobId', async (req, res) => {
+    const job = getInstallJob(req.params.jobId);
+    if (!job || job.provider !== 'taskmaster') {
+        return res.status(404).json({
+            success: false,
+            error: 'Install job not found'
+        });
+    }
+
+    res.json({ success: true, cancelled: cancelInstallJob(req.params.jobId) });
+});
+
 /**
  * GET /api/taskmaster/tasks/:projectName
  * Load actual tasks from .taskmaster/tasks/tasks.json
@@ -230,6 +362,75 @@ router.get('/tasks/:projectName', async (req, res) => {
     }
 });
 
+/**
+ * POST /api/taskmaster/execute/:projectName/:taskId
+ * Import a TaskMaster task into orchestration and dispatch it to a CLI agent.
+ */
+router.post('/execute/:projectName/:taskId', async (req, res) => {
+    try {
+        const { projectName, taskId } = req.params;
+        const adapterId = typeof req.body?.adapterId === 'string'
+            ? req.body.adapterId
+            : typeof req.body?.provider === 'string'
+                ? req.body.provider
+                : '';
+        const model = typeof req.body?.model === 'string' ? req.body.model : undefined;
+        const permissionMode = typeof req.body?.permissionMode === 'string' ? req.body.permissionMode : undefined;
+        const isolation = ['host', 'worktree', 'docker'].includes(req.body?.isolation)
+            ? req.body.isolation
+            : 'worktree';
+        const projectId = typeof req.body?.projectId === 'string' ? req.body.projectId : projectName;
+
+        if (!adapterId) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing adapterId',
+                message: 'adapterId or provider is required'
+            });
+        }
+
+        const { projectPath, transformedTasks } = await readTaskMasterTasks(projectName);
+        const task = transformedTasks.find((candidate) => String(candidate.id) === String(taskId));
+        if (!task) {
+            return res.status(404).json({
+                success: false,
+                error: 'TaskMaster task not found',
+                message: `Task "${taskId}" was not found in project "${projectName}"`
+            });
+        }
+
+        const orchestrationTask = orchestrationTaskService.upsertFromTaskMaster({
+            projectId,
+            taskmasterId: String(task.id),
+            title: `TaskMaster #${task.id}: ${task.title}`,
+            description: taskMasterExecutionDescription(task)
+        });
+
+        const dispatchedTask = await orchestrationTaskService.dispatch(orchestrationTask.id, {
+            adapterId,
+            isolation,
+            projectPath,
+            model,
+            permissionMode
+        });
+
+        res.json({
+            success: true,
+            projectName,
+            projectPath,
+            taskmasterTask: task,
+            task: dispatchedTask
+        });
+    } catch (error) {
+        console.error('TaskMaster execute error:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to execute TaskMaster task',
+            message: error.message
+        });
+    }
+});
+
 /**
  * POST /api/taskmaster/sync-orchestration/:projectName
  * One-way sync: TaskMaster -> Orchestration tasks

package/server/services/install-jobs.js

@@ -63,6 +63,7 @@ const PACKAGE_BINARIES = {
     '@google/gemini-cli': 'gemini',
     '@qwen-code/qwen-code': 'qwen',
     'opencode-ai': 'opencode',
+    'task-master': 'task-master',
 };
 
 /**