@agent-spaces/server 0.3.65 → 0.4.0

package/dist/services/generated-title.js

@@ -0,0 +1,59 @@
+import { runTitleGeneratorAgent } from '../agents/title-generator-agent.js';
+import { getChannel, updateChannel } from './channel.js';
+import * as issueService from './issue.js';
+export function scheduleChannelTitleGeneration(input) {
+    if (!input.requirement.trim())
+        return;
+    void generateChannelTitle(input).catch((err) => {
+        console.error('[title-generator] channel title generation failed', {
+            workspaceId: input.workspaceId,
+            channelId: input.channelId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    });
+}
+export function scheduleIssueTitleGeneration(input) {
+    void generateIssueTitle(input).catch((err) => {
+        console.error('[title-generator] issue title generation failed', {
+            workspaceId: input.workspaceId,
+            issueId: input.issueId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    });
+}
+async function generateChannelTitle(input) {
+    const title = await runTitleGeneratorAgent({
+        workspaceId: input.workspaceId,
+        target: 'channel',
+        requirement: input.requirement,
+    });
+    const current = getChannel(input.workspaceId, input.channelId);
+    if (!current || current.name.trim() !== '')
+        return;
+    const updated = updateChannel(input.workspaceId, input.channelId, { name: title });
+    if (updated)
+        input.broadcast('channel.updated', updated);
+}
+async function generateIssueTitle(input) {
+    const title = await runTitleGeneratorAgent({
+        workspaceId: input.workspaceId,
+        target: 'issue',
+        requirement: input.requirement,
+        description: input.description,
+    });
+    const issue = issueService.getById(input.workspaceId, input.issueId);
+    if (!issue || issue.title.trim() !== '')
+        return;
+    issue.title = title;
+    const saved = issueService.save(input.workspaceId, issue);
+    input.broadcast('issue.updated', saved);
+    if (!saved.channelId)
+        return;
+    const channel = getChannel(input.workspaceId, saved.channelId);
+    if (!channel || channel.name.trim() !== '')
+        return;
+    const updatedChannel = updateChannel(input.workspaceId, saved.channelId, { name: title });
+    if (updatedChannel)
+        input.broadcast('channel.updated', updatedChannel);
+}
+//# sourceMappingURL=generated-title.js.map

package/dist/services/gitignore.js

@@ -1,18 +1,24 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { minimatch } from 'minimatch';
 const cache = new Map();
-function matchPattern(pattern, name) {
-    if (pattern.startsWith('*.')) {
-        return name.endsWith(pattern.slice(1));
+function normalizeRelPath(path) {
+    return path.replace(/\\/g, '/').replace(/^\/+/, '');
+}
+function matchesDirPattern(pattern, relPath, hasSlash) {
+    if (!hasSlash) {
+        return relPath.split('/').includes(pattern);
     }
-    if (pattern.startsWith('*.') && pattern.includes('/')) {
-        return name.endsWith(pattern.split('/').pop());
+    return relPath === pattern || relPath.startsWith(`${pattern}/`);
+}
+function matchesPattern(pattern, relPath, name, isDir) {
+    if (pattern.dirOnly) {
+        return matchesDirPattern(pattern.pattern, relPath, pattern.hasSlash);
     }
-    if (pattern.includes('*')) {
-        const re = new RegExp('^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
-        return re.test(name);
+    if (!pattern.hasSlash) {
+        return minimatch(name, pattern.pattern, { dot: true, nocase: process.platform === 'win32' });
     }
-    return name === pattern;
+    return minimatch(relPath, pattern.pattern, { dot: true, nocase: process.platform === 'win32' });
 }
 export async function createGitignoreFilter(rootDir) {
     const gitignorePath = join(rootDir, '.gitignore');
@@ -39,9 +45,8 @@ export async function createGitignoreFilter(rootDir) {
             const dirOnly = p.endsWith('/');
             if (dirOnly)
                 p = p.slice(0, -1);
-            // extract the last segment for name matching
-            const namePart = p.includes('/') ? p.split('/').filter(Boolean).pop() : p;
-            return { raw: namePart, dirOnly, negated, fullPath: p };
+            p = normalizeRelPath(p);
+            return { pattern: p, dirOnly, negated, hasSlash: p.includes('/') };
         });
     }
     catch {
@@ -49,14 +54,13 @@ export async function createGitignoreFilter(rootDir) {
     }
     const filter = {
         isIgnored(relPath, name, isDir) {
+            const normalizedRelPath = normalizeRelPath(relPath);
+            let ignored = false;
             for (const p of patterns) {
-                if (p.dirOnly && !isDir)
-                    continue;
-                if (matchPattern(p.raw, name) || matchPattern(p.fullPath, relPath)) {
-                    return !p.negated;
-                }
+                if (matchesPattern(p, normalizedRelPath, name, isDir))
+                    ignored = !p.negated;
             }
-            return false;
+            return ignored;
         },
     };
     cache.set(rootDir, { mtime, filter });

package/dist/services/interaction-manager.js

@@ -0,0 +1,114 @@
+// Workflow interaction manager — handles client-side UI interactions
+// (alert/prompt/form/table_confirm) during workflow execution.
+import { randomUUID } from 'node:crypto';
+import { sendToClient, onClientConnected, onClientDisconnected, setInteractionResponseHandler } from '../ws/connection-manager.js';
+const DEFAULT_TIMEOUT_MS = 5 * 60_000;
+const RECONNECT_GRACE_MS = 30_000;
+export class InteractionManager {
+    pending = new Map();
+    constructor() {
+        setInteractionResponseHandler((response, clientId) => {
+            this.handleResponse(response, clientId);
+        });
+        onClientConnected((clientId) => {
+            this.handleClientReconnect(clientId);
+        });
+        onClientDisconnected((clientId) => {
+            this.handleClientDisconnect(clientId);
+        });
+    }
+    async request(params) {
+        const id = randomUUID();
+        const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const payload = {
+            id,
+            channel: 'workflow:interaction',
+            type: 'interaction_required',
+            executionId: params.executionId,
+            workflowId: params.workflowId,
+            nodeId: params.nodeId,
+            interactionType: params.interactionType,
+            schema: params.schema,
+            timeoutMs,
+        };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Interaction timeout: ${params.interactionType}`));
+            }, timeoutMs);
+            this.pending.set(id, {
+                id,
+                clientId: params.clientId,
+                executionId: params.executionId,
+                workflowId: params.workflowId,
+                nodeId: params.nodeId,
+                interactionType: params.interactionType,
+                payload,
+                resolve,
+                reject,
+                timer,
+            });
+            const sent = sendToClient(params.clientId, payload);
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(new Error(`Client not connected: ${params.interactionType}`));
+            }
+        });
+    }
+    cancelExecution(executionId, message = 'Execution stopped') {
+        let cancelled = 0;
+        for (const [id, pending] of this.pending.entries()) {
+            if (pending.executionId !== executionId)
+                continue;
+            this.pending.delete(id);
+            clearTimeout(pending.timer);
+            if (pending.reconnectTimer)
+                clearTimeout(pending.reconnectTimer);
+            pending.reject(new Error(message));
+            cancelled += 1;
+        }
+        return cancelled;
+    }
+    handleResponse(response, clientId) {
+        const pending = this.pending.get(response.id);
+        if (!pending || pending.clientId !== clientId)
+            return;
+        clearTimeout(pending.timer);
+        if (pending.reconnectTimer)
+            clearTimeout(pending.reconnectTimer);
+        this.pending.delete(response.id);
+        if (response.error) {
+            pending.reject(new Error(response.error.message));
+            return;
+        }
+        if (response.cancelled) {
+            pending.reject(new Error(`Interaction cancelled: ${pending.interactionType}`));
+            return;
+        }
+        pending.resolve(response.data);
+    }
+    handleClientDisconnect(clientId) {
+        for (const [id, pending] of this.pending.entries()) {
+            if (pending.clientId !== clientId || pending.reconnectTimer)
+                continue;
+            pending.reconnectTimer = setTimeout(() => {
+                this.pending.delete(id);
+                clearTimeout(pending.timer);
+                pending.reject(new Error(`Client disconnected: ${pending.interactionType}`));
+            }, RECONNECT_GRACE_MS);
+        }
+    }
+    handleClientReconnect(clientId) {
+        for (const pending of this.pending.values()) {
+            if (pending.clientId !== clientId)
+                continue;
+            if (pending.reconnectTimer) {
+                clearTimeout(pending.reconnectTimer);
+                pending.reconnectTimer = undefined;
+            }
+            sendToClient(clientId, pending.payload);
+        }
+    }
+}
+//# sourceMappingURL=interaction-manager.js.map

package/dist/services/issue-retry.js

@@ -1,16 +1,20 @@
 import * as issueService from './issue.js';
 import * as taskService from './task.js';
+import * as channelService from './channel.js';
+import * as messageService from './message.js';
 import { scheduleRunnableIssueTasks } from '../agents/issue-task-controller.js';
 import { listWorkspaces } from '../storage/workspace-store.js';
 const RECOVERY_ERROR = 'Server restarted while task was running';
 export function recoverRunningWorkOnStartup(ctxFactory) {
     for (const workspace of listWorkspaces()) {
         const ctx = ctxFactory?.(workspace.id);
+        // 1. Mark running tasks as failed
         const failedTasks = taskService.markRunningTasksFailed(workspace.id, RECOVERY_ERROR);
         for (const task of failedTasks) {
             ctx?.broadcast('task.status_changed', { taskId: task.id, from: 'running', to: task.status });
             ctx?.broadcast('task.updated', task);
         }
+        // 2. Mark in_progress issues as error
         const inProgressIssues = issueService.list(workspace.id)
             .filter((issue) => issue.status === 'in_progress');
         for (const issue of inProgressIssues) {
@@ -20,6 +24,27 @@ export function recoverRunningWorkOnStartup(ctxFactory) {
             ctx?.broadcast('issue.status_changed', { issueId: issue.id, from: issue.status, to: 'error' });
             ctx?.broadcast('issue.updated', updated);
         }
+        // 3. Mark streaming/pending/waiting_for_user channel messages as error
+        const channels = channelService.listChannels(workspace.id);
+        for (const channel of channels) {
+            const messages = messageService.listMessages(workspace.id, channel.id);
+            for (const message of messages) {
+                if (message.status !== 'streaming' && message.status !== 'pending' && message.status !== 'waiting_for_user')
+                    continue;
+                const updated = messageService.updateMessage(workspace.id, channel.id, message.id, {
+                    status: 'error',
+                    parts: message.parts?.map((part) => {
+                        if ('status' in part && part.status === 'streaming') {
+                            return { ...part, status: 'completed' };
+                        }
+                        return part;
+                    }),
+                });
+                if (updated) {
+                    ctx?.broadcast('channel.message.updated', updated);
+                }
+            }
+        }
     }
 }
 export async function retryErrorIssues(workspaceId, ctx) {

package/dist/services/notification-center.js

@@ -46,6 +46,15 @@ export function clearAll(workspaceId) {
     writeAll(workspaceId, []);
     broadcastToWorkspace(workspaceId, 'notification.cleared', null);
 }
+export function removeNotification(workspaceId, notificationId) {
+    const all = readAll(workspaceId);
+    const idx = all.findIndex((n) => n.id === notificationId);
+    if (idx === -1)
+        return null;
+    const [removed] = all.splice(idx, 1);
+    writeAll(workspaceId, all);
+    return removed;
+}
 export function unreadCount(workspaceId) {
     return readAll(workspaceId).filter((n) => !n.read).length;
 }

package/dist/services/output-style.js

@@ -25,7 +25,14 @@ function writeMeta(meta) {
     writeFileSync(getMetaPath(), JSON.stringify(meta, null, 2), 'utf-8');
 }
 export function listOutputStyles() {
-    return readMeta().templates;
+    const templates = readMeta().templates;
+    const agents = listTemplates();
+    return templates.map((tmpl) => ({
+        ...tmpl,
+        boundAgents: agents
+            .filter((a) => a.outputStyle === tmpl.name || a.outputStyle === tmpl.id)
+            .map((a) => ({ id: a.id, name: a.name || a.id, avatarUrl: a.avatarUrl })),
+    }));
 }
 export function resolveOutputStyleTemplate(ref) {
     const needle = sanitizeOutputStyleName(ref);

package/dist/services/plugin.js

@@ -0,0 +1,257 @@
+import { ensureDir, getDataDir, readJsonFile, writeJsonFile } from '../storage/json-store.js';
+import { cpSync, existsSync, readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { builtinModules } from 'node:module';
+import vm from 'node:vm';
+const require = createRequire(import.meta.url);
+const STATE_FILE = () => path.join(pluginsDir(), 'state.json');
+function templatesPluginsDir() {
+    const candidates = [
+        path.resolve(process.cwd(), 'packages/templates/plugins'),
+        path.resolve(process.cwd(), '../templates/plugins'),
+        path.resolve(process.cwd(), 'templates/plugins'),
+    ];
+    return candidates.find(candidate => existsSync(candidate)) || candidates[0];
+}
+function pluginsDir() {
+    return path.join(getDataDir(), 'plugins');
+}
+function pluginDir(pluginId) {
+    return path.join(pluginsDir(), pluginId);
+}
+function resolvePluginDir(pluginId) {
+    const direct = pluginDir(pluginId);
+    if (existsSync(direct))
+        return direct;
+    const root = pluginsDir();
+    if (!existsSync(root))
+        return null;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const dir = path.join(root, entry.name);
+        const manifest = readManifestFromDir(dir);
+        if ((manifest?.id || entry.name) === pluginId)
+            return dir;
+    }
+    return null;
+}
+function readState() {
+    return readJsonFile(STATE_FILE()) ?? { enabled: {}, config: {} };
+}
+function writeState(state) {
+    writeJsonFile(STATE_FILE(), state);
+}
+function readManifestFromDir(dir) {
+    const candidates = ['plugin.json', 'manifest.json', 'info.json', 'web-plugin.json', 'package.json'];
+    for (const filename of candidates) {
+        const manifest = readJsonFile(path.join(dir, filename));
+        if (manifest?.id || manifest?.name)
+            return manifest;
+    }
+    return null;
+}
+function normalizePlugin(dirName, manifest, state) {
+    const id = String(manifest.id || dirName);
+    return {
+        id,
+        name: String(manifest.name || id),
+        version: String(manifest.version || '0.0.0'),
+        description: String(manifest.description || ''),
+        author: manifest.author || { name: 'Unknown' },
+        tags: Array.isArray(manifest.tags) ? manifest.tags : [],
+        hasView: Boolean(manifest.hasView),
+        hasWorkflow: Boolean(manifest.hasWorkflow || manifest.workflowNodes?.length || manifest.entries?.workflow),
+        type: manifest.type,
+        enabled: state.enabled[id] ?? Boolean(manifest.enabled),
+        config: Array.isArray(manifest.config) ? manifest.config : [],
+        iconPath: manifest.iconPath || '',
+    };
+}
+function getManifest(pluginId) {
+    const dir = resolvePluginDir(pluginId);
+    return dir ? readManifestFromDir(dir) : null;
+}
+function createRequireStub() {
+    const target = () => createRequireStub();
+    return new Proxy(target, {
+        get: (_target, prop) => {
+            if (prop === 'then')
+                return undefined;
+            if (prop === Symbol.toPrimitive)
+                return () => '';
+            return createRequireStub();
+        },
+        apply: () => createRequireStub(),
+        construct: () => createRequireStub(),
+    });
+}
+function loadCommonJsWorkflowNodes(workflowPath) {
+    const source = readFileSync(workflowPath, 'utf-8');
+    const module = { exports: {} };
+    const localRequire = (request) => {
+        const normalized = request.replace(/^node:/, '');
+        if (builtinModules.includes(normalized))
+            return require(request);
+        return createRequireStub();
+    };
+    const script = new vm.Script(`(function(require, module, exports, __filename, __dirname) {\n${source}\n})`, { filename: workflowPath });
+    const runner = script.runInNewContext({ console, Buffer, URL, URLSearchParams, setTimeout, clearTimeout });
+    runner(localRequire, module, module.exports, workflowPath, path.dirname(workflowPath));
+    const payload = module.exports;
+    if (Array.isArray(payload))
+        return payload;
+    return Array.isArray(payload?.nodes) ? payload.nodes : [];
+}
+function loadCommonJsWorkflowModule(workflowPath) {
+    const source = readFileSync(workflowPath, 'utf-8');
+    const module = { exports: {} };
+    const localRequire = createRequire(workflowPath);
+    const script = new vm.Script(`(function(require, module, exports, __filename, __dirname) {\n${source}\n})`, { filename: workflowPath });
+    const runner = script.runInNewContext({ console, Buffer, URL, URLSearchParams, setTimeout, clearTimeout });
+    runner(localRequire, module, module.exports, workflowPath, path.dirname(workflowPath));
+    const payload = module.exports;
+    const rawNodes = Array.isArray(payload) ? payload : Array.isArray(payload?.nodes) ? payload.nodes : [];
+    const handlers = new Map();
+    const nodes = rawNodes.map((node) => {
+        const { handler, ...serializable } = node;
+        if (typeof handler === 'function' && typeof serializable.type === 'string') {
+            handlers.set(serializable.type, handler);
+        }
+        return serializable;
+    });
+    return { nodes, handlers };
+}
+export function listPlugins() {
+    const root = pluginsDir();
+    ensureDir(root);
+    const state = readState();
+    return readdirSync(root, { withFileTypes: true })
+        .filter(entry => entry.isDirectory())
+        .map((entry) => {
+        const manifest = readManifestFromDir(path.join(root, entry.name));
+        return manifest ? normalizePlugin(entry.name, manifest, state) : null;
+    })
+        .filter((plugin) => Boolean(plugin));
+}
+export function listWorkflowPlugins() {
+    return listPlugins().filter(plugin => plugin.hasWorkflow);
+}
+export function setPluginEnabled(pluginId, enabled) {
+    const state = readState();
+    state.enabled[pluginId] = enabled;
+    writeState(state);
+    const plugin = listPlugins().find(item => item.id === pluginId);
+    if (!plugin)
+        throw new Error('Plugin not found');
+    return plugin;
+}
+function findTemplatePluginDir(pluginId) {
+    const root = templatesPluginsDir();
+    if (!existsSync(root))
+        return null;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const dir = path.join(root, entry.name);
+        const manifest = readManifestFromDir(dir);
+        if ((manifest?.id || entry.name) === pluginId)
+            return dir;
+    }
+    return null;
+}
+export function installTemplatePlugin(pluginId) {
+    const sourceDir = findTemplatePluginDir(pluginId);
+    if (!sourceDir)
+        throw new Error('Template plugin not found');
+    const manifest = readManifestFromDir(sourceDir);
+    const id = String(manifest?.id || path.basename(sourceDir));
+    const targetDir = path.join(pluginsDir(), path.basename(sourceDir));
+    ensureDir(pluginsDir());
+    if (!existsSync(targetDir)) {
+        cpSync(sourceDir, targetDir, {
+            recursive: true,
+            filter: (src) => !src.split(path.sep).includes('node_modules'),
+        });
+    }
+    return setPluginEnabled(id, true);
+}
+export function getPluginConfig(pluginId) {
+    const state = readState();
+    const manifest = getManifest(pluginId);
+    const defaults = {};
+    for (const field of manifest?.config || []) {
+        defaults[field.key] = field.value ?? '';
+    }
+    return { ...defaults, ...(state.config[pluginId] || {}) };
+}
+export function savePluginConfig(pluginId, data) {
+    const state = readState();
+    state.config[pluginId] = data;
+    writeState(state);
+    return { success: true };
+}
+function getWorkflowEntryPath(pluginId) {
+    const manifest = getManifest(pluginId);
+    if (!manifest)
+        return null;
+    const dir = resolvePluginDir(pluginId);
+    if (!dir)
+        return null;
+    const workflowEntry = manifest.entries?.workflow || 'workflow.json';
+    const workflowPath = path.join(dir, workflowEntry);
+    return existsSync(workflowPath) ? workflowPath : null;
+}
+export function getWorkflowNodes(pluginId) {
+    const manifest = getManifest(pluginId);
+    if (!manifest)
+        throw new Error('Plugin not found');
+    if (Array.isArray(manifest.workflowNodes))
+        return manifest.workflowNodes;
+    const workflowPath = getWorkflowEntryPath(pluginId);
+    if (!workflowPath)
+        return [];
+    if (workflowPath.endsWith('.js') || workflowPath.endsWith('.cjs')) {
+        return loadCommonJsWorkflowNodes(workflowPath);
+    }
+    const payload = readJsonFile(workflowPath);
+    if (Array.isArray(payload))
+        return payload;
+    return Array.isArray(payload?.nodes) ? payload.nodes : [];
+}
+function getExecutablePluginByNodeType(nodeType) {
+    for (const plugin of listWorkflowPlugins()) {
+        if (!plugin.enabled)
+            continue;
+        const workflowPath = getWorkflowEntryPath(plugin.id);
+        if (!workflowPath || (!workflowPath.endsWith('.js') && !workflowPath.endsWith('.cjs')))
+            continue;
+        try {
+            const { handlers } = loadCommonJsWorkflowModule(workflowPath);
+            const handler = handlers.get(nodeType);
+            if (handler)
+                return { plugin, handler };
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export function canExecuteWorkflowNode(nodeType) {
+    return Boolean(getExecutablePluginByNodeType(nodeType));
+}
+export async function executeWorkflowNode(nodeType, args, hooks) {
+    const executable = getExecutablePluginByNodeType(nodeType);
+    if (!executable)
+        throw new Error(`Plugin node is not enabled or has no executable handler: ${nodeType}`);
+    return executable.handler({
+        api: {},
+        nodeId: '',
+        nodeLabel: nodeType,
+        upstream: {},
+        logger: hooks.logger,
+    }, args);
+}
+//# sourceMappingURL=plugin.js.map

package/dist/services/prompt-template.js

@@ -24,7 +24,14 @@ function writeMeta(meta) {
     writeFileSync(getMetaPath(), JSON.stringify(meta, null, 2), 'utf-8');
 }
 export function listPromptTemplates() {
-    return readMeta().templates;
+    const templates = readMeta().templates;
+    const agents = listTemplates();
+    return templates.map((tmpl) => ({
+        ...tmpl,
+        boundAgents: agents
+            .filter((a) => a.systemPrompt === tmpl.content)
+            .map((a) => ({ id: a.id, name: a.name || a.id, avatarUrl: a.avatarUrl })),
+    }));
 }
 export function createPromptTemplate(name, content, storeId) {
     const meta = readMeta();

package/dist/services/pty.js

@@ -3,9 +3,17 @@ import { v4 as uuid } from 'uuid';
 import { accessSync, constants } from 'node:fs';
 const MAX_BUFFER_LINES = 1000;
 const DEFAULT_READ_LIMIT = 100;
+const DEBUG_TERMINAL_DUP = '[DEBUG-terminal-dup]';
 const sessions = new Map();
 export function createSession(workspaceId, cwd, onOutput, onExit, shell, env, sessionId) {
     const id = sessionId || uuid();
+    console.log(DEBUG_TERMINAL_DUP, 'server pty.createSession start', {
+        workspaceId,
+        sessionId: id,
+        cwd,
+        shell,
+        existingSessionIds: Array.from(sessions.keys()),
+    });
     if (sessions.has(id)) {
         throw new Error(`Terminal session already exists: ${id}`);
     }
@@ -26,6 +34,12 @@ export function createSession(workspaceId, cwd, onOutput, onExit, shell, env, se
     });
     const session = { id, pty: ptyProcess, workspaceId, cwd, shell: resolvedShell, buffer: [], output: '' };
     ptyProcess.onData((data) => {
+        console.log(DEBUG_TERMINAL_DUP, 'server pty.onData', {
+            workspaceId,
+            sessionId: id,
+            outputLength: data.length,
+            preview: data.slice(0, 80),
+        });
         session.buffer.push(data);
         if (session.buffer.length > MAX_BUFFER_LINES) {
             session.buffer = session.buffer.slice(-MAX_BUFFER_LINES);
@@ -35,6 +49,12 @@ export function createSession(workspaceId, cwd, onOutput, onExit, shell, env, se
     });
     ptyProcess.onExit(({ exitCode }) => onExit(id, exitCode ?? 0));
     sessions.set(id, session);
+    console.log(DEBUG_TERMINAL_DUP, 'server pty.createSession stored', {
+        workspaceId,
+        sessionId: id,
+        resolvedShell,
+        sessionCount: sessions.size,
+    });
     return id;
 }
 export function write(sessionId, data) {