@shawnstack/quickforge 1.3.18 → 1.3.20

package/server/auto-compaction.mjs

@@ -70,7 +70,6 @@ function estimateMessageTokens(message) {
   const parts = [message.role || '', contentToText(message.content)]
   if (message.toolName) parts.push(message.toolName)
   if (message.toolCallId) parts.push(message.toolCallId)
-  if (message.details !== undefined) parts.push(safeJson(message.details))
   if (message.attachments !== undefined) parts.push(safeJson(message.attachments))
   return estimateTextTokens(parts.join('\n'))
 }
@@ -82,7 +81,7 @@ function estimateMessagesTokens(messages) {
 function estimateMessagesChars(messages) {
   return (Array.isArray(messages) ? messages : []).reduce((total, message) => {
     if (!message || typeof message !== 'object') return total
-    return total + [message.role || '', contentToText(message.content), safeJson(message.details), safeJson(message.attachments)].join('\n').length
+    return total + [message.role || '', contentToText(message.content), safeJson(message.attachments)].join('\n').length
   }, 0)
 }
 

package/server/conversation-compaction.mjs

@@ -134,10 +134,6 @@ function formatMessageForTranscript(message, index) {
   const attachments = attachmentsSummary(message)
   if (attachments) bodyParts.push(attachments)
 
-  if (role === 'toolResult' && message?.details !== undefined) {
-    bodyParts.push(`[tool result details]\n${safeJson(message.details, 4000)}`)
-  }
-
   const body = bodyParts.join('\n\n').trim() || '[empty]'
   return redactSensitive(`### Message ${index + 1}: ${role}\n${body}`)
 }
@@ -158,7 +154,6 @@ function approximateMessageChars(message) {
   if (message?.attachments) total += safeJson(message.attachments, 1000).length
   if (message?.toolName) total += String(message.toolName).length
   if (message?.toolCallId) total += String(message.toolCallId).length
-  if (message?.details) total += safeJson(message.details, 1000).length
   return total
 }
 

package/server/index.mjs

@@ -376,6 +376,7 @@ function isStaticAssetPath(pathname) {
   return pathname.startsWith('/assets/')
     || pathname === '/favicon.svg'
     || pathname === '/vite.svg'
+    || pathname === '/manifest.webmanifest'
 }
 
 function isSharePath(pathname) {

package/server/routes/static.mjs

@@ -13,6 +13,7 @@ function getContentType(filePath) {
     '.mjs': 'text/javascript; charset=utf-8',
     '.css': 'text/css; charset=utf-8',
     '.json': 'application/json; charset=utf-8',
+    '.webmanifest': 'application/manifest+json; charset=utf-8',
     '.svg': 'image/svg+xml',
     '.png': 'image/png',
     '.jpg': 'image/jpeg',

package/server/routes/tools.mjs

@@ -4,6 +4,8 @@ import { toolHandlers, loadSkillToolContext } from '../tools/index.mjs'
 import { createSkillTools, workspaceTools } from '../tools/definitions.mjs'
 import { projectContextFromId, readProjectConfig } from '../project-config.mjs'
 
+const directRouteDisabledTools = new Set(['run_subagent'])
+
 /**
  * GET /api/tools — returns canonical tool definitions (no project context needed).
  */
@@ -68,7 +70,7 @@ export async function handleToolApi(req, res, url) {
   }
 
   const handler = toolHandlers[name]
-  if (!handler) {
+  if (!handler || directRouteDisabledTools.has(name)) {
     const error = new Error(`Unknown tool: ${name}`)
     error.statusCode = 404
     throw error

package/server/session-utils.mjs

@@ -1,13 +1,18 @@
 import { streamSimple } from '@mariozechner/pi-ai'
 import { buildInstructionsPayload } from './project-config.mjs'
 import { composeSystemPrompt } from './system-prompt.mjs'
+import { listSubagentSummaries } from './subagents.mjs'
 
 // ---------------------------------------------------------------------------
 // System prompt
 // ---------------------------------------------------------------------------
 
 export async function buildSystemPrompt(projectId) {
-  return composeSystemPrompt(await buildInstructionsPayload(projectId))
+  const instructions = await buildInstructionsPayload(projectId)
+  return composeSystemPrompt({
+    ...instructions,
+    subagents: listSubagentSummaries(),
+  })
 }
 
 // ---------------------------------------------------------------------------

package/server/share-store.mjs

@@ -370,6 +370,29 @@ export async function issueConversationShareToken(shareId) {
   })
 }
 
+function messageTimestampMs(message) {
+  const timestamp = message?.timestamp
+  if (typeof timestamp === 'number' && Number.isFinite(timestamp)) return timestamp
+  if (typeof timestamp === 'string') {
+    const trimmed = timestamp.trim()
+    if (!trimmed) return undefined
+    const numeric = Number(trimmed)
+    if (Number.isFinite(numeric)) return numeric
+    const parsed = Date.parse(trimmed)
+    return Number.isNaN(parsed) ? undefined : parsed
+  }
+  return undefined
+}
+
+function lastModifiedFromMessages(messages, fallback) {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const timestamp = messageTimestampMs(messages[index])
+    if (timestamp !== undefined) return new Date(timestamp).toISOString()
+  }
+  const fallbackMs = Date.parse(fallback)
+  return Number.isNaN(fallbackMs) ? new Date().toISOString() : new Date(fallbackMs).toISOString()
+}
+
 export async function rollbackSharedSessionMessages(record, rollbackMessageIndex) {
   const { readSessionValue, writeSessionValue, atomicUpdate } = await import('./storage.mjs')
   const { rollbackSessionMessages, rollbackStartIndexFromMessage } = await import('./agent-manager.mjs')
@@ -394,11 +417,11 @@ export async function rollbackSharedSessionMessages(record, rollbackMessageIndex
   }
 
   const nextMessages = messages.slice(0, rollbackIndex)
-  const now = new Date().toISOString()
+  const lastModified = lastModifiedFromMessages(nextMessages, session.createdAt || session.lastModified)
   await writeSessionValue(record.sessionId, {
     ...session,
     messages: nextMessages,
-    lastModified: now,
+    lastModified,
   })
   await atomicUpdate('sessions-metadata', (metadata) => {
     const existing = metadata[record.sessionId]
@@ -406,13 +429,13 @@ export async function rollbackSharedSessionMessages(record, rollbackMessageIndex
       metadata[record.sessionId] = {
         ...existing,
         messageCount: nextMessages.length,
-        lastModified: now,
+        lastModified,
         preview: previewFromMessages(nextMessages),
       }
     }
     return metadata
   })
-  return { session: { ...session, messages: nextMessages, lastModified: now }, rollbackIndex }
+  return { session: { ...session, messages: nextMessages, lastModified }, rollbackIndex }
 }
 
 function textFromContent(content) {

package/server/subagents.mjs

@@ -0,0 +1,101 @@
+const commonSubagentRules = `
+You are a focused QuickForge subagent invoked by a parent coding assistant.
+
+Rules:
+- Work only on the delegated task. Do not broaden scope.
+- Do not ask the user questions directly. If required information is missing, report it under "Needs clarification".
+- Prefer evidence from read_file and grep_files before making claims.
+- Treat your findings as advisory; the parent assistant makes final decisions.
+- Do not attempt to call or simulate other subagents.
+- Keep the response concise and structured.
+
+Return this structure when practical:
+1. Summary
+2. Work performed or findings with evidence, including file paths when relevant
+3. Risks or unknowns
+4. Suggested next steps
+`.trim()
+
+export const subagentDefinitions = [
+  {
+    name: 'general',
+    label: 'General',
+    mode: 'subagent',
+    description: 'A general-purpose agent for researching complex problems and executing multi-step tasks. It has full built-in workspace tool access, excluding MCP tools and Agent Skills, so it can modify files when needed. Use it for substantial independent work units, including parallelizable work.',
+    allowedTools: ['read_file', 'grep_files', 'write_file', 'edit_file', 'run_command'],
+    allowFileMutations: true,
+    maxRuntimeMs: 30 * 60 * 1000,
+    maxToolCalls: 300,
+    systemPrompt: `You are General, a general-purpose subagent for complex research and multi-step implementation tasks. You may inspect, edit, write files, and run commands using the built-in workspace tools when needed. You do not have MCP tools or Agent Skills. Make focused, minimal changes that satisfy the delegated task, and verify your changes when appropriate.`,
+  },
+  {
+    name: 'explore',
+    label: 'Explore',
+    mode: 'subagent',
+    description: 'A fast read-only agent for targeted exploration and focused questions. It cannot modify files. Use it to quickly find relevant files, search keywords, identify patterns, or summarize findings.',
+    allowedTools: ['read_file', 'grep_files'],
+    allowFileMutations: false,
+    maxRuntimeMs: 30 * 60 * 1000,
+    maxToolCalls: 300,
+    systemPrompt: `You are Explore, a fast read-only exploration subagent. Use read_file and grep_files to locate relevant files, search keywords, identify patterns, and answer focused questions. You cannot modify files or run commands.`,
+  },
+]
+
+const subagentByName = new Map(subagentDefinitions.map((definition) => [definition.name, definition]))
+
+export function listSubagentSummaries() {
+  return subagentDefinitions.map(({ name, label, mode, description, allowedTools }) => ({
+    name,
+    label,
+    mode,
+    description,
+    allowedTools: [...allowedTools],
+  }))
+}
+
+export function getSubagentDefinition(name) {
+  return subagentByName.get(String(name || '').trim().toLowerCase()) || null
+}
+
+export function composeSubagentSystemPrompt({ definition, parentSystemPrompt, projectContext }) {
+  const workspaceLines = []
+  if (projectContext?.project?.name) workspaceLines.push(`- Project name: ${projectContext.project.name}`)
+  if (projectContext?.workspaceRoot) workspaceLines.push(`- Workspace root: ${projectContext.workspaceRoot}`)
+  if (projectContext?.project?.id) workspaceLines.push(`- Project ID: ${projectContext.project.id}`)
+
+  return [
+    parentSystemPrompt || '',
+    '<subagent_instructions>',
+    `Subagent: ${definition.label || definition.name}`,
+    `Mode: ${definition.mode || 'subagent'}`,
+    `Description: ${definition.description}`,
+    '',
+    definition.systemPrompt,
+    '',
+    commonSubagentRules,
+    '',
+    'Tool constraints:',
+    `- Allowed tools: ${definition.allowedTools.join(', ')}`,
+    '- MCP tools and Agent Skill tools are not available to subagents.',
+    '- run_subagent is not available to subagents.',
+    definition.allowFileMutations
+      ? '- File modification tools are available when needed, subject to the parent session approval/YOLO policy.'
+      : '- This subagent is read-only. Do not modify files or run commands.',
+    workspaceLines.length ? `\nWorkspace context:\n${workspaceLines.join('\n')}` : '',
+    '</subagent_instructions>',
+  ].filter(Boolean).join('\n')
+}
+
+export function formatSubagentTask(params) {
+  const task = String(params?.task || '').trim()
+  const context = String(params?.context || '').trim()
+  const expectedOutput = String(params?.expectedOutput || '').trim()
+
+  return [
+    '<delegated_task>',
+    task,
+    '</delegated_task>',
+    context ? `\n<context>\n${context}\n</context>` : '',
+    expectedOutput ? `\n<expected_output>\n${expectedOutput}\n</expected_output>` : '',
+  ].filter(Boolean).join('\n')
+}

package/server/system-prompt.mjs

@@ -6,7 +6,10 @@ For project tasks:
 - Make surgical changes only. Do not refactor unrelated code.
 - Match existing style.
 - For multi-step work, use a brief plan.
-- Inspect the workspace before changing files.
+- Before changing files, gather sufficient context: relevant files, entry points or call chains, existing patterns, tests or validation commands, and docs/wiki impact.
+- Before taking action, confirm with the user.
+- Unless the change is trivial and localized to an already-known file, use Explore first for read-only repository research; prefer Explore for broad searches, pattern lookup, impact analysis, and locating related tests, docs, or build scripts.
+- For complex multi-step work, use General only for bounded assistance; the parent assistant remains responsible for final decisions, minimal edits, and verification.
 - Make minimal, focused changes.
 - Prefer dedicated workspace tools for reading, editing, and searching files.
 - If dedicated tools are unavailable or insufficient, use the shell/command tool.
@@ -36,6 +39,31 @@ function formatSkillCatalogItem(skill) {
   return `  <skill>\n${details.join('\n')}\n  </skill>`
 }
 
+function formatSubagentCatalogItem(subagent) {
+  const details = [
+    `    <name>${escapeXml(subagent.name)}</name>`,
+    `    <description>${escapeXml(subagent.description)}</description>`,
+  ]
+  if (Array.isArray(subagent.allowedTools)) details.push(`    <allowed_tools>${escapeXml(subagent.allowedTools.join(', '))}</allowed_tools>`)
+  return `  <subagent>\n${details.join('\n')}\n  </subagent>`
+}
+
+function appendSubagentCatalog(parts, subagents) {
+  if (!Array.isArray(subagents) || subagents.length === 0) return
+
+  const subagentParts = subagents.map(formatSubagentCatalogItem)
+  parts.push(`
+<available_subagents>
+The run_subagent tool can delegate work to one of QuickForge's built-in temporary subagents.
+
+Use Explore for fast read-only codebase search, pattern lookup, and repository questions. Use General for complex research or multi-step implementation work that may need built-in workspace tools, including file edits. Keep delegation concrete and include relevant context. Treat subagent output as advisory; you remain responsible for the final answer.
+
+Subagents are short-lived, cannot call other subagents, and do not receive MCP tools or Agent Skill tools. General may modify files subject to the parent session approval/YOLO policy; Explore is read-only.
+
+${subagentParts.join('\n')}
+</available_subagents>`)
+}
+
 function appendSkillsCatalog(parts, skills) {
   if (!Array.isArray(skills) || skills.length === 0) return
 
@@ -86,6 +114,7 @@ ${lines.join('\n')}
       ]
 
   appendSkillsCatalog(parts, skills)
+  appendSubagentCatalog(parts, instructions.subagents)
 
   return parts.join('\n')
 }

package/server/tools/definitions.mjs

@@ -1,5 +1,6 @@
 import { Type } from 'typebox'
 import { loadSelectedGlobalSkills, loadSelectedProjectSkills, mergeSkills } from '../skills.mjs'
+import { listSubagentSummaries } from '../subagents.mjs'
 
 // ---------------------------------------------------------------------------
 // Canonical workspace tool definitions.
@@ -12,7 +13,24 @@ import { loadSelectedGlobalSkills, loadSelectedProjectSkills, mergeSkills } from
 // it to a handler, and the frontend can fetch definitions from /api/tools.
 // ---------------------------------------------------------------------------
 
+const subagentNames = listSubagentSummaries().map((subagent) => subagent.name)
+
+export const subagentTool = {
+  name: 'run_subagent',
+  label: 'Run subagent',
+  description: 'Delegate a bounded task to a built-in temporary subagent. Use general for complex multi-step work with full built-in workspace tools, or explore for fast read-only lookup and focused analysis. Subagents are short-lived and do not receive MCP or Agent Skill tools.',
+  parameters: Type.Object({
+    subagent: subagentNames.length
+      ? Type.String({ enum: subagentNames, description: 'Specialized subagent to invoke.' })
+      : Type.String({ description: 'Specialized subagent to invoke.' }),
+    task: Type.String({ description: 'Concrete, bounded task for the subagent. Do not delegate vague or open-ended work.' }),
+    context: Type.Optional(Type.String({ description: 'Relevant context from the parent conversation or current plan. Keep this focused.' })),
+    expectedOutput: Type.Optional(Type.String({ description: 'Optional output requirements for the subagent result.' })),
+  }),
+}
+
 export const workspaceTools = [
+  subagentTool,
   {
     name: 'read_file',
     label: 'Read file',