@lovelybunch/api 1.0.76-alpha.0 → 1.0.76-alpha.10

package/dist/routes/api/v1/proposals/[id]/route.d.ts

@@ -9,11 +9,10 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
     success: true;
     data: {
         id: string;
-        title: string;
-        intent?: string;
+        intent: string;
         content?: string;
         author: {
-            type: import("@lovelybunch/core").AuthorType;
+            type: import("@lovelybunch/types").AuthorType;
             id: string;
             name: string;
             email?: string;
@@ -48,7 +47,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             version: string;
             name: string;
             description: string;
-            type: import("@lovelybunch/core").FeatureFlagType;
+            type: import("@lovelybunch/types").FeatureFlagType;
             defaultValue: any;
             scopes: string[];
             targets: {
@@ -96,7 +95,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
                 minimumSampleSize: number;
                 testType: "two-tailed" | "one-tailed";
             };
-            status: import("@lovelybunch/core").ExperimentStatus;
+            status: import("@lovelybunch/types").ExperimentStatus;
             startedAt?: string;
             endedAt?: string;
         }[];
@@ -134,13 +133,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             schedule?: string;
             rollbackPlan?: string;
         };
-        status: import("@lovelybunch/core").CPStatus;
-        comments?: {
-            id: string;
-            author: string;
-            content: string;
-            createdAt: string;
-        }[];
+        status: import("@lovelybunch/types").CPStatus;
         metadata: {
             createdAt: string;
             updatedAt: string;
@@ -173,11 +166,10 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
     success: true;
     data: {
         id: string;
-        title: string;
-        intent?: string;
+        intent: string;
         content?: string;
         author: {
-            type: import("@lovelybunch/core").AuthorType;
+            type: import("@lovelybunch/types").AuthorType;
             id: string;
             name: string;
             email?: string;
@@ -212,7 +204,7 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
             version: string;
             name: string;
             description: string;
-            type: import("@lovelybunch/core").FeatureFlagType;
+            type: import("@lovelybunch/types").FeatureFlagType;
             defaultValue: any;
             scopes: string[];
             targets: {
@@ -260,7 +252,7 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
                 minimumSampleSize: number;
                 testType: "two-tailed" | "one-tailed";
             };
-            status: import("@lovelybunch/core").ExperimentStatus;
+            status: import("@lovelybunch/types").ExperimentStatus;
             startedAt?: string;
             endedAt?: string;
         }[];
@@ -298,13 +290,7 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
             schedule?: string;
             rollbackPlan?: string;
         };
-        status: import("@lovelybunch/core").CPStatus;
-        comments?: {
-            id: string;
-            author: string;
-            content: string;
-            createdAt: string;
-        }[];
+        status: import("@lovelybunch/types").CPStatus;
         metadata: {
             createdAt: string;
             updatedAt: string;

package/dist/routes/api/v1/proposals/[id]/route.js

@@ -1,5 +1,6 @@
 import { FileStorageAdapter } from '../../../../../lib/storage/file-storage.js';
 import { getLogger } from '@lovelybunch/core/logging';
+import { getSlackService } from '../../../../../lib/slack/slack-service.js';
 const storage = new FileStorageAdapter();
 // Logger is lazily initialized inside handlers to use server config
 export async function GET(c) {
@@ -90,6 +91,14 @@ export async function PATCH(c) {
                     reason: null
                 }
             });
+            // Send Slack notification for status change (non-blocking)
+            getSlackService().sendNotification({
+                type: 'proposal.statusChange',
+                proposalId: id,
+                intent: updatedProposal?.intent || existing.intent,
+                status: newStatus,
+                previousStatus: oldStatus,
+            }).catch(err => console.warn('[proposals] Slack notification failed:', err));
         }
         return c.json({
             success: true,
@@ -134,7 +143,7 @@ export async function DELETE(c) {
                 tags: ['proposal'],
                 payload: {
                     id,
-                    title: proposal.title
+                    intent: proposal.intent
                 }
             });
         }

package/dist/routes/api/v1/proposals/route.d.ts

@@ -3,8 +3,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
     success: true;
     data: {
         id: string;
-        title: string;
-        intent?: string;
+        intent: string;
         content?: string;
         author: {
             type: import("@lovelybunch/types").AuthorType;
@@ -129,12 +128,6 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             rollbackPlan?: string;
         };
         status: import("@lovelybunch/types").CPStatus;
-        comments?: {
-            id: string;
-            author: string;
-            content: string;
-            createdAt: string;
-        }[];
         metadata: {
             createdAt: string;
             updatedAt: string;
@@ -167,8 +160,7 @@ export declare function POST(c: Context): Promise<(Response & import("hono").Typ
     success: true;
     data: {
         id: string;
-        title: string;
-        intent?: string;
+        intent: string;
         content?: string;
         author: {
             type: import("@lovelybunch/types").AuthorType;
@@ -293,12 +285,6 @@ export declare function POST(c: Context): Promise<(Response & import("hono").Typ
             rollbackPlan?: string;
         };
         status: import("@lovelybunch/types").CPStatus;
-        comments?: {
-            id: string;
-            author: string;
-            content: string;
-            createdAt: string;
-        }[];
         metadata: {
             createdAt: string;
             updatedAt: string;

package/dist/routes/api/v1/proposals/route.js

@@ -2,6 +2,7 @@ import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
 import { getAuthorInfo } from '../../../../lib/user-preferences.js';
 import Fuse from 'fuse.js';
 import { getLogger } from '@lovelybunch/core/logging';
+import { getSlackService } from '../../../../lib/slack/slack-service.js';
 const storage = new FileStorageAdapter();
 // Logger is lazily initialized inside handlers to use server config
 export async function GET(c) {
@@ -23,8 +24,7 @@ export async function GET(c) {
         if (searchQuery?.trim()) {
             const fuse = new Fuse(proposals, {
                 keys: [
-                    { name: 'title', weight: 0.4 },
-                    { name: 'intent', weight: 0.4 }, // Deprecated fallback
+                    { name: 'intent', weight: 0.4 },
                     { name: 'id', weight: 0.3 },
                     { name: 'author.name', weight: 0.2 },
                     { name: 'metadata.tags', weight: 0.1 }
@@ -58,13 +58,9 @@ export async function POST(c) {
         const authorInfo = await getAuthorInfo();
         // Create a new proposal with required fields
         const now = new Date();
-        // Use title as primary, fall back to deprecated intent for backward compatibility
-        const titleValue = body.title || body.intent || '';
         const proposal = {
             id: body.id || `cp-${Date.now()}`,
-            title: titleValue,
-            // Keep intent for backward compatibility (deprecated)
-            ...(body.intent && { intent: body.intent }),
+            intent: body.intent,
             content: body.content,
             author: body.author || {
                 id: 'current-user',
@@ -103,11 +99,18 @@ export async function POST(c) {
             tags: ['proposal'],
             payload: {
                 id: proposal.id,
-                title: proposal.title,
+                intent: proposal.intent,
                 priority: proposal.metadata.priority,
                 author: proposal.author
             }
         });
+        // Send Slack notification (non-blocking)
+        getSlackService().sendNotification({
+            type: 'proposal.created',
+            proposalId: proposal.id,
+            intent: proposal.intent,
+            author: proposal.author.name,
+        }).catch(err => console.warn('[proposals] Slack notification failed:', err));
         return c.json({
             success: true,
             data: proposal

package/dist/routes/api/v1/slack/route.d.ts

@@ -7,6 +7,9 @@ export declare function getConfig(c: Context): Promise<(Response & import("hono"
     success: true;
     data: {
         enabled: boolean;
+        channelId: string;
+        channelName: string;
+        siteUrl: string;
         notifications: {
             proposals: {
                 created: boolean;
@@ -21,9 +24,6 @@ export declare function getConfig(c: Context): Promise<(Response & import("hono"
                 merge: boolean;
             };
         };
-        channelId: string;
-        channelName: string;
-        siteUrl: string;
         hasBotToken: boolean;
         hasSigningSecret: boolean;
     };
@@ -39,6 +39,9 @@ export declare function updateConfig(c: Context): Promise<(Response & import("ho
     success: true;
     data: {
         enabled: boolean;
+        channelId: string;
+        channelName: string;
+        siteUrl: string;
         notifications: {
             proposals: {
                 created: boolean;
@@ -53,9 +56,6 @@ export declare function updateConfig(c: Context): Promise<(Response & import("ho
                 merge: boolean;
             };
         };
-        channelId: string;
-        channelName: string;
-        siteUrl: string;
         hasBotToken: boolean;
         hasSigningSecret: boolean;
     };

package/dist/routes/api/v1/tasks/route.d.ts

@@ -1,45 +1,25 @@
 import { Context } from 'hono';
+/**
+ * GET /api/v1/tasks
+ *
+ * Query params:
+ *   q        - fuzzy search query (title, content, id, author, tags)
+ *   status   - filter by status
+ *   author   - filter by author
+ *   priority - filter by priority
+ *   tags     - comma-separated tag filter
+ *   limit    - max results per page (1-100, default: all)
+ *   offset   - number of results to skip (for pagination, default: 0)
+ *   full     - set to "true" to include full content, planSteps, and comments
+ */
 export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    offset: number;
+    data: never[];
+    limit: number;
     totalCount: number;
+    count: number;
+    query?: string;
     success: true;
-    data: {
-        id: string;
-        title: string;
-        intent?: string;
-        content?: string;
-        author: {
-            type: import("@lovelybunch/types").AuthorType;
-            id: string;
-            name: string;
-            email?: string;
-        };
-        productSpecRef?: string;
-        planSteps: {
-            id: string;
-            description: string;
-            command?: string;
-            expectedOutcome?: string;
-            status: "pending" | "active" | "done" | "failed" | "skipped";
-            output?: string;
-            error?: string;
-            executedAt?: string;
-        }[];
-        status: import("@lovelybunch/types").TaskStatus;
-        comments?: {
-            id: string;
-            author: string;
-            content: string;
-            createdAt: string;
-        }[];
-        metadata: {
-            createdAt: string;
-            updatedAt: string;
-            reviewers: string[];
-            tags?: string[];
-            priority?: "low" | "medium" | "high" | "critical";
-            readiness?: number;
-        };
-    }[];
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
     error: {

package/dist/routes/api/v1/tasks/route.js

@@ -3,7 +3,64 @@ import { getAuthorInfo } from '../../../../lib/user-preferences.js';
 import Fuse from 'fuse.js';
 import { getLogger } from '@lovelybunch/core/logging';
 const storage = new FileStorageAdapter();
-// Logger is lazily initialized inside handlers to use server config
+const MAX_SUMMARY_CHARS = 200;
+function summarizeContent(content) {
+    if (!content)
+        return '';
+    const cleaned = content
+        .replace(/^#+\s+/gm, '')
+        .replace(/[*_`]/g, '')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        .trim();
+    const lines = cleaned.split('\n').filter(l => l.trim().length > 0);
+    const summary = lines.slice(0, 3).join(' ');
+    return summary.length > MAX_SUMMARY_CHARS
+        ? summary.substring(0, MAX_SUMMARY_CHARS) + '...'
+        : summary;
+}
+function extractSnippet(text, query, maxLen = 200) {
+    if (!text)
+        return '';
+    const lower = text.toLowerCase();
+    const terms = query.toLowerCase().split(/\s+/);
+    let bestIdx = -1;
+    for (const term of terms) {
+        const idx = lower.indexOf(term);
+        if (idx !== -1 && (bestIdx === -1 || idx < bestIdx))
+            bestIdx = idx;
+    }
+    if (bestIdx === -1)
+        return text.slice(0, maxLen) + (text.length > maxLen ? '...' : '');
+    const start = Math.max(0, bestIdx - 60);
+    const end = Math.min(text.length, bestIdx + 140);
+    let snippet = text.slice(start, end);
+    if (start > 0)
+        snippet = '...' + snippet;
+    if (end < text.length)
+        snippet += '...';
+    return snippet;
+}
+function toLightweight(task) {
+    const { content, comments, ...rest } = task;
+    return {
+        ...rest,
+        content: summarizeContent(content),
+        commentCount: comments?.length ?? 0,
+    };
+}
+/**
+ * GET /api/v1/tasks
+ *
+ * Query params:
+ *   q        - fuzzy search query (title, content, id, author, tags)
+ *   status   - filter by status
+ *   author   - filter by author
+ *   priority - filter by priority
+ *   tags     - comma-separated tag filter
+ *   limit    - max results per page (1-100, default: all)
+ *   offset   - number of results to skip (for pagination, default: 0)
+ *   full     - set to "true" to include full content, planSteps, and comments
+ */
 export async function GET(c) {
     try {
         const url = new URL(c.req.url);
@@ -15,36 +72,57 @@ export async function GET(c) {
         const searchQuery = searchParams.get('q');
         const limitParam = searchParams.get('limit');
         const limit = limitParam ? Math.min(Math.max(1, parseInt(limitParam, 10) || 20), 100) : undefined;
+        const offsetParam = searchParams.get('offset');
+        const offset = offsetParam ? Math.max(0, parseInt(offsetParam, 10) || 0) : 0;
+        const full = searchParams.get('full') === 'true';
         let tasks = await storage.listTasks({
             status,
             author: author || undefined,
             priority: priority || undefined,
             tags
         });
-        // Apply search filter if provided
+        let data;
         if (searchQuery?.trim()) {
             const fuse = new Fuse(tasks, {
                 keys: [
-                    { name: 'title', weight: 0.4 },
-                    { name: 'intent', weight: 0.4 }, // Deprecated fallback
-                    { name: 'id', weight: 0.3 },
-                    { name: 'author.name', weight: 0.2 },
-                    { name: 'metadata.tags', weight: 0.1 }
+                    { name: 'title', weight: 2 },
+                    { name: 'content', weight: 1 },
+                    { name: 'intent', weight: 1.5 },
+                    { name: 'id', weight: 1 },
+                    { name: 'author.name', weight: 0.5 },
+                    { name: 'metadata.tags', weight: 1.5 }
                 ],
-                threshold: 0.3,
-                includeScore: true
+                threshold: 0.15,
+                includeScore: true,
+                ignoreLocation: true,
+                minMatchCharLength: 3,
+            });
+            const MAX_SCORE = 0.85;
+            const results = fuse.search(searchQuery).filter(r => (r.score ?? 1) <= MAX_SCORE);
+            data = results.map(result => {
+                const base = full ? result.item : toLightweight(result.item);
+                return {
+                    ...base,
+                    snippet: extractSnippet(result.item.content || result.item.title || '', searchQuery),
+                    score: result.score,
+                };
             });
-            const searchResults = fuse.search(searchQuery);
-            tasks = searchResults.map(result => result.item);
         }
-        const totalCount = tasks.length;
-        if (limit !== undefined) {
-            tasks = tasks.slice(0, limit);
+        else {
+            data = full ? tasks : tasks.map(toLightweight);
+        }
+        const totalCount = data.length;
+        if (limit !== undefined || offset > 0) {
+            data = data.slice(offset, limit !== undefined ? offset + limit : undefined);
         }
         return c.json({
             success: true,
-            data: tasks,
-            ...(limit !== undefined && { totalCount })
+            ...(searchQuery ? { query: searchQuery } : {}),
+            totalCount,
+            count: data.length,
+            ...(limit !== undefined && { limit }),
+            offset,
+            data,
         });
     }
     catch (error) {

package/dist/routes/api/v1/terminal/[proposalId]/create/route.js

@@ -4,7 +4,7 @@ export async function POST(c) {
     try {
         const proposalId = c.req.param('proposalId');
         const body = await c.req.json().catch(() => ({}));
-        const { startupCommand } = body;
+        const { enableLogging = false, startupCommand } = body;
         if (!proposalId) {
             return c.json({ error: 'Proposal ID is required' }, 400);
         }
@@ -13,7 +13,7 @@ export async function POST(c) {
         const shellPreference = (userSettings.preferences.terminalShell || 'bash');
         // Create a new terminal session for this proposal
         const terminalManager = getGlobalTerminalManager();
-        const session = await terminalManager.createSession(proposalId, shellPreference, startupCommand);
+        const session = await terminalManager.createSession(proposalId, enableLogging, shellPreference, startupCommand);
         return c.json({
             sessionId: session.id,
             proposalId: session.proposalId,

package/dist/routes/api/v1/terminal/code/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const code: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default code;

package/dist/routes/api/v1/terminal/code/index.js

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { POST } from './route.js';
+const code = new Hono();
+code.post('/', POST);
+export default code;

package/dist/routes/api/v1/terminal/code/route.d.ts

@@ -0,0 +1,14 @@
+import { Context } from 'hono';
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    sessionId: string;
+    taskId: string;
+    command: string;
+    scriptPath: string;
+    createdAt: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;

package/dist/routes/api/v1/terminal/code/route.js

@@ -0,0 +1,159 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { tmpdir } from 'os';
+import matter from 'gray-matter';
+import { getGlobalTerminalManager } from '../../../../../lib/terminal/global-manager.js';
+import { loadUserSettings } from '../../../../../lib/user-preferences.js';
+import { FileStorageAdapter } from '../../../../../lib/storage/file-storage.js';
+import { buildPipelineScript, buildPipelineBanner } from '@lovelybunch/core';
+const storage = new FileStorageAdapter();
+const VALID_AGENTS = ['claude', 'gemini', 'codex', 'droid', 'kiro'];
+const VALID_CONTEXT_TYPES = ['change-task', 'prepare-task', 'skill', 'general'];
+function resolveGaitPath() {
+    if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
+        return process.env.GAIT_DEV_ROOT;
+    }
+    if (process.env.GAIT_DATA_PATH) {
+        return path.resolve(process.env.GAIT_DATA_PATH, '.nut');
+    }
+    return path.resolve(process.cwd(), '.nut');
+}
+async function loadMcpServers() {
+    const gaitPath = resolveGaitPath();
+    const mcpConfigPath = path.join(gaitPath, 'mcp', 'config.json');
+    try {
+        const raw = await fs.readFile(mcpConfigPath, 'utf-8');
+        const json = JSON.parse(raw);
+        const mcpServersMap = json.mcpServers || {};
+        return { servers: Object.keys(mcpServersMap), mcpServersMap };
+    }
+    catch {
+        return { servers: [], mcpServersMap: {} };
+    }
+}
+async function loadSkills() {
+    const gaitPath = resolveGaitPath();
+    const skillsPath = path.join(gaitPath, 'skills');
+    try {
+        await fs.mkdir(skillsPath, { recursive: true });
+        const entries = await fs.readdir(skillsPath, { withFileTypes: true });
+        const skills = await Promise.all(entries
+            .filter(entry => entry.isDirectory())
+            .map(async (entry) => {
+            const skillFile = path.join(skillsPath, entry.name, 'SKILL.md');
+            try {
+                const content = await fs.readFile(skillFile, 'utf-8');
+                const { data } = matter(content);
+                return { id: entry.name, name: data.name || entry.name };
+            }
+            catch {
+                return { id: entry.name, name: entry.name };
+            }
+        }));
+        return { skills, ids: skills.map(s => s.id) };
+    }
+    catch {
+        return { skills: [], ids: [] };
+    }
+}
+export async function POST(c) {
+    try {
+        const body = await c.req.json();
+        const { taskId } = body;
+        if (!taskId) {
+            return c.json({ error: 'taskId is required' }, 400);
+        }
+        const agent = (body.model || 'claude');
+        if (!VALID_AGENTS.includes(agent)) {
+            return c.json({ error: `Invalid model '${agent}'. Valid options: ${VALID_AGENTS.join(', ')}` }, 400);
+        }
+        const contextType = (body.contextType || 'change-task');
+        if (!VALID_CONTEXT_TYPES.includes(contextType)) {
+            return c.json({ error: `Invalid contextType '${contextType}'. Valid options: ${VALID_CONTEXT_TYPES.join(', ')}` }, 400);
+        }
+        // Validate task exists
+        const task = await storage.getTask(taskId);
+        if (!task) {
+            return c.json({ error: `Task '${taskId}' not found` }, 404);
+        }
+        // Optionally create a worktree
+        let worktreePath;
+        if (body.newWorktree) {
+            if (body.worktreeSuffix && body.worktreeBranch) {
+                return c.json({ error: 'Cannot use both worktreeSuffix and worktreeBranch' }, 400);
+            }
+            const idPart = taskId.startsWith('cp-') ? taskId.slice(3) : taskId;
+            const baseBranch = `feat/cp-${idPart}`;
+            let branchName;
+            if (body.worktreeBranch) {
+                branchName = body.worktreeBranch.trim();
+            }
+            else if (body.worktreeSuffix) {
+                const suffix = body.worktreeSuffix.trim().replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '');
+                branchName = suffix ? `${baseBranch}-${suffix}` : baseBranch;
+            }
+            else {
+                branchName = baseBranch;
+            }
+            try {
+                const apiBase = `http://localhost:${process.env.PORT || 3000}`;
+                const worktreeResponse = await fetch(`${apiBase}/api/v1/git/worktrees`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ branch: branchName, from: 'main' }),
+                });
+                const worktreeResult = await worktreeResponse.json();
+                if (worktreeResult.success) {
+                    worktreePath = worktreeResult.data?.added?.path;
+                }
+            }
+            catch {
+                // Continue without worktree
+            }
+        }
+        // Load MCP servers and skills
+        const { servers: selectedMcpServers, mcpServersMap } = await loadMcpServers();
+        const { skills, ids: selectedSkillIds } = await loadSkills();
+        // Build the raw node script and write to a temp file so the PTY
+        // command stays short (avoids echo noise and buffer-length limits).
+        const script = buildPipelineScript({
+            taskId,
+            contextType,
+            cliAgent: agent,
+            mcpServersMap,
+            selectedMcpServers,
+            skills,
+            selectedSkillIds,
+            automationEnabled: Boolean(body.autonomous),
+            customInstruction: body.customInstructions,
+            interactive: body.interactive ?? true,
+        });
+        const tmpDir = await fs.mkdtemp(path.join(tmpdir(), 'nut-pipeline-'));
+        const scriptPath = path.join(tmpDir, 'run.js');
+        await fs.writeFile(scriptPath, script, 'utf-8');
+        const interactive = body.interactive ?? true;
+        const banner = buildPipelineBanner({ taskId, cliAgent: agent, contextType, interactive });
+        const exitSuffix = interactive ? '' : '; exit';
+        const command = `printf '${banner}' && node ${scriptPath}${exitSuffix}`;
+        // Create terminal session with the pipeline command as a startup command
+        // so it runs via GAIT_STARTUP_CMD during shell init (same as the web UI path).
+        const userSettings = await loadUserSettings();
+        const shellPreference = (userSettings.preferences.terminalShell || 'bash');
+        const startupCommand = worktreePath
+            ? `cd '${worktreePath.replace(/'/g, "'\\''")}' && ${command}`
+            : command;
+        const terminalManager = getGlobalTerminalManager();
+        const session = await terminalManager.createSession(taskId, shellPreference, startupCommand);
+        return c.json({
+            sessionId: session.id,
+            taskId: session.taskId,
+            command,
+            scriptPath,
+            createdAt: session.createdAt,
+        });
+    }
+    catch (error) {
+        console.error('Error starting code session:', error);
+        return c.json({ error: 'Failed to start code session' }, 500);
+    }
+}