profclaw 0.0.1-beta.3 → 2.3.0

package/dist/server.js

@@ -6,15 +6,23 @@ import { createServer } from 'net';
 // Core imports - keep static only for truly essential boot utilities
 import { loadConfig } from './utils/config-loader.js';
 import { createContextualLogger } from './utils/logger.js';
+import { writePidFile, removePidFile } from './utils/pid-file.js';
 const appLog = createContextualLogger('Server');
 import { validateEnvironment, getConfiguredIntegrations, getConfiguredAIProviders } from './utils/env-validator.js';
 import { initApiTokensTable, tokenAuthMiddleware } from './auth/api-tokens.js';
 import { authMiddleware } from './auth/middleware.js';
 import { rateLimit } from './middleware/rate-limit.js';
 import { CreateTaskSchema } from './types/task.js';
-import { getMode, getModeLabel, hasCapability } from './core/deployment.js';
-import { registerRouteModules } from './server/route-loader.js';
+import { getMode, getModeLabel, hasCapability, getCapabilities } from './core/deployment.js';
+import { getRouteDefinitionsForMode, registerRouteModules } from './server/route-loader.js';
+import { validateBody, GatewayExecuteSchema } from './middleware/request-validator.js';
 const VERSION = '2.0.0';
+// Module-level startup state flags
+let degradedMode = false;
+let inMemoryStorageReminderInterval = null;
+// Runtime tracking state
+let runningPort = 0;
+let lastErrorMessage;
 let cachedSettings = null;
 function getAppSettings() {
     if (!cachedSettings) {
@@ -87,6 +95,13 @@ app.use('*', cors({
 // Authentication middleware — applied to all /api/* routes
 // Skips public routes (auth, setup, webhooks, messaging channels)
 app.use('/api/*', authMiddleware());
+// WS-1.4: In-memory storage warning header — set on every response when storage is ephemeral
+app.use('*', async (c, next) => {
+    await next();
+    if (degradedMode) {
+        c.res.headers.set('X-ProfClaw-Storage', 'ephemeral');
+    }
+});
 // HTTP rate limiting (sliding window, per-IP)
 const apiRateLimiter = rateLimit({
     maxRequests: parseInt(process.env['API_RATE_LIMIT'] ?? '100', 10),
@@ -100,131 +115,332 @@ app.use('/api/*', apiRateLimiter);
 app.use('/auth/*', authRateLimiter);
 // === Core Routes ===
 // Health check
+const serverStartTime = Date.now();
+async function checkDatabaseHealth() {
+    const start = Date.now();
+    try {
+        const { getDb } = await import('./storage/index.js');
+        const db = getDb();
+        if (!db)
+            return { status: 'error', message: 'Database not initialised' };
+        // Simple liveness query
+        await db.run('SELECT 1');
+        return { status: 'ok', latencyMs: Date.now() - start };
+    }
+    catch (err) {
+        return {
+            status: 'error',
+            latencyMs: Date.now() - start,
+            message: err instanceof Error ? err.message : 'Database check failed',
+        };
+    }
+}
+async function checkQueueHealth() {
+    try {
+        const { getQueueType } = await import('./queue/index.js');
+        const queueType = getQueueType();
+        if (!queueType)
+            return { status: 'warning', message: 'Queue not initialised' };
+        if (queueType === 'redis') {
+            // Test Redis reachability with a fresh connection
+            const redisUrl = process.env.REDIS_URL || 'redis://localhost:6379';
+            const start = Date.now();
+            try {
+                const IORedis = (await import('ioredis')).default;
+                const probe = new IORedis(redisUrl, { lazyConnect: true, connectTimeout: 2000, maxRetriesPerRequest: 0 });
+                await probe.connect();
+                await probe.ping();
+                await probe.disconnect();
+                return { status: 'ok', type: 'redis', latencyMs: Date.now() - start };
+            }
+            catch {
+                return { status: 'error', type: 'redis', latencyMs: Date.now() - start, message: 'Redis unreachable' };
+            }
+        }
+        return { status: 'ok', type: queueType };
+    }
+    catch {
+        return { status: 'ok', type: 'in-memory' };
+    }
+}
+async function checkOllamaHealth() {
+    const ollamaUrl = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+    const start = Date.now();
+    try {
+        const res = await fetch(`${ollamaUrl}/api/tags`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!res.ok)
+            return { status: 'error', latencyMs: Date.now() - start, message: `HTTP ${res.status}` };
+        const data = await res.json();
+        const modelCount = Array.isArray(data.models) ? data.models.length : 0;
+        return { status: 'ok', latencyMs: Date.now() - start, models: modelCount };
+    }
+    catch {
+        // Ollama is optional — not reachable means degraded, not unhealthy
+        return { status: 'warning', latencyMs: Date.now() - start, message: 'Ollama not reachable' };
+    }
+}
+async function checkDiskHealth() {
+    try {
+        const { statfs } = await import('node:fs/promises');
+        const stats = await statfs(process.cwd());
+        const freeBytes = stats.bfree * stats.bsize;
+        const freeGb = freeBytes / (1024 ** 3);
+        const WARN_THRESHOLD_BYTES = 100 * 1024 * 1024; // 100 MB
+        const status = freeBytes < WARN_THRESHOLD_BYTES ? 'warning' : 'ok';
+        return {
+            status,
+            freeGb: Math.round(freeGb * 100) / 100,
+            ...(status === 'warning' && { message: 'Low disk space (< 100 MB free)' }),
+        };
+    }
+    catch {
+        return { status: 'warning', message: 'Disk check unavailable' };
+    }
+}
+function checkMemoryHealth() {
+    const WARN_THRESHOLD = 90;
+    const mode = getMode();
+    const mem = process.memoryUsage();
+    const rssMb = Math.round(mem.rss / 1024 / 1024);
+    // Mode-specific RSS caps (absolute memory usage is more actionable than heap ratio)
+    const RSS_CAP_MB = { pico: 128, mini: 256, pro: 512 };
+    const capMb = RSS_CAP_MB[mode] ?? 512;
+    // Use RSS vs mode cap — heap ratio is misleading at small heap sizes
+    const usedPercent = Math.round((rssMb / capMb) * 100);
+    const status = usedPercent > WARN_THRESHOLD ? 'warning' : 'ok';
+    return {
+        status,
+        usedPercent,
+        ...(status === 'warning' && { message: `RSS ${rssMb}MB exceeds ${WARN_THRESHOLD}% of ${capMb}MB cap (${mode} mode)` }),
+    };
+}
 app.get('/health', async (c) => {
-    const { getHealthStatus } = await import('./cron/index.js');
-    const { getQueueType } = await import('./queue/index.js');
-    const agentHealth = getHealthStatus();
-    return c.json({
-        status: 'ok',
-        service: 'profclaw',
+    const [database, queue, ollama, disk] = await Promise.all([
+        checkDatabaseHealth(),
+        checkQueueHealth(),
+        checkOllamaHealth(),
+        checkDiskHealth(),
+    ]);
+    const memory = checkMemoryHealth();
+    const services = { database, queue, ollama, disk, memory };
+    const statuses = Object.values(services).map((s) => s.status);
+    const overallStatus = statuses.some((s) => s === 'error')
+        ? 'unhealthy'
+        : statuses.some((s) => s === 'warning')
+            ? 'degraded'
+            : 'ok';
+    // Gather queue depth
+    let queueDepth = { pending: 0, running: 0, total: 0 };
+    try {
+        const { getTasks } = await import('./queue/index.js');
+        const pending = getTasks({ status: 'pending' }).length + getTasks({ status: 'queued' }).length;
+        const running = getTasks({ status: 'in_progress' }).length;
+        queueDepth = { pending, running, total: pending + running };
+    }
+    catch {
+        // Queue not yet initialised — use zeroes
+    }
+    // Gather active agent sessions
+    let activeSessions = 0;
+    try {
+        const { getAgentRegistry } = await import('./adapters/registry.js');
+        activeSessions = getAgentRegistry().getActiveAdapters().length;
+    }
+    catch {
+        // Registry not yet initialised
+    }
+    const memUsage = process.memoryUsage();
+    const { loadavg: osLoadavg } = await import('node:os');
+    const body = {
+        status: overallStatus,
+        services,
         version: VERSION,
-        mode: getMode(),
-        queue: getQueueType() || 'not_initialized',
-        timestamp: new Date().toISOString(),
-        agents: agentHealth,
-    });
+        uptime: Math.floor((Date.now() - serverStartTime) / 1000),
+        sseClients: sseConnections.size,
+        activeSessions,
+        queueDepth,
+        process: {
+            pid: process.pid,
+            port: runningPort,
+            memoryMb: Math.round(memUsage.rss / 1024 / 1024),
+            cpuLoadAvg: process.platform !== 'win32' ? osLoadavg() : [0, 0, 0],
+        },
+        ...(lastErrorMessage !== undefined && { lastError: lastErrorMessage }),
+    };
+    const httpStatus = overallStatus === 'unhealthy' ? 503 : 200;
+    return c.json(body, httpStatus);
 });
-// API info
-app.get('/', (c) => {
+// API info (mode-aware)
+app.get('/', async (c) => {
+    // WS-1.3: First-run setup redirect — send to /setup when no admin users exist
+    try {
+        const [{ getDb }, { users }, { eq }] = await Promise.all([
+            import('./storage/index.js'),
+            import('./storage/schema.js'),
+            import('drizzle-orm'),
+        ]);
+        const db = getDb();
+        if (db) {
+            const adminCount = await db
+                .select({ id: users.id })
+                .from(users)
+                .where(eq(users.role, 'admin'))
+                .limit(1);
+            if (adminCount.length === 0) {
+                return c.redirect('/setup', 302);
+            }
+        }
+    }
+    catch {
+        // DB may not be ready; fall through to normal response
+    }
+    // If UI is built and web_ui capability is enabled, serve the dashboard
+    if (hasCapability('web_ui')) {
+        const { existsSync } = await import('node:fs');
+        const { join } = await import('node:path');
+        const { readFile } = await import('node:fs/promises');
+        const indexPath = join(process.cwd(), 'ui', 'dist', 'index.html');
+        if (existsSync(indexPath)) {
+            const html = await readFile(indexPath, 'utf-8');
+            return c.html(html);
+        }
+    }
+    // Fallback: API info JSON
+    const mode = getMode();
+    const routes = getRouteDefinitionsForMode(mode);
+    const routeIds = new Set(routes.map((r) => r.id));
+    // Build endpoints dynamically based on available routes
+    const endpoints = {
+        health: 'GET /health',
+    };
+    // Core routes (always available)
+    if (routeIds.has('tasks')) {
+        endpoints.tasks = {
+            list: 'GET /api/tasks',
+            create: 'POST /api/tasks',
+            get: 'GET /api/tasks/:id',
+            cancel: 'POST /api/tasks/:id/cancel',
+            retry: 'POST /api/tasks/:id/retry',
+        };
+    }
+    if (routeIds.has('agents'))
+        endpoints.agents = 'GET /api/agents';
+    if (routeIds.has('chat')) {
+        endpoints.chat = {
+            models: 'GET /api/chat/models',
+            providers: 'GET /api/chat/providers',
+            send: 'POST /api/chat/send',
+        };
+    }
+    if (routeIds.has('gateway')) {
+        endpoints.gateway = {
+            execute: 'POST /api/gateway/execute',
+            agents: 'GET /api/gateway/agents',
+            workflows: 'GET /api/gateway/workflows',
+        };
+    }
+    if (routeIds.has('hooks')) {
+        endpoints.hooks = {
+            toolUse: 'POST /api/hook/tool-use',
+            sessionEnd: 'POST /api/hook/session-end',
+            sessions: 'GET /api/hook/sessions',
+        };
+    }
+    if (routeIds.has('tools')) {
+        endpoints.tools = {
+            list: 'GET /api/tools',
+            execute: 'POST /api/tools/execute',
+            security: 'GET /api/tools/security',
+        };
+    }
+    if (routeIds.has('settings')) {
+        endpoints.settings = {
+            get: 'GET /api/settings',
+            update: 'PATCH /api/settings',
+        };
+    }
+    if (routeIds.has('auth'))
+        endpoints.auth = 'POST /auth/login';
+    // Dashboard/web UI routes
+    if (routeIds.has('costs'))
+        endpoints.costs = 'GET /api/costs/summary';
+    if (routeIds.has('memory'))
+        endpoints.memory = 'GET /api/memory';
+    if (routeIds.has('skills'))
+        endpoints.skills = 'GET /api/skills';
+    if (routeIds.has('mcp')) {
+        endpoints.mcp = {
+            status: 'GET /api/mcp',
+            tools: 'GET /api/mcp/tools',
+        };
+    }
+    if (routeIds.has('tunnels'))
+        endpoints.tunnels = 'GET /api/tunnels';
+    if (routeIds.has('teams')) {
+        endpoints.teams = {
+            list: 'GET /api/teams?userId=<id>',
+            create: 'POST /api/teams',
+            members: 'GET /api/teams/:id/members',
+            usage: 'GET /api/teams/:id/usage',
+            invites: 'POST /api/teams/:id/invites',
+        };
+    }
+    // Web UI data routes
+    if (routeIds.has('dlq'))
+        endpoints.deadLetterQueue = 'GET /api/dlq';
+    if (routeIds.has('summaries')) {
+        endpoints.summaries = {
+            list: 'GET /api/summaries',
+            search: 'GET /api/summaries/search',
+        };
+    }
+    if (routeIds.has('search')) {
+        endpoints.search = {
+            semantic: 'GET /api/search/semantic?q={query}',
+            text: 'GET /api/search/text?q={query}',
+        };
+    }
+    if (routeIds.has('stats'))
+        endpoints.stats = 'GET /api/stats';
+    // Integration routes
+    if (routeIds.has('tickets')) {
+        endpoints.tickets = {
+            list: 'GET /api/tickets',
+            create: 'POST /api/tickets',
+            get: 'GET /api/tickets/:id',
+        };
+    }
+    if (routeIds.has('projects')) {
+        endpoints.projects = {
+            list: 'GET /api/projects',
+            create: 'POST /api/projects',
+            get: 'GET /api/projects/:id',
+        };
+    }
+    if (routeIds.has('webhooks')) {
+        endpoints.webhooks = {
+            github: 'POST /webhooks/github',
+            jira: 'POST /webhooks/jira',
+            linear: 'POST /webhooks/linear',
+        };
+    }
+    // Cron routes
+    if (routeIds.has('cron'))
+        endpoints.cron = 'GET /api/cron';
+    // Channel routes
+    if (routeIds.has('channels'))
+        endpoints.channels = 'GET /api/channels';
+    // Sync routes
+    if (routeIds.has('sync'))
+        endpoints.sync = 'GET /api/sync';
     return c.json({
         name: 'profClaw',
         version: VERSION,
-        description: 'AI Agent Task Orchestration - Autonomous Mode',
-        docs: '/docs',
-        endpoints: {
-            health: 'GET /health',
-            tasks: 'GET /api/tasks',
-            createTask: 'POST /api/tasks',
-            getTask: 'GET /api/tasks/:id',
-            cancelTask: 'POST /api/tasks/:id/cancel',
-            retryTask: 'POST /api/tasks/:id/retry',
-            agents: 'GET /api/agents',
-            deadLetterQueue: 'GET /api/dlq',
-            retryDlqTask: 'POST /api/dlq/:id/retry',
-            webhooks: {
-                github: 'POST /webhooks/github',
-                jira: 'POST /webhooks/jira',
-                linear: 'POST /webhooks/linear',
-            },
-            hooks: {
-                toolUse: 'POST /api/hook/tool-use',
-                sessionEnd: 'POST /api/hook/session-end',
-                promptSubmit: 'POST /api/hook/prompt-submit',
-                sessions: 'GET /api/hook/sessions',
-                sessionEvents: 'GET /api/hook/sessions/:sessionId/events',
-                sessionSummary: 'GET /api/hook/sessions/:sessionId/summary',
-            },
-            agentWebhooks: {
-                openclaw: 'POST /api/hook/webhook/openclaw',
-                generic: 'POST /api/hook/webhook/agent',
-                reports: 'GET /api/hook/webhook/reports',
-                taskReports: 'GET /api/hook/webhook/tasks/:taskId/reports',
-            },
-            costs: {
-                summary: 'GET /api/costs/summary',
-                budget: 'GET /api/costs/budget',
-            },
-            summaries: {
-                list: 'GET /api/summaries',
-                create: 'POST /api/summaries',
-                get: 'GET /api/summaries/:id',
-                delete: 'DELETE /api/summaries/:id',
-                search: 'GET /api/summaries/search',
-                stats: 'GET /api/summaries/stats',
-                recent: 'GET /api/summaries/recent',
-                byTask: 'GET /api/tasks/:taskId/summaries',
-            },
-            settings: {
-                get: 'GET /api/settings',
-                update: 'PATCH /api/settings',
-                reset: 'POST /api/settings/reset',
-            },
-            gateway: {
-                execute: 'POST /api/gateway/execute',
-                agents: 'GET /api/gateway/agents',
-                workflows: 'GET /api/gateway/workflows',
-                workflow: 'GET /api/gateway/workflows/:type',
-                config: 'GET /api/gateway/config',
-                updateConfig: 'PATCH /api/gateway/config',
-            },
-            search: {
-                semantic: 'GET /api/search/semantic?q={query}',
-                text: 'GET /api/search/text?q={query}',
-                capabilities: 'GET /api/search/capabilities',
-            },
-            tickets: {
-                list: 'GET /api/tickets',
-                create: 'POST /api/tickets',
-                get: 'GET /api/tickets/:id',
-                update: 'PATCH /api/tickets/:id',
-                delete: 'DELETE /api/tickets/:id',
-                transition: 'POST /api/tickets/:id/transition',
-                assignAgent: 'POST /api/tickets/:id/assign-agent',
-                comments: 'GET /api/tickets/:id/comments',
-                addComment: 'POST /api/tickets/:id/comments',
-                links: 'GET /api/tickets/:id/links',
-                addLink: 'POST /api/tickets/:id/links',
-                history: 'GET /api/tickets/:id/history',
-            },
-            projects: {
-                list: 'GET /api/projects',
-                create: 'POST /api/projects',
-                get: 'GET /api/projects/:id',
-                update: 'PATCH /api/projects/:id',
-                archive: 'POST /api/projects/:id/archive',
-                delete: 'DELETE /api/projects/:id',
-                byKey: 'GET /api/projects/by-key/:key',
-                default: 'GET /api/projects/default',
-                migrate: 'POST /api/projects/migrate',
-                externalLinks: 'GET /api/projects/:id/external-links',
-                addExternalLink: 'POST /api/projects/:id/external-links',
-            },
-            sprints: {
-                list: 'GET /api/projects/:projectId/sprints',
-                create: 'POST /api/projects/:projectId/sprints',
-                get: 'GET /api/projects/:projectId/sprints/:sprintId',
-                update: 'PATCH /api/projects/:projectId/sprints/:sprintId',
-                start: 'POST /api/projects/:projectId/sprints/:sprintId/start',
-                complete: 'POST /api/projects/:projectId/sprints/:sprintId/complete',
-                cancel: 'POST /api/projects/:projectId/sprints/:sprintId/cancel',
-                delete: 'DELETE /api/projects/:projectId/sprints/:sprintId',
-                active: 'GET /api/projects/:projectId/sprints/active',
-                tickets: 'GET /api/projects/:projectId/sprints/:sprintId/tickets',
-                addTickets: 'POST /api/projects/:projectId/sprints/:sprintId/tickets',
-                removeTicket: 'DELETE /api/projects/:projectId/sprints/:sprintId/tickets/:ticketId',
-                reorderTickets: 'PUT /api/projects/:projectId/sprints/:sprintId/tickets/reorder',
-            },
-        },
+        mode,
+        capabilities: getCapabilities(),
+        endpoints,
     });
 });
 // Task statistics
@@ -395,9 +611,10 @@ app.get('/api/events', (c) => {
     });
 });
 // === Protected Gateway Endpoint ===
-app.post('/api/gateway/execute-secure', tokenAuthMiddleware(['gateway:execute']), async (c) => {
+app.post('/api/gateway/execute-secure', tokenAuthMiddleware(['gateway:execute']), validateBody(GatewayExecuteSchema), async (c) => {
     try {
-        const body = await c.req.json();
+        // validateBody middleware stores the parsed result; cast via raw context map
+        const body = c.get('validatedBody');
         const { getGateway } = await import('./gateway/index.js');
         const gateway = getGateway();
         const request = {
@@ -436,6 +653,7 @@ app.post('/api/plugins/:id/toggle', async (c) => {
     return c.redirect(`/api/settings/plugins/${id}/toggle`, 307);
 });
 // === Server Startup ===
+const MAX_PORT_ATTEMPTS = 3;
 function checkPortAvailable(port) {
     return new Promise((resolve) => {
         const server = createServer();
@@ -449,6 +667,16 @@ function checkPortAvailable(port) {
         server.listen(port, '127.0.0.1');
     });
 }
+async function resolvePort(startPort) {
+    for (let offset = 0; offset < MAX_PORT_ATTEMPTS; offset++) {
+        const candidate = startPort + offset;
+        const available = await checkPortAvailable(candidate);
+        if (available) {
+            return candidate;
+        }
+    }
+    return null;
+}
 async function main() {
     // Only start IF we are the main module actually being executed
     const isMain = process.argv[1]?.endsWith('server.ts') || process.argv[1]?.endsWith('server.js');
@@ -457,15 +685,18 @@ async function main() {
     }
     const mode = getMode();
     const appSettings = getAppSettings();
-    const PORT = getPort();
+    const configuredPort = getPort();
     const ENABLE_CRON = isCronEnabled();
     appLog.info('profClaw starting', { version: VERSION, mode: getModeLabel() });
-    // Early port conflict detection
-    const portAvailable = await checkPortAvailable(PORT);
-    if (!portAvailable) {
-        appLog.error(`Port ${PORT} is already in use`, new Error(`EADDRINUSE: Port ${PORT}`));
+    // Bind-or-retry: find an available port
+    const PORT = await resolvePort(configuredPort);
+    if (PORT === null) {
+        appLog.error(`All ports ${configuredPort}–${configuredPort + MAX_PORT_ATTEMPTS - 1} are in use`, new Error(`EADDRINUSE: ports ${configuredPort}-${configuredPort + MAX_PORT_ATTEMPTS - 1}`));
         process.exit(1);
     }
+    if (PORT !== configuredPort) {
+        appLog.warn(`Port ${configuredPort} in use, started on port ${PORT}`);
+    }
     // Validate environment variables (fail fast if critical vars missing)
     const envResult = validateEnvironment({
         exitOnError: process.env.NODE_ENV === 'production',
@@ -545,6 +776,15 @@ async function main() {
         appLog.error('Failed to initialize task queue', error instanceof Error ? error : new Error(String(error)));
         appLog.warn('Tasks will not be processed');
     }
+    // Register SSE broadcaster for agent summary updates
+    try {
+        const { getAgentSummaryTracker } = await import('./agents/agent-summary.js');
+        getAgentSummaryTracker().registerSSEBroadcaster(broadcastEvent);
+        appLog.info('Agent summary SSE broadcaster registered');
+    }
+    catch (error) {
+        appLog.error('Failed to register agent summary broadcaster', error instanceof Error ? error : new Error(String(error)));
+    }
     // Initialize sync engine (pro mode or if explicitly configured)
     if (hasCapability('sync_engine')) {
         try {
@@ -561,12 +801,10 @@ async function main() {
             appLog.warn('Sync engine initialization failed', { error: error instanceof Error ? error.message : String(error) });
         }
     }
-    // Initialize cost tracking (skip in pico - loaded on first use)
-    if (getMode() !== 'pico') {
-        const { initTokenTracker } = await import('./costs/token-tracker.js');
-        initTokenTracker();
-        appLog.info('Token tracker initialized');
-    }
+    // Initialize cost tracking (all modes — lightweight, needed for /api/costs)
+    const { initTokenTracker } = await import('./costs/token-tracker.js');
+    initTokenTracker();
+    appLog.info('Token tracker initialized');
     // Initialize agents from config
     const { getAgentRegistry } = await import('./adapters/registry.js');
     const registry = getAgentRegistry();
@@ -605,11 +843,13 @@ async function main() {
             }
         }
     }
-    // Auto-discover agents if enabled (skip in pico mode to save startup time/memory)
-    const autoDiscover = mode !== 'pico' && (process.env.AUTO_DISCOVER_AGENTS !== undefined
+    // Auto-discover agents if enabled
+    // Pico mode: only auto-discover Ollama (cheap fetch, essential for pico users)
+    // Mini/Pro: full auto-discovery (Claude Code CLI check, etc.)
+    const autoDiscover = mode === 'pico' ? true : (process.env.AUTO_DISCOVER_AGENTS !== undefined
         ? process.env.AUTO_DISCOVER_AGENTS === 'true'
         : (appSettings.agents?.autoDiscover ?? false));
-    if (autoDiscover && !registry.getActiveAdapters().some(a => a.type === 'claude-code')) {
+    if (autoDiscover && mode !== 'pico' && !registry.getActiveAdapters().some(a => a.type === 'claude-code')) {
         try {
             const { execSync } = await import('child_process');
             execSync('which claude', { stdio: 'ignore' });
@@ -655,6 +895,32 @@ async function main() {
             // Ollama not running
         }
     }
+    // WS-1.2: Provider validation — warn (or exit in strict mode) when no AI adapters are configured
+    if (registry.getActiveAdapters().length === 0) {
+        appLog.warn('No AI providers configured. Run `profclaw setup` or set ANTHROPIC_API_KEY / OPENAI_API_KEY');
+        if (process.env.PROFCLAW_STRICT_MODE === 'true') {
+            appLog.error('Strict mode enabled: refusing to start without an AI provider');
+            process.exit(1);
+        }
+        degradedMode = true;
+    }
+    // WS-1.4: In-memory storage — warn on startup and remind every 60 seconds
+    {
+        const { isStorageInMemory } = await import('./storage/index.js');
+        if (isStorageInMemory()) {
+            degradedMode = true;
+            appLog.warn('╔══════════════════════════════════════════════════════════╗');
+            appLog.warn('║  WARNING: Running with in-memory storage (ephemeral)     ║');
+            appLog.warn('║  All data will be lost when the server restarts.         ║');
+            appLog.warn('║  Set STORAGE_TIER=local or DATABASE_URL to persist data. ║');
+            appLog.warn('╚══════════════════════════════════════════════════════════╝');
+            inMemoryStorageReminderInterval = setInterval(() => {
+                appLog.warn('Reminder: server is running with ephemeral in-memory storage — data will not survive a restart');
+            }, 60_000);
+            // Allow Node to exit cleanly without waiting for this interval
+            inMemoryStorageReminderInterval.unref();
+        }
+    }
     // Start cron jobs (if mode supports it and enabled)
     if (ENABLE_CRON && hasCapability('cron')) {
         const { startAllCronJobs } = await import('./cron/index.js');
@@ -714,6 +980,10 @@ async function main() {
         fetch: app.fetch,
         port: PORT,
     });
+    // Record runtime port for health endpoint
+    runningPort = PORT;
+    // Record PID so the CLI can detect/kill existing instances
+    writePidFile(PORT);
     appLog.info(`profClaw ready on http://localhost:${PORT}`, { port: PORT, mode: getModeLabel() });
     if (ENABLE_CRON) {
         const heartbeatMs = parseInt(process.env.POLL_INTERVAL_HEARTBEAT || '30000', 10);
@@ -784,7 +1054,12 @@ async function gracefulShutdown(signal) {
     sseConnections.clear();
     clearInterval(sseCleanupInterval);
     appLog.info('SSE connections closed');
-    // 2. Stop cron jobs
+    // 2. Stop in-memory storage reminder interval
+    if (inMemoryStorageReminderInterval !== null) {
+        clearInterval(inMemoryStorageReminderInterval);
+        inMemoryStorageReminderInterval = null;
+    }
+    // 3. Stop cron jobs
     try {
         const { stopAllCronJobs } = await import('./cron/index.js');
         stopAllCronJobs();
@@ -793,7 +1068,7 @@ async function gracefulShutdown(signal) {
     catch {
         // Cron may not be initialized
     }
-    // 3. Drain task queue
+    // 4. Drain task queue
     try {
         const { closeQueue } = await import('./queue/index.js');
         await closeQueue();
@@ -802,7 +1077,7 @@ async function gracefulShutdown(signal) {
     catch {
         // Queue may not be initialized
     }
-    // 4. Destroy HTTP rate limiters
+    // 5. Destroy HTTP rate limiters
     try {
         apiRateLimiter.destroy();
         authRateLimiter.destroy();
@@ -811,6 +1086,8 @@ async function gracefulShutdown(signal) {
     catch {
         // Rate limiters may not be initialized
     }
+    // Remove PID file so new instances know the slot is free
+    removePidFile();
     appLog.info('Clean exit');
     clearTimeout(forceExitTimer);
     process.exit(0);
@@ -819,12 +1096,15 @@ process.on('SIGINT', () => { gracefulShutdown('SIGINT'); });
 process.on('SIGTERM', () => { gracefulShutdown('SIGTERM'); });
 // Catch unhandled errors to log before crashing
 process.on('uncaughtException', (err) => {
+    lastErrorMessage = err.message;
     appLog.error('Uncaught exception', err);
     // Let the process crash (daemon/serve will restart it)
     process.exit(1);
 });
 process.on('unhandledRejection', (reason) => {
-    appLog.error('Unhandled rejection', reason instanceof Error ? reason : new Error(String(reason)));
+    const errMsg = reason instanceof Error ? reason.message : String(reason);
+    lastErrorMessage = errMsg;
+    appLog.error('Unhandled rejection', reason instanceof Error ? reason : new Error(errMsg));
     // Don't exit for unhandled rejections - log and continue
     // This prevents a single failed promise from taking down the server
 });