claude-ws 0.4.8 → 0.4.9-beta.2

package/eslint.config.mjs

@@ -5,6 +5,20 @@ import nextTs from "eslint-config-next/typescript";
 const eslintConfig = defineConfig([
   ...nextVitals,
   ...nextTs,
+  {
+    rules: {
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-require-imports": "off",
+      "react-hooks/preserve-manual-memoization": "off",
+      "react-hooks/refs": "off",
+      "react-hooks/set-state-in-effect": "off",
+      "react-hooks/immutability": "off",
+      "react-hooks/purity": "off",
+      "react-hooks/static-components": "off",
+      "@next/next/no-html-link-for-pages": "off",
+      "prefer-const": "off",
+    },
+  },
   // Override default ignores of eslint-config-next.
   globalIgnores([
     // Default ignores of eslint-config-next:

package/next.config.ts

@@ -13,7 +13,14 @@ const nextConfig: NextConfig = {
   // Enable gzip compression for responses
   compress: true,
   // Transpile xterm packages for proper CSS/ESM handling
-  transpilePackages: ['@xterm/xterm', '@xterm/addon-fit', '@xterm/addon-web-links', '@pierre/diffs'],
+  transpilePackages: [
+    '@xterm/xterm', '@xterm/addon-fit', '@xterm/addon-web-links', '@pierre/diffs',
+    // Force Turbopack to compile these as a single bundle to avoid
+    // "module factory not available" HMR errors with shared @lezer/common
+    '@codemirror/state', '@codemirror/view', '@codemirror/language',
+    '@lezer/common', '@lezer/highlight', '@lezer/lr',
+    '@uiw/react-codemirror',
+  ],
   outputFileTracingRoot: path.join(__dirname),
   outputFileTracingIncludes: {
     '/': ['./src/**/*'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-ws",
-  "version": "0.4.8",
+  "version": "0.4.9-beta.2",
   "private": false,
   "description": "AI-powered workspace for solo CEOs and indie builders — manage your entire business with AI agents, not just code. Kanban board, code editor, Git integration, claw agent hub, local-first SQLite.",
   "keywords": [
@@ -66,6 +66,9 @@
     "pnpm": ">=9.0.0"
   },
   "pnpm": {
+    "overrides": {
+      "axios": "0.30.3"
+    },
     "onlyBuiltDependencies": [
       "@parcel/watcher",
       "@swc/core",
@@ -81,6 +84,11 @@
   "scripts": {
     "postinstall": "node scripts/postinstall-optional-native-deps.js",
     "dev": "cross-env CLAUDECODE= tsx server.ts",
+    "pm2": "pm2 start ecosystem.config.js && pm2 save",
+    "pm2-restart": "pm2 restart claudews",
+    "pm2-stop": "pm2 stop claudews",
+    "pm2-logs": "pm2 logs claudews",
+    "pm2-monit": "pm2 monit",
     "build": "cross-env NODE_ENV=production next build",
     "start": "cross-env NODE_ENV=production tsx server.ts",
     "db:generate": "drizzle-kit generate",
@@ -119,6 +127,7 @@
     "@radix-ui/react-dialog": "^1.1.15",
     "@radix-ui/react-dropdown-menu": "^2.1.16",
     "@radix-ui/react-label": "^2.1.8",
+    "@radix-ui/react-popover": "^1.1.15",
     "@radix-ui/react-scroll-area": "^1.2.10",
     "@radix-ui/react-select": "^2.2.6",
     "@radix-ui/react-separator": "^1.1.8",
@@ -130,6 +139,7 @@
     "@tailwindcss/postcss": "^4.2.2",
     "@types/adm-zip": "^0.5.8",
     "@types/better-sqlite3": "^7.6.13",
+    "@types/js-yaml": "^4.0.9",
     "@types/compression": "^1.8.1",
     "@types/dompurify": "^3.2.0",
     "@types/node": "^20.19.37",
@@ -191,8 +201,5 @@
   "optionalDependencies": {
     "@homebridge/node-pty-prebuilt-multiarch": "^0.13.1",
     "node-pty": "^1.1.0"
-  },
-  "devDependencies": {
-    "@types/js-yaml": "^4.0.9"
   }
 }

package/packages/agentic-sdk/src/routes/projects/route.ts

@@ -12,8 +12,8 @@ export default async function projectsRoute(fastify: FastifyInstance) {
 
   fastify.post('/api/projects', async (request, reply) => {
     try {
-      const { name, path: projectPath } = request.body as any;
-      const project = await fastify.services.project.createProject({ name, path: projectPath });
+      const { id, projectId, name, path: projectPath } = request.body as any;
+      const project = await fastify.services.project.createProject({ id: projectId || id, name, path: projectPath });
       return reply.code(201).send(project);
     } catch (error: any) {
       if (error instanceof ProjectValidationError) {

package/packages/agentic-sdk/src/services/agent-factory/upload-analysis-and-import.ts

@@ -37,7 +37,12 @@ export async function analyzeForPreview(extractDir: string, agentFactoryDir: str
 
     if (entry.isDirectory()) {
       if (entry.name === 'skills' || entry.name === 'commands' || entry.name === 'agents') {
-        await previewDirectoryContents(entryPath, agentFactoryDir, items, entry.name as 'skill' | 'command' | 'agent');
+        const componentType = entry.name === 'skills'
+          ? 'skill'
+          : entry.name === 'commands'
+            ? 'command'
+            : 'agent';
+        await previewDirectoryContents(entryPath, agentFactoryDir, items, componentType);
       } else {
         const subEntries = await readdir(entryPath, { withFileTypes: true });
         const hasSubdirs = subEntries.some(e =>
@@ -110,8 +115,12 @@ export async function analyzeAndOrganize(extractDir: string, agentFactoryDir: st
 
     if (entry.isDirectory()) {
       if (entry.name === 'skills' || entry.name === 'commands' || entry.name === 'agents') {
-        const targetDir = join(agentFactoryDir, entry.name);
-        await moveDirectoryContents(entryPath, targetDir, items, entry.name as 'skill' | 'command' | 'agent');
+        const componentType = entry.name === 'skills'
+          ? 'skill'
+          : entry.name === 'commands'
+            ? 'command'
+            : 'agent';
+        await moveDirectoryContents(entryPath, agentFactoryDir, items, componentType);
       } else {
         const subEntries = await readdir(entryPath, { withFileTypes: true });
         const hasSubdirs = subEntries.some(e =>
@@ -165,11 +174,11 @@ export async function importFromSession(
     if (item.type === 'agent_set') {
       targetPath = join(targetBaseDir, 'agent-sets', item.name);
     } else if (item.type === 'skill') {
-      targetPath = join(targetBaseDir, 'skills', item.name, 'SKILL.md');
+      targetPath = join(targetBaseDir, 'skills', item.relativePath || item.name, 'SKILL.md');
     } else if (item.type === 'agent') {
-      targetPath = join(targetBaseDir, 'agents', `${item.name}.md`);
+      targetPath = join(targetBaseDir, 'agents', item.relativePath || `${item.name}.md`);
     } else {
-      targetPath = join(targetBaseDir, 'commands', `${item.name}.md`);
+      targetPath = join(targetBaseDir, 'commands', item.relativePath || `${item.name}.md`);
     }
 
     if (item.type === 'agent_set') {
@@ -207,7 +216,11 @@ export async function importFromSession(
           description = extractDescriptionFromMarkdown(content);
         } catch { /* ignore */ }
 
-        const componentType = item.type === 'unknown' ? 'command' : item.type;
+        const componentType = item.type === 'skill'
+          ? 'skill'
+          : item.type === 'agent'
+            ? 'agent'
+            : 'command';
         await registryService.upsertPlugin(item.name, componentType, {
           description,
           sourcePath: targetPath,

package/packages/agentic-sdk/src/services/agent-factory/upload-filesystem-helpers.ts

@@ -11,6 +11,8 @@ export interface ExtractedItem {
   sourcePath: string;
   targetPath: string;
   name: string;
+  // Relative path under skills/commands/agents root. Used to preserve command namespaces.
+  relativePath?: string;
   componentCount?: number;
 }
 
@@ -71,9 +73,10 @@ export async function moveDirectory(source: string, target: string): Promise<voi
 
 export async function moveDirectoryContents(
   sourceDir: string,
-  targetDir: string,
+  targetBaseDir: string,
   items: ExtractedItem[],
-  type: 'skill' | 'command' | 'agent'
+  type: 'skill' | 'command' | 'agent',
+  relativePrefix = ''
 ): Promise<void> {
   const entries = await readdir(sourceDir, { withFileTypes: true });
 
@@ -81,15 +84,57 @@ export async function moveDirectoryContents(
     if (entry.name.startsWith('.')) continue;
 
     const sourcePath = join(sourceDir, entry.name);
-    const targetPath = join(targetDir, entry.name);
+    const relPath = relativePrefix ? join(relativePrefix, entry.name) : entry.name;
+
+    if (type === 'skill') {
+      if (!entry.isDirectory()) continue;
+      const skillMdPath = join(sourcePath, 'SKILL.md');
+      if (existsSync(skillMdPath)) {
+        const targetPath = join(targetBaseDir, 'skills', relPath);
+        await moveDirectory(sourcePath, targetPath);
+        items.push({
+          type: 'skill',
+          sourcePath,
+          targetPath: join(targetPath, 'SKILL.md'),
+          name: relPath,
+          relativePath: relPath,
+        });
+      } else {
+        await moveDirectoryContents(sourcePath, targetBaseDir, items, type, relPath);
+      }
+      continue;
+    }
 
-    if (entry.isDirectory()) {
-      await moveDirectory(sourcePath, targetPath);
-      items.push({ type, sourcePath, targetPath, name: entry.name });
-    } else if (entry.isFile()) {
+    if (type === 'command') {
+      if (entry.isDirectory()) {
+        await moveDirectoryContents(sourcePath, targetBaseDir, items, type, relPath);
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        const targetPath = join(targetBaseDir, 'commands', relPath);
+        await mkdir(dirname(targetPath), { recursive: true });
+        await copyFile(sourcePath, targetPath);
+        items.push({
+          type: 'command',
+          sourcePath,
+          targetPath,
+          name: relPath.replace(/\.md$/i, '').split('/').join(':'),
+          relativePath: relPath,
+        });
+      }
+      continue;
+    }
+
+    // Agents: only allow markdown files directly under agents/ (no subdirectories)
+    if (!relativePrefix && entry.isFile() && entry.name.endsWith('.md')) {
+      const targetPath = join(targetBaseDir, 'agents', entry.name);
       await mkdir(dirname(targetPath), { recursive: true });
       await copyFile(sourcePath, targetPath);
-      items.push({ type, sourcePath, targetPath, name: entry.name });
+      items.push({
+        type: 'agent',
+        sourcePath,
+        targetPath,
+        name: basename(entry.name, '.md'),
+        relativePath: entry.name,
+      });
     }
   }
 }
@@ -173,9 +218,10 @@ export async function previewDirectory(
 
 export async function previewDirectoryContents(
   sourceDir: string,
-  targetDir: string,
+  targetBaseDir: string,
   items: ExtractedItem[],
-  type: 'skill' | 'command' | 'agent'
+  type: 'skill' | 'command' | 'agent',
+  relativePrefix = ''
 ): Promise<void> {
   const entries = await readdir(sourceDir, { withFileTypes: true });
 
@@ -183,12 +229,49 @@ export async function previewDirectoryContents(
     if (entry.name.startsWith('.')) continue;
 
     const sourcePath = join(sourceDir, entry.name);
-    const targetPath = join(targetDir, entry.name);
+    const relPath = relativePrefix ? join(relativePrefix, entry.name) : entry.name;
+
+    if (type === 'skill') {
+      if (!entry.isDirectory()) continue;
+      const skillMdPath = join(sourcePath, 'SKILL.md');
+      if (existsSync(skillMdPath)) {
+        items.push({
+          type: 'skill',
+          sourcePath,
+          targetPath: join(targetBaseDir, 'skills', relPath, 'SKILL.md'),
+          name: relPath,
+          relativePath: relPath,
+        });
+      } else {
+        await previewDirectoryContents(sourcePath, targetBaseDir, items, type, relPath);
+      }
+      continue;
+    }
 
-    if (entry.isDirectory()) {
-      items.push({ type, sourcePath, targetPath, name: entry.name });
-    } else if (entry.isFile() && entry.name.endsWith('.md')) {
-      items.push({ type, sourcePath, targetPath, name: entry.name });
+    if (type === 'command') {
+      if (entry.isDirectory()) {
+        await previewDirectoryContents(sourcePath, targetBaseDir, items, type, relPath);
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        items.push({
+          type: 'command',
+          sourcePath,
+          targetPath: join(targetBaseDir, 'commands', relPath),
+          name: relPath.replace(/\.md$/i, '').split('/').join(':'),
+          relativePath: relPath,
+        });
+      }
+      continue;
+    }
+
+    // Agents: only allow markdown files directly under agents/ (no subdirectories)
+    if (!relativePrefix && entry.isFile() && entry.name.endsWith('.md')) {
+      items.push({
+        type: 'agent',
+        sourcePath,
+        targetPath: join(targetBaseDir, 'agents', entry.name),
+        name: basename(entry.name, '.md'),
+        relativePath: entry.name,
+      });
     }
   }
 }

package/packages/agentic-sdk/src/services/attempt/attempt-creation-orchestrator.ts

@@ -67,10 +67,11 @@ interface OrchestratorDeps {
   /** Callback to start the agent process (runtime singleton, lives outside SDK) */
   startAgent: (params: AgentStartParams) => void;
   defaultBasePath: string;
+  onProjectForceCreated?: (project: any) => Promise<void> | void;
 }
 
 export function createAttemptOrchestrator(deps: OrchestratorDeps) {
-  const { taskService, projectService, attemptService, forceCreateService, sessionManager, startAgent, defaultBasePath } = deps;
+  const { taskService, projectService, attemptService, forceCreateService, sessionManager, startAgent, defaultBasePath, onProjectForceCreated } = deps;
 
   return {
     /**
@@ -91,11 +92,14 @@ export function createAttemptOrchestrator(deps: OrchestratorDeps) {
       }
 
       // Resolve task (lookup or force-create)
-      const task = await this.resolveTask(input);
+      const { task, projectCreatedByForceCreate } = await this.resolveTask(input);
 
       // Resolve project
       const project = await projectService.getById(task.projectId);
       if (!project) throw new AttemptValidationError('Project not found', 404);
+      if (projectCreatedByForceCreate && onProjectForceCreated) {
+        await onProjectForceCreated(project);
+      }
 
       // Create attempt record
       const attempt = await attemptService.create({
@@ -166,18 +170,18 @@ export function createAttemptOrchestrator(deps: OrchestratorDeps) {
     },
 
     /** Resolve task: find existing or force-create project+task */
-    async resolveTask(input: AttemptCreationInput): Promise<any> {
+    async resolveTask(input: AttemptCreationInput): Promise<{ task: any; projectCreatedByForceCreate: boolean }> {
       const { taskId, force_create, projectId, projectName, taskTitle, projectRootPath } = input;
 
       if (!force_create) {
         const task = await taskService.getById(taskId);
         if (!task) throw new AttemptValidationError('Task not found', 404);
-        return task;
+        return { task, projectCreatedByForceCreate: false };
       }
 
       // Force-create: check if task already exists
       const existingTask = await taskService.getById(taskId);
-      if (existingTask) return existingTask;
+      if (existingTask) return { task: existingTask, projectCreatedByForceCreate: false };
 
       // Task doesn't exist — force-create project + task
       if (!projectId) throw new AttemptValidationError('projectId required', 400);
@@ -185,7 +189,7 @@ export function createAttemptOrchestrator(deps: OrchestratorDeps) {
       const result = await forceCreateService.ensureProjectAndTask({
         taskId, projectId, projectName, taskTitle, projectRootPath, defaultBasePath,
       });
-      return result.task;
+      return { task: result.task, projectCreatedByForceCreate: Boolean(result.projectCreated) };
     },
 
     /** Poll attempt status until terminal state or timeout */

package/packages/agentic-sdk/src/services/force-create-project-and-task.ts

@@ -31,6 +31,7 @@ export interface ForceCreateParams {
 export interface ForceCreateResult {
   task: typeof schema.tasks.$inferSelect;
   project: typeof schema.projects.$inferSelect;
+  projectCreated: boolean;
 }
 
 export function createForceCreateService(db: any) {
@@ -42,6 +43,7 @@ export function createForceCreateService(db: any) {
      */
     async ensureProjectAndTask(params: ForceCreateParams): Promise<ForceCreateResult> {
       const { taskId, projectId, projectName, taskTitle, projectRootPath, defaultBasePath } = params;
+      let projectCreated = false;
 
       // Check if project exists
       let project = await db.select().from(schema.projects)
@@ -79,6 +81,7 @@ export function createForceCreateService(db: any) {
           path: projectPath,
           createdAt: Date.now(),
         });
+        projectCreated = true;
 
         project = await db.select().from(schema.projects)
           .where(eq(schema.projects.id, projectId)).get();
@@ -114,7 +117,7 @@ export function createForceCreateService(db: any) {
       const task = await db.select().from(schema.tasks)
         .where(eq(schema.tasks.id, taskId)).get();
 
-      return { task, project };
+      return { task, project, projectCreated };
     },
   };
 }

package/packages/agentic-sdk/src/services/project/project-crud.ts

@@ -97,7 +97,7 @@ export function createProjectService(db: any) {
     },
 
     /** Validate + setup directory + create project. Throws ProjectValidationError on constraint violation. */
-    async createProject(data: { name: string; path: string }) {
+    async createProject(data: { id?: string; name: string; path: string }) {
       if (!data.name || !data.path) throw new ProjectValidationError('Name and path are required', 400);
       try {
         await this.setupProjectDirectory(data.path);

package/scripts/build-test-pm2.sh

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT_DIR"
+
+APP_NAME="${PM2_APP_NAME:-claudews}"
+ECOSYSTEM_FILE="${PM2_ECOSYSTEM_FILE:-ecosystem.config.js}"
+BUILD_CMD="${BUILD_CMD:-pnpm build}"
+
+# Resolve health URL from env override or fallback to localhost:PORT/api/tunnel/status
+if [[ -n "${HEALTH_URL:-}" ]]; then
+  HEALTH_URL="$HEALTH_URL"
+else
+  PORT_VALUE="${PORT:-8556}"
+  if [[ -f .env ]]; then
+    ENV_PORT="$(grep -E '^PORT=' .env | tail -n1 | cut -d'=' -f2- | tr -d '"' | tr -d "'" || true)"
+    if [[ -n "$ENV_PORT" ]]; then
+      PORT_VALUE="$ENV_PORT"
+    fi
+  fi
+  HEALTH_URL="http://127.0.0.1:${PORT_VALUE}/api/tunnel/status"
+fi
+
+RETRY_COUNT="${HEALTH_RETRY_COUNT:-20}"
+RETRY_DELAY_SECONDS="${HEALTH_RETRY_DELAY_SECONDS:-2}"
+
+need_cmd() {
+  if ! command -v "$1" >/dev/null 2>&1; then
+    echo "❌ Missing required command: $1"
+    exit 1
+  fi
+}
+
+need_cmd pnpm
+need_cmd pm2
+need_cmd curl
+
+echo "📦 Building project..."
+$BUILD_CMD
+
+echo "🚀 Starting/Restarting PM2 app: $APP_NAME"
+if pm2 describe "$APP_NAME" >/dev/null 2>&1; then
+  pm2 restart "$APP_NAME" --update-env
+else
+  if [[ ! -f "$ECOSYSTEM_FILE" ]]; then
+    echo "❌ Ecosystem file not found: $ECOSYSTEM_FILE"
+    exit 1
+  fi
+
+  # Prefer starting the specific app in ecosystem; fallback to starting entire file.
+  if ! pm2 start "$ECOSYSTEM_FILE" --only "$APP_NAME"; then
+    pm2 start "$ECOSYSTEM_FILE"
+  fi
+fi
+
+pm2 save >/dev/null
+
+echo "🩺 Health check: $HEALTH_URL"
+attempt=1
+while (( attempt <= RETRY_COUNT )); do
+  if curl -fsS --max-time 8 "$HEALTH_URL" >/dev/null; then
+    echo "✅ Health check passed (attempt $attempt/$RETRY_COUNT)"
+    pm2 status "$APP_NAME"
+    echo "✅ PM2 build + test completed"
+    exit 0
+  fi
+
+  echo "⏳ Waiting for service... ($attempt/$RETRY_COUNT)"
+  sleep "$RETRY_DELAY_SECONDS"
+  ((attempt++))
+done
+
+echo "❌ Health check failed after $RETRY_COUNT attempts"
+pm2 status "$APP_NAME" || true
+echo "--- Last 120 lines of PM2 logs for $APP_NAME ---"
+pm2 logs "$APP_NAME" --lines 120 --nostream || true
+exit 1

package/server.ts

@@ -52,6 +52,8 @@ import { usageTracker } from './src/lib/usage-tracker';
 import { workflowTracker } from './src/lib/workflow-tracker';
 import { gitStatsCache } from './src/lib/git-stats-collector';
 import { tunnelService } from './src/lib/tunnel-service';
+import { getMinioPullQueueWorker } from './src/lib/minio-pull-queue';
+import { getMinioPushQueueWorker } from './src/lib/minio-push-queue';
 import { createAutopilotManager, appendQuestionAnswer, appendSubagentEnded, appendTrackedTaskUpdate } from './src/lib/autopilot';
 import type { AutopilotMode } from './src/lib/autopilot';
 
@@ -63,6 +65,8 @@ const port = getPort();
 
 const app = next({ dev, hostname, port, turbopack: false });
 const handle = app.getRequestHandler();
+const minioPullQueueWorker = getMinioPullQueueWorker();
+const minioPushQueueWorker = getMinioPushQueueWorker();
 
 app.prepare().then(async () => {
   const httpServer = createServer((req, res) => {
@@ -224,14 +228,18 @@ app.prepare().then(async () => {
               const { mkdir } = await import('fs/promises');
               const { join } = await import('path');
 
-              const projectDirName = projectId;
-              const projectPath = projectRootPath
+              const projectDirName = `${projectId}-${projectName}`;
+              log.info({ projectRootPath, userCwd, projectDirName }, '[Socket] Debug project path creation');
+              const projectPath = (projectRootPath && projectRootPath.trim() !== '')
                 ? join(projectRootPath, projectDirName)
                 : join(userCwd, 'data', 'projects', projectDirName);
+              log.info({ projectPath, projectRootPath, userCwd }, '[Socket] Final project path');
 
               try {
+                const { setupProjectDefaults } = await import('./src/lib/project-utils');
                 await mkdir(projectPath, { recursive: true });
-                log.info({ projectPath }, '[Socket] Created project directory');
+                await setupProjectDefaults(projectPath, projectId);
+                log.info({ projectPath, projectId }, '[Socket] Created project directory and defaults');
               } catch (mkdirError: any) {
                 if (mkdirError?.code !== 'EEXIST') {
                   log.error({ mkdirError }, '[Socket] Failed to create project folder');
@@ -615,7 +623,7 @@ app.prepare().then(async () => {
 
             log.warn(`[Server] Auto-retried answer for ${attemptId} as new attempt ${newAttemptId}`);
           } catch (error) {
-            log.error({error},`[Server] Auto-retry failed for ${attemptId}:`);
+            log.error({ error }, `[Server] Auto-retry failed for ${attemptId}:`);
             socket.emit('error', { message: 'Auto-retry failed: ' + (error instanceof Error ? error.message : 'Unknown error') });
           }
         }
@@ -1632,9 +1640,9 @@ app.prepare().then(async () => {
               taskTitle: task?.title || 'Unknown',
               summary: expanded.summary,
             });
-          }).catch(() => {});
+          }).catch(() => { });
         }
-      }).catch(() => {});
+      }).catch(() => { });
     }
   });
 
@@ -1828,6 +1836,9 @@ app.prepare().then(async () => {
   httpServer.listen(port, () => {
     log.info(`> Ready on http://${hostname}:${port}`);
 
+    // Start MinIO sync queue workers with server lifecycle
+    minioPullQueueWorker.start();
+    minioPushQueueWorker.start();
     if (!process.env.NEXT_PUBLIC_URL) {
       log.warn('[Server] NEXT_PUBLIC_URL is not set. Access is limited to localhost only. Set NEXT_PUBLIC_URL in .env to enable remote access.');
     }
@@ -1851,6 +1862,13 @@ app.prepare().then(async () => {
     await tunnelService.stop();
     log.info('> Tunnel stopped');
 
+    // Stop MinIO sync queue workers
+    minioPullQueueWorker.stop();
+    log.info('> MinIO pull queue worker stopped');
+
+    minioPushQueueWorker.stop();
+    log.info('> MinIO push queue worker stopped');
+
     // Cancel all Claude agents first
     agentManager.cancelAll();
     log.info('> Cancelled all Claude agents');

package/src/app/[locale]/page.tsx

@@ -3,13 +3,7 @@
 import { useEffect, useState } from 'react';
 import { SearchProvider } from '@/components/search/search-provider';
 import { Header } from '@/components/header';
-import { Board } from '@/components/kanban/board';
-import { CreateTaskDialog } from '@/components/kanban/create-task-dialog';
-import { TaskDetailPanel } from '@/components/task/task-detail-panel';
-import { FloatingChatWindowsContainer } from '@/components/task/floating-chat-windows-container';
-import { SettingsPage } from '@/components/settings/settings-page';
-import { SetupDialog } from '@/components/settings/setup-dialog';
-import { SidebarPanel, FileTabsPanel, DiffTabsPanel } from '@/components/sidebar';
+import dynamic from 'next/dynamic';
 import { RightSidebar } from '@/components/right-sidebar';
 import { QuestionsPanel } from '@/components/questions/questions-panel';
 import { TeamView } from '@/components/team-view/team-view';
@@ -28,6 +22,45 @@ import { useKanbanKeyboardShortcuts } from '@/hooks/use-kanban-keyboard-shortcut
 import type { Task } from '@/types';
 import { useTranslations } from 'next-intl';
 
+// Lazy-load heavy components to isolate third-party chunks (@dnd-kit, @codemirror, @lezer)
+// and avoid Turbopack HMR "module factory not available" errors from stale browser cache.
+const Board = dynamic(
+  () => import('@/components/kanban/board').then(m => ({ default: m.Board })),
+  { ssr: false }
+);
+const CreateTaskDialog = dynamic(
+  () => import('@/components/kanban/create-task-dialog').then(m => ({ default: m.CreateTaskDialog })),
+  { ssr: false }
+);
+const TaskDetailPanel = dynamic(
+  () => import('@/components/task/task-detail-panel').then(m => ({ default: m.TaskDetailPanel })),
+  { ssr: false }
+);
+const FloatingChatWindowsContainer = dynamic(
+  () => import('@/components/task/floating-chat-windows-container').then(m => ({ default: m.FloatingChatWindowsContainer })),
+  { ssr: false }
+);
+const SettingsPage = dynamic(
+  () => import('@/components/settings/settings-page').then(m => ({ default: m.SettingsPage })),
+  { ssr: false }
+);
+const SetupDialog = dynamic(
+  () => import('@/components/settings/setup-dialog').then(m => ({ default: m.SetupDialog })),
+  { ssr: false }
+);
+const SidebarPanel = dynamic(
+  () => import('@/components/sidebar/sidebar-panel').then(m => ({ default: m.SidebarPanel })),
+  { ssr: false }
+);
+const FileTabsPanel = dynamic(
+  () => import('@/components/sidebar/file-browser/file-tabs-panel').then(m => ({ default: m.FileTabsPanel })),
+  { ssr: false }
+);
+const DiffTabsPanel = dynamic(
+  () => import('@/components/sidebar/git-changes/diff-tabs-panel').then(m => ({ default: m.DiffTabsPanel })),
+  { ssr: false }
+);
+
 function KanbanApp() {
   const tCommon = useTranslations('common');
   const [createTaskOpen, setCreateTaskOpen] = useState(false);