@shawnstack/quickforge 1.3.18 → 1.3.19

package/node_modules/@mariozechner/pi-ai/dist/utils/diagnostics.js

@@ -0,0 +1,25 @@
+export function formatThrownValue(value) {
+    if (value instanceof Error)
+        return value.message || value.name;
+    if (typeof value === "string")
+        return value;
+    return String(value);
+}
+export function extractDiagnosticError(error) {
+    if (!(error instanceof Error))
+        return { name: "ThrownValue", message: formatThrownValue(error) };
+    const code = error.code;
+    return {
+        name: error.name || undefined,
+        message: error.message || error.name,
+        stack: error.stack,
+        code: typeof code === "string" || typeof code === "number" ? code : undefined,
+    };
+}
+export function createAssistantMessageDiagnostic(type, error, details) {
+    return { type, timestamp: Date.now(), error: extractDiagnosticError(error), details };
+}
+export function appendAssistantMessageDiagnostic(message, diagnostic) {
+    message.diagnostics = [...(message.diagnostics ?? []), diagnostic];
+}
+//# sourceMappingURL=diagnostics.js.map

package/node_modules/@mariozechner/pi-ai/dist/utils/oauth/index.js

@@ -5,17 +5,11 @@
  * for OAuth-based providers:
  * - Anthropic (Claude Pro/Max)
  * - GitHub Copilot
- * - Google Cloud Code Assist (Gemini CLI)
- * - Antigravity (Gemini 3, Claude, GPT-OSS via Google Cloud)
  */
 // Anthropic
 export { anthropicOAuthProvider, loginAnthropic, refreshAnthropicToken } from "./anthropic.js";
 // GitHub Copilot
 export { getGitHubCopilotBaseUrl, githubCopilotOAuthProvider, loginGitHubCopilot, normalizeDomain, refreshGitHubCopilotToken, } from "./github-copilot.js";
-// Google Antigravity
-export { antigravityOAuthProvider, loginAntigravity, refreshAntigravityToken } from "./google-antigravity.js";
-// Google Gemini CLI
-export { geminiCliOAuthProvider, loginGeminiCli, refreshGoogleCloudToken } from "./google-gemini-cli.js";
 // OpenAI Codex (ChatGPT OAuth)
 export { loginOpenAICodex, openaiCodexOAuthProvider, refreshOpenAICodexToken } from "./openai-codex.js";
 export * from "./types.js";
@@ -24,14 +18,10 @@ export * from "./types.js";
 // ============================================================================
 import { anthropicOAuthProvider } from "./anthropic.js";
 import { githubCopilotOAuthProvider } from "./github-copilot.js";
-import { antigravityOAuthProvider } from "./google-antigravity.js";
-import { geminiCliOAuthProvider } from "./google-gemini-cli.js";
 import { openaiCodexOAuthProvider } from "./openai-codex.js";
 const BUILT_IN_OAUTH_PROVIDERS = [
     anthropicOAuthProvider,
     githubCopilotOAuthProvider,
-    geminiCliOAuthProvider,
-    antigravityOAuthProvider,
     openaiCodexOAuthProvider,
 ];
 const oauthProviderRegistry = new Map(BUILT_IN_OAUTH_PROVIDERS.map((provider) => [provider.id, provider]));

package/node_modules/@mariozechner/pi-ai/dist/utils/oauth/openai-codex.js

@@ -84,13 +84,18 @@ async function exchangeAuthorizationCode(code, verifier, redirectUri = REDIRECT_
     });
     if (!response.ok) {
         const text = await response.text().catch(() => "");
-        console.error("[openai-codex] code->token failed:", response.status, text);
-        return { type: "failed" };
+        return {
+            type: "failed",
+            status: response.status,
+            message: `OpenAI Codex token exchange failed (${response.status}): ${text || response.statusText}`,
+        };
     }
     const json = (await response.json());
     if (!json.access_token || !json.refresh_token || typeof json.expires_in !== "number") {
-        console.error("[openai-codex] token response missing fields:", json);
-        return { type: "failed" };
+        return {
+            type: "failed",
+            message: `OpenAI Codex token exchange response missing fields: ${JSON.stringify(json)}`,
+        };
     }
     return {
         type: "success",
@@ -112,13 +117,18 @@ async function refreshAccessToken(refreshToken) {
         });
         if (!response.ok) {
             const text = await response.text().catch(() => "");
-            console.error("[openai-codex] Token refresh failed:", response.status, text);
-            return { type: "failed" };
+            return {
+                type: "failed",
+                status: response.status,
+                message: `OpenAI Codex token refresh failed (${response.status}): ${text || response.statusText}`,
+            };
         }
         const json = (await response.json());
         if (!json.access_token || !json.refresh_token || typeof json.expires_in !== "number") {
-            console.error("[openai-codex] Token refresh response missing fields:", json);
-            return { type: "failed" };
+            return {
+                type: "failed",
+                message: `OpenAI Codex token refresh response missing fields: ${JSON.stringify(json)}`,
+            };
         }
         return {
             type: "success",
@@ -128,8 +138,10 @@ async function refreshAccessToken(refreshToken) {
         };
     }
     catch (error) {
-        console.error("[openai-codex] Token refresh error:", error);
-        return { type: "failed" };
+        return {
+            type: "failed",
+            message: `OpenAI Codex token refresh error: ${error instanceof Error ? error.message : String(error)}`,
+        };
     }
 }
 async function createAuthorizationFlow(originator = "pi") {
@@ -206,8 +218,7 @@ function startLocalOAuthServer(state) {
                 waitForCode: () => waitForCodePromise,
             });
         })
-            .on("error", (err) => {
-            console.error(`[openai-codex] Failed to bind http://${CALLBACK_HOST}:1455 (`, err.code, ") Falling back to manual paste.");
+            .on("error", (_err) => {
             settleWait?.(null);
             resolve({
                 close: () => {
@@ -316,7 +327,7 @@ export async function loginOpenAICodex(options) {
         }
         const tokenResult = await exchangeAuthorizationCode(code, verifier);
         if (tokenResult.type !== "success") {
-            throw new Error("Token exchange failed");
+            throw new Error(tokenResult.message);
         }
         const accountId = getAccountId(tokenResult.access);
         if (!accountId) {
@@ -339,7 +350,7 @@ export async function loginOpenAICodex(options) {
 export async function refreshOpenAICodexToken(refreshToken) {
     const result = await refreshAccessToken(refreshToken);
     if (result.type !== "success") {
-        throw new Error("Failed to refresh OpenAI Codex token");
+        throw new Error(result.message);
     }
     const accountId = getAccountId(result.access);
     if (!accountId) {

package/node_modules/@mariozechner/pi-ai/dist/utils/overflow.js

@@ -21,6 +21,9 @@
  * - Cerebras: "400/413 status code (no body)"
  * - Mistral: "Prompt contains X tokens ... too large for model with Y maximum context length"
  * - z.ai: Does NOT error, accepts overflow silently - handled via usage.input > contextWindow
+ * - Xiaomi MiMo: Truncates input to fill contextWindow exactly, then returns finish_reason "length"
+ *   with output=0 (no room left to generate). Detected via stopReason "length" + zero output +
+ *   input filling the context window.
  * - Ollama: Some deployments truncate silently, others return errors like "prompt too long; exceeded max context length by X tokens"
  */
 const OVERFLOW_PATTERNS = [
@@ -86,6 +89,8 @@ const NON_OVERFLOW_PATTERNS = [
  * **Unreliable detection:**
  * - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow),
  *   sometimes returns rate limit errors. Pass contextWindow param to detect silent overflow.
+ * - Xiaomi MiMo: Truncates input to fit contextWindow then returns stopReason "length" with
+ *   output=0. Pass contextWindow param to detect via the "filled context + zero output" signal.
  * - Ollama: May truncate input silently for some setups, but may also return explicit
  *   overflow errors that match the patterns above. Silent truncation still cannot be
  *   detected here because we do not know the expected token count.
@@ -121,6 +126,15 @@ export function isContextOverflow(message, contextWindow) {
             return true;
         }
     }
+    // Case 3: Length-stop overflow (Xiaomi MiMo style) - server truncates oversized input
+    // to fit the context window, leaving no room for output. Returns stopReason "length"
+    // with output=0 and input+cacheRead filling the context window.
+    if (contextWindow && message.stopReason === "length" && message.usage.output === 0) {
+        const inputTokens = message.usage.input + message.usage.cacheRead;
+        if (inputTokens >= contextWindow * 0.99) {
+            return true;
+        }
+    }
     return false;
 }
 /**

package/node_modules/@mariozechner/pi-ai/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mariozechner/pi-ai",
-	"version": "0.70.6",
+	"version": "0.73.1",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -22,10 +22,6 @@
 			"types": "./dist/providers/google.d.ts",
 			"import": "./dist/providers/google.js"
 		},
-		"./google-gemini-cli": {
-			"types": "./dist/providers/google-gemini-cli.d.ts",
-			"import": "./dist/providers/google-gemini-cli.js"
-		},
 		"./google-vertex": {
 			"types": "./dist/providers/google-vertex.d.ts",
 			"import": "./dist/providers/google-vertex.js"
@@ -72,7 +68,7 @@
 		"prepublishOnly": "npm run clean && npm run build"
 	},
 	"dependencies": {
-		"@anthropic-ai/sdk": "^0.90.0",
+		"@anthropic-ai/sdk": "^0.91.1",
 		"@aws-sdk/client-bedrock-runtime": "^3.1030.0",
 		"@google/genai": "^1.40.0",
 		"@mistralai/mistralai": "^2.2.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shawnstack/quickforge",
-  "version": "1.3.18",
+  "version": "1.3.19",
   "description": "AI chat application with YOLO-mode local workspace tools. React + Vite + Tailwind CSS frontend, local Node.js storage server.",
   "keywords": [
     "ai",
@@ -42,8 +42,8 @@
     "package.json"
   ],
   "dependencies": {
-    "@mariozechner/pi-agent-core": "^0.70.5",
-    "@mariozechner/pi-ai": "^0.70.5",
+    "@mariozechner/pi-agent-core": "^0.73.1",
+    "@mariozechner/pi-ai": "^0.73.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "ws": "^8.20.1"
   },

package/server/agent-manager.mjs

@@ -5,6 +5,11 @@ import { streamSimpleWithAiHttpLogging } from './ai-http-logger.mjs'
 import { toolHandlers, loadSkillToolContext, abortRunningCommand } from './tools/index.mjs'
 import { createSkillTools, workspaceTools } from './tools/definitions.mjs'
 import { callMcpTool, createMcpToolDefinitions, isMcpToolName } from './mcp/registry.mjs'
+import {
+  composeSubagentSystemPrompt,
+  formatSubagentTask,
+  getSubagentDefinition,
+} from './subagents.mjs'
 import { projectContextFromId, readProjectConfig } from './project-config.mjs'
 import { readStore, atomicUpdate, readSessionValue, writeSessionValue, deleteSessionValue } from './storage.mjs'
 import { logger } from './utils/logger.mjs'
@@ -88,7 +93,36 @@ function wrapMcpToolDefinition(definition, toolPermissions) {
   }
 }
 
-async function createServerTools(projectId, projectContext, skillsContext, includeWorkspaceTools, toolPermissions) {
+function wrapSubagentToolDefinition(definition, parentSessionId) {
+  return {
+    ...definition,
+    execute: async (_toolCallId, params, signal, onUpdate) => {
+      const parentSession = agentSessions.get(parentSessionId)
+      if (!parentSession) throw new Error('Parent session is no longer active.')
+      const result = await runSubagent(parentSession, params || {}, signal, onUpdate)
+      return {
+        content: [{ type: 'text', text: result.content }],
+        details: result.details,
+      }
+    },
+  }
+}
+
+function wrapWorkspaceToolDefinition(definition, context, toolPermissions, options = {}) {
+  if (definition.name === 'run_subagent') return wrapSubagentToolDefinition(definition, options.parentSessionId)
+  return wrapToolDefinition(definition, context, toolPermissions)
+}
+
+async function createServerTools(projectId, projectContext, skillsContext, includeWorkspaceTools, toolPermissions, options = {}) {
+  const {
+    allowedToolNames = null,
+    includeSubagentTool = true,
+    includeMcpTools = true,
+    parentSessionId = null,
+  } = options
+  const allowedTools = allowedToolNames ? new Set(allowedToolNames) : null
+  const isAllowed = (definition) => !allowedTools || allowedTools.has(definition.name)
+
   const skillTools = await createSkillTools({
     globalSkillNames: skillsContext.globalSkillNames,
     projectSkillNames: skillsContext.projectSkillNames,
@@ -100,14 +134,21 @@ async function createServerTools(projectId, projectContext, skillsContext, inclu
     workspaceRoot: projectContext?.workspaceRoot,
   })
   const toolContext = { ...projectContext, ...skillToolContext }
-  const tools = skillTools.map((definition) => wrapToolDefinition(definition, toolContext, toolPermissions))
+  const tools = skillTools
+    .filter(isAllowed)
+    .map((definition) => wrapToolDefinition(definition, toolContext, toolPermissions))
 
   if (includeWorkspaceTools && projectId && projectContext) {
-    tools.push(...workspaceTools.map((definition) => wrapToolDefinition(definition, toolContext, toolPermissions)))
+    const definitions = workspaceTools.filter((definition) => includeSubagentTool || definition.name !== 'run_subagent')
+    tools.push(...definitions
+      .filter(isAllowed)
+      .map((definition) => wrapWorkspaceToolDefinition(definition, toolContext, toolPermissions, { parentSessionId })))
   }
 
-  const mcpTools = await createMcpToolDefinitions()
-  tools.push(...mcpTools.map((definition) => wrapMcpToolDefinition(definition, toolPermissions)))
+  if (includeMcpTools) {
+    const mcpTools = await createMcpToolDefinitions()
+    tools.push(...mcpTools.filter(isAllowed).map((definition) => wrapMcpToolDefinition(definition, toolPermissions)))
+  }
 
   return tools
 }
@@ -126,6 +167,7 @@ async function rebuildSessionTools(session) {
     sessionSkillsContext(session),
     !!(session.projectId && session.projectContext),
     createCommandToolPermissions(session),
+    { parentSessionId: session.sessionId },
   )
 }
 
@@ -139,9 +181,10 @@ const agentSessions = new Map()
 
 const IDLE_TIMEOUT_MS = 30 * 60 * 1000 // 30 minutes
 const APPROVAL_TIMEOUT_MS = 5 * 60 * 1000 // 5 minutes for tool approval
+const SUBAGENT_DEFAULT_TIMEOUT_MS = 30 * 60 * 1000
 const commandRestrictedTools = new Set(['write_file', 'edit_file', 'run_command'])
 const safeReadTools = new Set(['read_file', 'grep_files'])
-const pendingApprovals = new Map() // toolCallId → { resolve, reject, sessionId, toolName, args, timeout }
+const pendingApprovals = new Map() // toolCallId → { resolve, reject, sessionId, toolName, args, source, timeout }
 const pendingAutoCompactApprovals = new Map() // approvalId → { resolve, reject, sessionId, timeout }
 
 function createCommandToolPermissions(session) {
@@ -163,7 +206,7 @@ function createCommandToolPermissions(session) {
  * The agent loop's `await config.beforeToolCall(...)` pauses on this promise,
  * effectively freezing the agent until the user decides.
  */
-function createApprovalPromise(session, toolCallId, toolName, args) {
+function createApprovalPromise(session, toolCallId, toolName, args, source) {
   if (!session) return { block: true, reason: 'No active session for tool approval.' }
   return new Promise((resolve, reject) => {
     let settled = false
@@ -209,6 +252,7 @@ function createApprovalPromise(session, toolCallId, toolName, args) {
       sessionId: session.sessionId,
       toolName,
       args,
+      source,
     })
 
     // Notify the frontend via both the session-level and global event buses.
@@ -220,6 +264,7 @@ function createApprovalPromise(session, toolCallId, toolName, args) {
       toolCallId,
       toolName,
       args,
+      source,
     }
     session.eventBus.emit('agent_event', approvalEvent)
     agentEvents.emit('agent_event', approvalEvent)
@@ -574,6 +619,13 @@ async function resolveCommandState(session, userMessage) {
   }
 }
 
+function omitDetailsForLlm(message) {
+  if (!message || typeof message !== 'object' || message.details === undefined) return message
+  const copy = { ...message }
+  delete copy.details
+  return copy
+}
+
 /**
  * Convert AgentMessage[] to LLM-compatible Message[].
  * Handles "user-with-attachments" → "user" with multi-modal content blocks.
@@ -597,14 +649,197 @@ function serverConvertToLlm(messages) {
             }
           }
         }
-        return { ...m, role: 'user', content: textContent }
+        return omitDetailsForLlm({ ...m, role: 'user', content: textContent })
       }
-      if (m.role === 'user' || m.role === 'assistant' || m.role === 'toolResult') return m
+      if (m.role === 'user' || m.role === 'assistant' || m.role === 'toolResult') return omitDetailsForLlm(m)
       return null
     })
     .filter(Boolean)
 }
 
+function messageText(message) {
+  const content = message?.content
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) {
+    return content
+      .filter((block) => block?.type === 'text')
+      .map((block) => block.text ?? '')
+      .join('\n')
+      .trim()
+  }
+  return ''
+}
+
+function lastAssistantText(messages) {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index]
+    if (message?.role !== 'assistant') continue
+    const text = messageText(message)
+    if (text) return text
+  }
+  return ''
+}
+
+async function runSubagent(parentSession, params, parentSignal, onUpdate) {
+  const definition = getSubagentDefinition(params?.subagent)
+  if (!definition) {
+    const error = new Error(`Unknown subagent: ${params?.subagent || ''}`)
+    error.statusCode = 400
+    throw error
+  }
+
+  const task = String(params?.task || '').trim()
+  if (!task) {
+    const error = new Error('task is required')
+    error.statusCode = 400
+    throw error
+  }
+  if (!parentSession.projectId || !parentSession.projectContext) {
+    throw new Error('Subagents require an active project workspace.')
+  }
+  if (!parentSession.model) {
+    throw new Error('No active model is configured for the parent session.')
+  }
+
+  const timeoutMs = Math.max(1000, Math.min(Number(definition.maxRuntimeMs || SUBAGENT_DEFAULT_TIMEOUT_MS), 30 * 60 * 1000))
+  const subagentSessionId = `${parentSession.sessionId}:subagent:${definition.name}:${randomUUID()}`
+  const startedAt = Date.now()
+  let toolCalls = 0
+  let latestMessages = []
+  let latestPendingToolCalls = []
+  let toolsForClient = []
+
+  const tools = await createServerTools(
+    parentSession.projectId,
+    parentSession.projectContext,
+    sessionSkillsContext(parentSession),
+    true,
+    (toolName) => {
+      if (!definition.allowedTools.includes(toolName)) return `Subagent ${definition.name} is not allowed to use ${toolName}.`
+      return null
+    },
+    {
+      allowedToolNames: definition.allowedTools,
+      includeSubagentTool: false,
+      includeMcpTools: false,
+    },
+  )
+  toolsForClient = tools.map(({ execute, prepareArguments, ...tool }) => tool)
+
+  const emitSubagentTrace = () => {
+    onUpdate?.({
+      content: [],
+      details: {
+        subagent: definition.name,
+        label: definition.label,
+        sessionId: subagentSessionId,
+        parentSessionId: parentSession.sessionId,
+        toolCalls,
+        allowedTools: definition.allowedTools,
+        timeoutMs,
+        durationMs: Date.now() - startedAt,
+        messages: latestMessages,
+        tools: toolsForClient,
+        pendingToolCalls: latestPendingToolCalls,
+      },
+    })
+  }
+
+  const systemPrompt = composeSubagentSystemPrompt({
+    definition,
+    parentSystemPrompt: parentSession.agent.state.systemPrompt,
+    projectContext: parentSession.projectContext,
+  })
+  const userMessage = {
+    role: 'user',
+    content: [{ type: 'text', text: formatSubagentTask(params) }],
+    timestamp: Date.now(),
+  }
+  const subagent = new Agent({
+    initialState: {
+      systemPrompt,
+      model: parentSession.model,
+      thinkingLevel: parentSession.thinkingLevel,
+      messages: [],
+      tools,
+    },
+    streamFn: streamSimpleWithAiHttpLogging,
+    getApiKey: parentSession.getApiKey,
+    sessionId: subagentSessionId,
+    convertToLlm: serverConvertToLlm,
+    onPayload: (payload) => {
+      restoreReasoningContentInPayload(payload, subagent.state.messages, subagent.state.model)
+    },
+    beforeToolCall: async (context) => {
+      const toolName = context.toolCall?.name
+      toolCalls += 1
+      emitSubagentTrace()
+      if (toolCalls > Number(definition.maxToolCalls || 12)) {
+        return { block: true, reason: `Subagent ${definition.name} exceeded its tool-call budget.` }
+      }
+      if (!definition.allowedTools.includes(toolName)) {
+        return { block: true, reason: `Subagent ${definition.name} is not allowed to use ${toolName}.` }
+      }
+      if (!parentSession.yoloMode) {
+        if (safeReadTools.has(toolName)) return undefined
+        return createApprovalPromise(parentSession, context.toolCall?.id, toolName, context.args, {
+          type: 'subagent',
+          subagent: definition.name,
+          label: definition.label,
+          sessionId: subagentSessionId,
+        })
+      }
+      return undefined
+    },
+  })
+
+  subagent.subscribe((event) => {
+    latestMessages = subagent.state.messages.slice()
+    latestPendingToolCalls = Array.from(subagent.state.pendingToolCalls || [])
+    if (event.type === 'message_start' || event.type === 'message_update') {
+      if (event.message?.role === 'assistant') {
+        latestMessages = [...latestMessages, event.message]
+      }
+    }
+    emitSubagentTrace()
+  })
+
+  let timedOut = false
+  const timeout = setTimeout(() => {
+    timedOut = true
+    subagent.abort()
+  }, timeoutMs)
+  const onParentAbort = () => subagent.abort()
+  parentSignal?.addEventListener?.('abort', onParentAbort, { once: true })
+
+  try {
+    await subagent.prompt(userMessage)
+    if (timedOut) throw new Error(`Subagent ${definition.name} timed out after ${timeoutMs}ms.`)
+    if (parentSignal?.aborted) throw new Error(`Subagent ${definition.name} aborted with parent run.`)
+  } finally {
+    clearTimeout(timeout)
+    parentSignal?.removeEventListener?.('abort', onParentAbort)
+  }
+
+  const content = lastAssistantText(subagent.state.messages) || `Subagent ${definition.name} completed without a text response.`
+  return {
+    content,
+    details: {
+      subagent: definition.name,
+      label: definition.label,
+      sessionId: subagentSessionId,
+      parentSessionId: parentSession.sessionId,
+      toolCalls,
+      allowedTools: definition.allowedTools,
+      timeoutMs,
+      durationMs: Date.now() - startedAt,
+      messages: latestMessages,
+      tools: toolsForClient,
+      pendingToolCalls: latestPendingToolCalls,
+    },
+  }
+}
+
 function applyActiveCommandPrompt(messages, commandPrompt) {
   if (!commandPrompt) return messages
 
@@ -717,6 +952,7 @@ export async function createAgent(sessionId, config = {}) {
     systemPrompt = null,
     title = 'New chat',
     createdAt = new Date().toISOString(),
+    lastModified = null,
     contextCompaction = null,
   } = config
 
@@ -764,6 +1000,7 @@ export async function createAgent(sessionId, config = {}) {
       const session = agentSessions.get(sessionId)
       return session ? createCommandToolPermissions(session)(toolName) : null
     },
+    { parentSessionId: sessionId },
   )
 
   // Resolve API key
@@ -798,6 +1035,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 (toolName === 'run_subagent') return undefined
       if (isMcpToolName(toolName)) {
         if (!currentSession?.yoloMode) return createApprovalPromise(currentSession, toolCallId, toolName, context.args)
         return undefined
@@ -828,6 +1066,7 @@ export async function createAgent(sessionId, config = {}) {
     scope,
     title,
     createdAt,
+    lastModified,
     globalSkillNames: skillsContext.globalSkillNames,
     projectSkillNames: skillsContext.projectSkillNames,
     status: 'idle',
@@ -902,11 +1141,35 @@ export async function createAgent(sessionId, config = {}) {
   return session
 }
 
+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 sessionLastModifiedFromMessages(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()
+}
+
 /**
  * Persist session data to storage.
  */
 async function persistSession(session) {
-  const { sessionId, agent, scope, projectId, title, createdAt, status, startedAt, finishedAt, model, thinkingLevel, yoloMode, contextCompaction } = session
+  const { sessionId, agent, scope, projectId, title, createdAt, lastModified: storedLastModified, status, startedAt, finishedAt, model, thinkingLevel, yoloMode, contextCompaction } = session
   const messages = agent.state.messages
 
   if (messages.length === 0) {
@@ -923,6 +1186,7 @@ async function persistSession(session) {
   }
 
   const now = new Date().toISOString()
+  const lastModified = sessionLastModifiedFromMessages(messages, storedLastModified || createdAt || now)
   const sessionData = {
     id: sessionId,
     title,
@@ -931,7 +1195,7 @@ async function persistSession(session) {
     yoloMode,
     messages,
     createdAt: createdAt || now,
-    lastModified: now,
+    lastModified,
     scope,
     projectId: scope === 'project' ? projectId : undefined,
     taskStatus: status,
@@ -939,6 +1203,7 @@ async function persistSession(session) {
     taskFinishedAt: finishedAt,
     contextCompaction: contextCompaction || undefined,
   }
+  session.lastModified = lastModified
 
   // Calculate usage
   let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 }
@@ -974,7 +1239,7 @@ async function persistSession(session) {
     id: sessionId,
     title,
     createdAt: createdAt || now,
-    lastModified: now,
+    lastModified,
     messageCount: messages.length,
     usage,
     thinkingLevel,
@@ -1261,6 +1526,7 @@ export function getSessionState(sessionId) {
     thinkingLevel: session.thinkingLevel,
     title: session.title,
     createdAt: session.createdAt,
+    lastModified: session.lastModified,
     status: session.status,
     startedAt: session.startedAt,
     finishedAt: session.finishedAt,
@@ -1362,6 +1628,7 @@ export async function restoreAgent(sessionId) {
       messages: sessionData.messages || [],
       title: sessionData.title || 'New chat',
       createdAt: sessionData.createdAt,
+      lastModified: sessionData.lastModified,
       contextCompaction: sessionData.contextCompaction || null,
     })
   } catch (err) {