@shawnstack/quickforge 1.3.20 → 1.3.22

package/node_modules/typebox/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.38",
+  "version": "1.1.39",
   "keywords": [
     "typescript",
     "jsonschema"
@@ -16,22 +16,6 @@
   "types": "./build/index.d.mts",
   "module": "./build/index.mjs",
   "exports": {
-    "./guard": {
-      "import": "./build/guard/index.mjs",
-      "default": "./build/guard/index.mjs"
-    },
-    "./error": {
-      "import": "./build/error/index.mjs",
-      "default": "./build/error/index.mjs"
-    },
-    "./compile": {
-      "import": "./build/compile/index.mjs",
-      "default": "./build/compile/index.mjs"
-    },
-    "./system": {
-      "import": "./build/system/index.mjs",
-      "default": "./build/system/index.mjs"
-    },
     "./format": {
       "import": "./build/format/index.mjs",
       "default": "./build/format/index.mjs"
@@ -44,10 +28,26 @@
       "import": "./build/schema/index.mjs",
       "default": "./build/schema/index.mjs"
     },
+    "./compile": {
+      "import": "./build/compile/index.mjs",
+      "default": "./build/compile/index.mjs"
+    },
     "./value": {
       "import": "./build/value/index.mjs",
       "default": "./build/value/index.mjs"
     },
+    "./guard": {
+      "import": "./build/guard/index.mjs",
+      "default": "./build/guard/index.mjs"
+    },
+    "./system": {
+      "import": "./build/system/index.mjs",
+      "default": "./build/system/index.mjs"
+    },
+    "./error": {
+      "import": "./build/error/index.mjs",
+      "default": "./build/error/index.mjs"
+    },
     ".": {
       "import": "./build/index.mjs",
       "default": "./build/index.mjs"
@@ -55,18 +55,6 @@
   },
   "typesVersions": {
     "*": {
-      "guard": [
-        "./build/guard/index.d.mts"
-      ],
-      "error": [
-        "./build/error/index.d.mts"
-      ],
-      "compile": [
-        "./build/compile/index.d.mts"
-      ],
-      "system": [
-        "./build/system/index.d.mts"
-      ],
       "format": [
         "./build/format/index.d.mts"
       ],
@@ -76,9 +64,21 @@
       "schema": [
         "./build/schema/index.d.mts"
       ],
+      "compile": [
+        "./build/compile/index.d.mts"
+      ],
       "value": [
         "./build/value/index.d.mts"
       ],
+      "guard": [
+        "./build/guard/index.d.mts"
+      ],
+      "system": [
+        "./build/system/index.d.mts"
+      ],
+      "error": [
+        "./build/error/index.d.mts"
+      ],
       ".": [
         "./build/index.d.mts"
       ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shawnstack/quickforge",
-  "version": "1.3.20",
+  "version": "1.3.22",
   "description": "AI chat application with YOLO-mode local workspace tools. React + Vite + Tailwind CSS frontend, local Node.js storage server.",
   "keywords": [
     "ai",

package/server/agent-manager.mjs

@@ -8,8 +8,8 @@ import { callMcpTool, createMcpToolDefinitions, isMcpToolName } from './mcp/regi
 import {
   composeSubagentSystemPrompt,
   formatSubagentTask,
-  getSubagentDefinition,
 } from './subagents.mjs'
+import { agentProfileSnapshot, getAgentProfile } from './agent-profiles.mjs'
 import { projectContextFromId, readProjectConfig } from './project-config.mjs'
 import { readStore, atomicUpdate, readSessionValue, writeSessionValue, deleteSessionValue } from './storage.mjs'
 import { logger } from './utils/logger.mjs'
@@ -22,6 +22,7 @@ import {
 } from './conversation-compaction.mjs'
 import {
   buildAutoCompactLoopMessages,
+  estimateSessionContextUsage,
   maybeAutoCompactSession,
 } from './auto-compaction.mjs'
 import {
@@ -366,8 +367,12 @@ function estimateTokenReduction(originalChars, finalChars) {
 }
 
 function emitSessionEvent(session, event) {
-  session.eventBus.emit('agent_event', event)
-  agentEvents.emit('agent_event', { sessionId: session.sessionId, ...event })
+  const enrichedEvent = (event?.type === 'message_end' || event?.type === 'agent_end' || event?.type === 'messages_replaced' || event?.type === 'auto_compact_completed')
+    && event.contextUsage === undefined
+    ? { ...event, contextUsage: getSessionContextUsage(session) }
+    : event
+  session.eventBus.emit('agent_event', enrichedEvent)
+  agentEvents.emit('agent_event', { sessionId: session.sessionId, ...enrichedEvent })
 }
 
 function addToolTimingToEvent(session, event) {
@@ -681,12 +686,13 @@ function lastAssistantText(messages) {
 }
 
 async function runSubagent(parentSession, params, parentSignal, onUpdate) {
-  const definition = getSubagentDefinition(params?.subagent)
-  if (!definition) {
-    const error = new Error(`Unknown subagent: ${params?.subagent || ''}`)
+  const profile = await getAgentProfile(params?.subagent)
+  if (!profile || !profile.enabledAsSubagent) {
+    const error = new Error(`Unknown or disabled subagent: ${params?.subagent || ''}`)
     error.statusCode = 400
     throw error
   }
+  const definition = profile
 
   const task = String(params?.task || '').trim()
   if (!task) {
@@ -774,7 +780,7 @@ async function runSubagent(parentSession, params, parentSignal, onUpdate) {
       const toolName = context.toolCall?.name
       toolCalls += 1
       emitSubagentTrace()
-      if (toolCalls > Number(definition.maxToolCalls || 12)) {
+      if (toolCalls > Number(definition.maxToolCalls || 300)) {
         return { block: true, reason: `Subagent ${definition.name} exceeded its tool-call budget.` }
       }
       if (!definition.allowedTools.includes(toolName)) {
@@ -954,6 +960,7 @@ export async function createAgent(sessionId, config = {}) {
     createdAt = new Date().toISOString(),
     lastModified = null,
     contextCompaction = null,
+    agentProfile = null,
   } = config
 
   // Resolve project context for tool calls
@@ -975,7 +982,8 @@ export async function createAgent(sessionId, config = {}) {
     globalSkillNames: projectConfig.globalSkills,
     projectSkillNames: configuredProject?.skills,
   }
-  const resolvedSystemPrompt = systemPrompt ?? (await buildSystemPrompt(projectId))
+  const profileSystemPrompt = agentProfile?.systemPrompt ? `\n\n<agent_profile_instructions>\nAgent Profile: ${agentProfile.label || agentProfile.name}\n${agentProfile.systemPrompt}\n</agent_profile_instructions>` : ''
+  const resolvedSystemPrompt = systemPrompt ?? `${await buildSystemPrompt(projectId)}${profileSystemPrompt}`
 
   // Resolve model
   let resolvedModel = model
@@ -991,16 +999,25 @@ export async function createAgent(sessionId, config = {}) {
   }
 
   // Build skills tools for enabled skills, plus workspace tools when a project is available.
+  const profileToolNames = Array.isArray(agentProfile?.allowedTools) ? agentProfile.allowedTools : null
   const tools = await createServerTools(
     projectId,
     projectContext,
     skillsContext,
     !!(projectId && projectContext),
     (toolName) => {
+      if (profileToolNames && !profileToolNames.includes(toolName)) return `Agent profile ${agentProfile.name} is not allowed to use ${toolName}.`
       const session = agentSessions.get(sessionId)
       return session ? createCommandToolPermissions(session)(toolName) : null
     },
-    { parentSessionId: sessionId },
+    agentProfile
+      ? {
+          allowedToolNames: profileToolNames,
+          includeSubagentTool: false,
+          includeMcpTools: false,
+          parentSessionId: sessionId,
+        }
+      : { parentSessionId: sessionId },
   )
 
   // Resolve API key
@@ -1013,6 +1030,7 @@ export async function createAgent(sessionId, config = {}) {
     }
   }
 
+  let session
   const agent = new Agent({
     initialState: {
       systemPrompt: resolvedSystemPrompt,
@@ -1035,6 +1053,7 @@ export async function createAgent(sessionId, config = {}) {
       const isSkillTool = toolName === 'activate_skill' || toolName === 'read_skill_resource'
       if (isSkillTool) return undefined
       const currentSession = agentSessions.get(sessionId)
+      if (profileToolNames && !profileToolNames.includes(toolName)) return { block: true, reason: `Agent profile ${agentProfile.name} is not allowed to use ${toolName}.` }
       if (toolName === 'run_subagent') return undefined
       if (isMcpToolName(toolName)) {
         if (!currentSession?.yoloMode) return createApprovalPromise(currentSession, toolCallId, toolName, context.args)
@@ -1055,7 +1074,7 @@ export async function createAgent(sessionId, config = {}) {
   const eventBus = new EventEmitter()
   eventBus.setMaxListeners(100)
 
-  const session = {
+  session = {
     sessionId,
     agent,
     projectContext,
@@ -1081,6 +1100,7 @@ export async function createAgent(sessionId, config = {}) {
     toolTimings: new Map(),
     getApiKey,
     contextCompaction,
+    agentProfile: agentProfile ? agentProfileSnapshot(agentProfile) : null,
     lastTransformedContextMessages: null,
     autoCompacting: false,
     lastAutoCompactAt: null,
@@ -1102,8 +1122,7 @@ export async function createAgent(sessionId, config = {}) {
       : timedEvent
 
     // Forward all events to the session event bus and the global bus.
-    eventBus.emit('agent_event', forwardEvent)
-    agentEvents.emit('agent_event', { sessionId, ...forwardEvent })
+    emitSessionEvent(session, forwardEvent)
 
     // Track status
     if (event.type === 'agent_start') {
@@ -1263,7 +1282,10 @@ async function persistSession(session) {
   try {
     await writeSessionValue(sessionId, sessionData)
     await atomicUpdate('sessions-metadata', (data) => {
-      data[sessionId] = metadata
+      data[sessionId] = {
+        ...metadata,
+        pinnedAt: data[sessionId]?.pinnedAt,
+      }
       return data
     })
   } catch (err) {
@@ -1320,6 +1342,8 @@ export async function rollbackSessionMessages(sessionId, rollbackMessageIndex) {
     reason: 'rollback',
     rollbackIndex,
     messages: session.agent.state.messages,
+    contextCompaction: session.contextCompaction,
+    contextUsage: getSessionContextUsage(session),
   }
   emitSessionEvent(session, replacedEvent)
   emitSessionEvent(session, { type: 'message_end', messages: session.agent.state.messages })
@@ -1340,8 +1364,9 @@ export async function replaceSessionMessages(sessionId, messages) {
   session.finishedAt = new Date().toISOString()
   await persistSession(session)
   const nextMessages = session.agent.state.messages
-  emitSessionEvent(session, { type: 'message_end', messages: nextMessages })
-  emitSessionEvent(session, { type: 'agent_end', messages: nextMessages })
+  const contextUsage = getSessionContextUsage(session)
+  emitSessionEvent(session, { type: 'message_end', messages: nextMessages, contextUsage })
+  emitSessionEvent(session, { type: 'agent_end', messages: nextMessages, contextUsage })
   return getSessionState(sessionId)
 }
 
@@ -1375,10 +1400,8 @@ export async function runPrompt(sessionId, message) {
     ]
     await persistSession(session)
     const messages = session.agent.state.messages
-    session.eventBus.emit('agent_event', { type: 'message_end', messages })
-    session.eventBus.emit('agent_event', { type: 'agent_end', messages })
-    agentEvents.emit('agent_event', { sessionId, type: 'message_end', messages })
-    agentEvents.emit('agent_event', { sessionId, type: 'agent_end', messages })
+    emitSessionEvent(session, { type: 'message_end', messages })
+    emitSessionEvent(session, { type: 'agent_end', messages })
     return { sessionId, status: session.status }
   }
 
@@ -1403,8 +1426,7 @@ export async function runPrompt(sessionId, message) {
       if (aiTitle && aiTitle !== 'New chat') {
         session.title = aiTitle
         await persistSession(session)
-        session.eventBus.emit('agent_event', { type: 'title_updated', title: aiTitle })
-        agentEvents.emit('agent_event', { sessionId, type: 'title_updated', title: aiTitle })
+        emitSessionEvent(session, { type: 'title_updated', title: aiTitle })
       }
     }).catch((err) => {
       logger.warn(`Title generation failed for session ${sessionId}:`, err.message || err, { sessionId })
@@ -1422,8 +1444,7 @@ export async function runPrompt(sessionId, message) {
       type: 'error',
       error: err.message || 'Unknown error',
     }
-    session.eventBus.emit('agent_event', event)
-    agentEvents.emit('agent_event', { sessionId, ...event })
+    emitSessionEvent(session, event)
   }).finally(() => {
     session.activeCommandName = null
     session.activeCommandPermissions = null
@@ -1468,8 +1489,7 @@ export async function abortRun(sessionId) {
       type: 'agent_end',
       messages: session.agent.state.messages,
     }
-    session.eventBus.emit('agent_event', event)
-    agentEvents.emit('agent_event', { sessionId, ...event })
+    emitSessionEvent(session, event)
   }
 
   return { sessionId, aborted: true }
@@ -1509,6 +1529,15 @@ export function followUpAgent(sessionId, message) {
   return { sessionId, followUp: true }
 }
 
+function getSessionContextUsage(session) {
+  try {
+    return estimateSessionContextUsage(session)
+  } catch (error) {
+    logger.warn(`Failed to estimate context usage for session ${session?.sessionId}:`, error?.message || error, { sessionId: session?.sessionId })
+    return null
+  }
+}
+
 /**
  * Get the current state of a session (for page refresh recovery).
  */
@@ -1533,6 +1562,7 @@ export function getSessionState(sessionId) {
     tools: session.agent.state.tools,
     messages: session.agent.state.messages,
     contextCompaction: session.contextCompaction,
+    contextUsage: getSessionContextUsage(session),
     isStreaming: session.agent.state.isStreaming,
     errorMessage: session.agent.state.errorMessage,
   }
@@ -1591,6 +1621,14 @@ export async function destroyAgent(sessionId) {
     // ignore
   }
 
+  // Clean up any pending approvals for this session before removing it.
+  for (const [toolCallId, approval] of pendingApprovals) {
+    if (approval.sessionId === sessionId) approval.reject(new Error('Session destroyed'))
+  }
+  for (const [approvalId, approval] of pendingAutoCompactApprovals) {
+    if (approval.sessionId === sessionId) approval.reject(new Error('Session destroyed'))
+  }
+
   // Final persist (empty sessions are cleaned up by persistSession)
   try {
     await persistSession(session)

package/server/agent-profiles.mjs

@@ -0,0 +1,191 @@
+import { randomUUID } from 'node:crypto'
+import { readStore, atomicUpdate } from './storage.mjs'
+import { subagentDefinitions } from './subagents.mjs'
+import { workspaceTools } from './tools/definitions.mjs'
+
+const STORE = 'custom-agents'
+const RESERVED_NAMES = new Set(subagentDefinitions.map((definition) => definition.name))
+export const AGENT_PROFILE_TOOL_NAMES = ['read_file', 'grep_files', 'write_file', 'edit_file', 'run_command']
+const allowedToolNames = new Set(AGENT_PROFILE_TOOL_NAMES)
+const nameRegex = /^[a-z][a-z0-9_-]{1,39}$/
+const DEFAULT_MAX_RUNTIME_MS = 30 * 60 * 1000
+const DEFAULT_MAX_TOOL_CALLS = 300
+
+function requestError(message, statusCode = 400) {
+  const error = new Error(message)
+  error.statusCode = statusCode
+  return error
+}
+
+function uniqueStrings(value) {
+  if (!Array.isArray(value)) return []
+  const result = []
+  const seen = new Set()
+  for (const item of value) {
+    const text = String(item || '').trim()
+    if (!text || seen.has(text)) continue
+    seen.add(text)
+    result.push(text)
+  }
+  return result
+}
+
+function normalizeOptionalPositiveInteger(value, fallback, max) {
+  if (value === undefined || value === null || value === '') return fallback
+  const parsed = Number(value)
+  if (!Number.isInteger(parsed) || parsed <= 0) throw requestError('maxToolCalls must be a positive integer')
+  return Math.min(parsed, max)
+}
+
+function normalizeOptionalRuntime(value, fallback) {
+  if (value === undefined || value === null || value === '') return fallback
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed) || parsed <= 0) throw requestError('maxRuntimeMs must be a positive number')
+  return Math.min(Math.max(Math.round(parsed), 1000), DEFAULT_MAX_RUNTIME_MS)
+}
+
+function builtinProfileFromSubagent(definition) {
+  return {
+    id: definition.name,
+    name: definition.name,
+    label: definition.label || definition.name,
+    description: definition.description || '',
+    systemPrompt: definition.systemPrompt || '',
+    allowedTools: [...definition.allowedTools],
+    maxRuntimeMs: definition.maxRuntimeMs || DEFAULT_MAX_RUNTIME_MS,
+    maxToolCalls: definition.maxToolCalls || DEFAULT_MAX_TOOL_CALLS,
+    enabledAsSubagent: true,
+    builtin: true,
+    createdAt: 'builtin',
+    updatedAt: 'builtin',
+  }
+}
+
+export function listBuiltinAgentProfiles() {
+  return subagentDefinitions.map(builtinProfileFromSubagent)
+}
+
+function normalizeProfileInput(input, existing = null, { creating = false } = {}) {
+  const now = new Date().toISOString()
+  const name = String(input?.name ?? existing?.name ?? '').trim().toLowerCase()
+  if (!nameRegex.test(name)) throw requestError('name must start with a letter and contain only lowercase letters, numbers, underscores, or hyphens')
+  if (creating && RESERVED_NAMES.has(name)) throw requestError(`Agent name is reserved: ${name}`, 409)
+  if (!creating && existing?.builtin) throw requestError('Built-in agents cannot be modified', 403)
+
+  const label = String(input?.label ?? existing?.label ?? name).trim().slice(0, 80)
+  if (!label) throw requestError('label is required')
+
+  const allowedTools = uniqueStrings(input?.allowedTools ?? existing?.allowedTools ?? ['read_file', 'grep_files'])
+  if (allowedTools.length === 0) throw requestError('allowedTools must contain at least one tool')
+  for (const toolName of allowedTools) {
+    if (!allowedToolNames.has(toolName)) throw requestError(`Unsupported tool for custom agent: ${toolName}`)
+  }
+
+  return {
+    id: existing?.id || `agent-${randomUUID()}`,
+    name,
+    label,
+    description: String(input?.description ?? existing?.description ?? '').trim().slice(0, 500),
+    systemPrompt: String(input?.systemPrompt ?? existing?.systemPrompt ?? '').trim(),
+    allowedTools,
+    maxRuntimeMs: normalizeOptionalRuntime(input?.maxRuntimeMs ?? existing?.maxRuntimeMs, DEFAULT_MAX_RUNTIME_MS),
+    maxToolCalls: normalizeOptionalPositiveInteger(input?.maxToolCalls ?? existing?.maxToolCalls, DEFAULT_MAX_TOOL_CALLS, 300),
+    enabledAsSubagent: input?.enabledAsSubagent === undefined ? Boolean(existing?.enabledAsSubagent ?? true) : input.enabledAsSubagent === true,
+    builtin: false,
+    createdAt: existing?.createdAt || now,
+    updatedAt: now,
+  }
+}
+
+async function readCustomAgentMap() {
+  const data = await readStore(STORE)
+  return data && typeof data === 'object' ? data : {}
+}
+
+export async function listAgentProfiles(options = {}) {
+  const custom = Object.values(await readCustomAgentMap())
+  const profiles = [...listBuiltinAgentProfiles(), ...custom]
+  return options.includeDisabled ? profiles : profiles.filter((profile) => profile.enabledAsSubagent || profile.builtin || profile.enabledAsSubagent === false)
+}
+
+export async function listSubagentProfiles() {
+  return (await listAgentProfiles({ includeDisabled: true })).filter((profile) => profile.enabledAsSubagent)
+}
+
+export async function getAgentProfile(idOrName) {
+  const key = String(idOrName || '').trim().toLowerCase()
+  if (!key) return null
+  return (await listAgentProfiles({ includeDisabled: true })).find((profile) => profile.id === key || profile.name === key) || null
+}
+
+export async function createCustomAgentProfile(input) {
+  let created = null
+  await atomicUpdate(STORE, (data) => {
+    const map = data && typeof data === 'object' ? data : {}
+    const profile = normalizeProfileInput(input, null, { creating: true })
+    if (Object.values(map).some((item) => item?.name === profile.name)) throw requestError(`Agent name already exists: ${profile.name}`, 409)
+    created = profile
+    map[profile.id] = profile
+    return map
+  })
+  return created
+}
+
+export async function updateCustomAgentProfile(id, patch) {
+  let updated = null
+  await atomicUpdate(STORE, (data) => {
+    const map = data && typeof data === 'object' ? data : {}
+    const current = map[id]
+    if (!current) throw requestError('Agent not found', 404)
+    const next = normalizeProfileInput(patch, current)
+    if (RESERVED_NAMES.has(next.name)) throw requestError(`Agent name is reserved: ${next.name}`, 409)
+    if (Object.values(map).some((item) => item?.id !== id && item?.name === next.name)) throw requestError(`Agent name already exists: ${next.name}`, 409)
+    updated = next
+    map[id] = next
+    return map
+  })
+  return updated
+}
+
+export async function deleteCustomAgentProfile(id) {
+  await atomicUpdate(STORE, (data) => {
+    const map = data && typeof data === 'object' ? data : {}
+    if (!map[id]) throw requestError('Agent not found', 404)
+    delete map[id]
+    return map
+  })
+}
+
+export function agentProfileSnapshot(profile) {
+  if (!profile) return null
+  return {
+    id: profile.id,
+    name: profile.name,
+    label: profile.label,
+    description: profile.description,
+    systemPrompt: profile.systemPrompt,
+    allowedTools: [...profile.allowedTools],
+    maxRuntimeMs: profile.maxRuntimeMs,
+    maxToolCalls: profile.maxToolCalls,
+    builtin: profile.builtin === true,
+  }
+}
+
+export function listAvailableAgentTools() {
+  const labels = {
+    read_file: 'Read file',
+    grep_files: 'Search files',
+    write_file: 'Write file',
+    edit_file: 'Edit file',
+    run_command: 'Run command',
+  }
+  const risks = new Set(['write_file', 'edit_file', 'run_command'])
+  return workspaceTools
+    .filter((tool) => allowedToolNames.has(tool.name))
+    .map((tool) => ({
+      name: tool.name,
+      label: tool.label || labels[tool.name] || tool.name,
+      description: tool.description || '',
+      riskLevel: risks.has(tool.name) ? 'dangerous' : 'safe',
+    }))
+}

package/server/auto-compaction.mjs

@@ -215,6 +215,24 @@ export function buildAutoCompactLoopMessages(session, messages) {
   return [summaryMessage, ...source.slice(compactedUpToIndex)]
 }
 
+export function estimateSessionContextUsage(session, messages = session?.agent?.state?.messages ?? []) {
+  if (!session?.agent?.state) return null
+  const sourceMessages = Array.isArray(messages) ? messages : []
+  const contextWindow = Number(session.model?.contextWindow) || 0
+  if (sourceMessages.length === 0) {
+    return { inputTokens: 0, estimatedInputTokens: 0, knownInputTokens: 0, reservedOutputTokens: 0, totalTokens: 0, contextWindow, percent: 0 }
+  }
+  const loopMessages = buildAutoCompactLoopMessages(session, sourceMessages)
+  const knownInputTokens = latestKnownInputTokens(sourceMessages, latestCompactTimestampMs(session))
+  return estimateContextUsage({
+    systemPrompt: session.agent.state.systemPrompt,
+    messages: loopMessages,
+    tools: session.agent.state.tools,
+    model: session.model,
+    knownInputTokens,
+  })
+}
+
 export async function maybeAutoCompactSession({ session, messages, signal, emitSessionEvent, persistSession, logger, confirmAutoCompact }) {
   if (!session || session.autoCompacting) return { compacted: false }
   const settings = await readAutoCompactSettings()
@@ -300,12 +318,14 @@ export async function maybeAutoCompactSession({ session, messages, signal, emitS
       usage,
       thresholdPercent: settings.thresholdPercent,
       contextCompaction: session.contextCompaction,
+      contextUsage: estimateSessionContextUsage(session, messages),
     })
     emitSessionEvent(session, {
       type: 'messages_replaced',
       reason: 'auto_compact',
       messages,
       contextCompaction: session.contextCompaction,
+      contextUsage: estimateSessionContextUsage(session, messages),
     })
     return { compacted: true, usage }
   } catch (error) {

package/server/index.mjs

@@ -16,6 +16,7 @@ import { handleToolApi, handleGetTools } from './routes/tools.mjs'
 import { handleInstructionsApi } from './routes/instructions.mjs'
 import { handleSkillsApi } from './routes/skills.mjs'
 import { handleAgentApi } from './routes/agent.mjs'
+import { handleAgentProfilesApi } from './routes/agent-profiles.mjs'
 import { handleScheduledTasksApi, startScheduledTaskRunner, stopScheduledTaskRunner } from './routes/scheduled-tasks.mjs'
 import { handleBackupApi } from './routes/backup.mjs'
 import { handleSystemApi } from './routes/system.mjs'
@@ -208,6 +209,12 @@ async function handleApi(req, res, url) {
     return
   }
 
+  // Agent profiles
+  if (pathname === '/api/agent-profiles' || pathname.startsWith('/api/agent-profiles/')) {
+    await handleAgentProfilesApi(req, res, url)
+    return
+  }
+
   // Skills
   if (pathname === '/api/skills' || pathname.startsWith('/api/skills/')) {
     await handleSkillsApi(req, res, url)
@@ -319,6 +326,10 @@ function startVite() {
     shell: false,
     env: { ...process.env, QUICKFORGE_SERVER_PORT: String(port) },
   })
+  viteChild.on('error', (error) => {
+    logger.error('Failed to start Vite dev server:', error)
+    process.exitCode = 1
+  })
   viteChild.on('exit', (code) => {
     if (code && code !== 0) process.exitCode = code
   })
@@ -485,10 +496,17 @@ const server = createServer(async (req, res) => {
   }
 })
 
+function writeAndDestroySocket(socket, statusLine) {
+  socket.on('error', () => {})
+  if (!socket.destroyed) {
+    try { socket.write(`${statusLine}\r\n\r\n`) } catch { /* ignore */ }
+  }
+  socket.destroy()
+}
+
 server.on('upgrade', (req, socket, head) => {
   if (!isAllowedHostHeader(req.headers.host)) {
-    socket.write('HTTP/1.1 403 Forbidden\r\n\r\n')
-    socket.destroy()
+    writeAndDestroySocket(socket, 'HTTP/1.1 403 Forbidden')
     return
   }
 
@@ -500,11 +518,9 @@ server.on('upgrade', (req, socket, head) => {
       })
       return
     }
-    socket.write('HTTP/1.1 404 Not Found\r\n\r\n')
-    socket.destroy()
+    writeAndDestroySocket(socket, 'HTTP/1.1 404 Not Found')
   } catch {
-    socket.write('HTTP/1.1 400 Bad Request\r\n\r\n')
-    socket.destroy()
+    writeAndDestroySocket(socket, 'HTTP/1.1 400 Bad Request')
   }
 })
 
@@ -546,5 +562,13 @@ async function gracefulShutdown(signal) {
   process.exit(0)
 }
 
-process.on('SIGINT', (signal) => gracefulShutdown(signal))
-process.on('SIGTERM', (signal) => gracefulShutdown(signal))
+function handleShutdownSignal(signal) {
+  void gracefulShutdown(signal).catch((error) => {
+    logger.error('Graceful shutdown failed:', error)
+    flushLogger()
+    process.exit(1)
+  })
+}
+
+process.on('SIGINT', handleShutdownSignal)
+process.on('SIGTERM', handleShutdownSignal)