@bibobonking/opensol 3.1.2 → 3.1.4

package/src/components/TopBar.tsx

@@ -2,6 +2,7 @@ import {
   FolderOpen,
   ListChecks,
   Menu,
+  MessageSquareCode,
   Moon,
   PanelLeftOpen,
   Rocket,
@@ -19,6 +20,8 @@ import { cn } from '../lib/utils'
 import { themeIsDark } from '../lib/themes'
 import { LogoMark } from './Logo'
 import { ContextBar } from './ContextBar'
+import { SystemPromptModal } from './SystemPromptModal'
+import { useState } from 'react'
 
 export type ChatViewMode = 'chat' | 'trajectory'
 
@@ -44,7 +47,11 @@ export function TopBar({
   const setWorkspaceOpen = useUi((state) => state.setWorkspaceOpen)
   const setDeployOpen = useUi((state) => state.setDeployOpen)
   const workspace = useWorkspace((state) => state.info)
+  const workspaceRoot = useWorkspace((state) => state.root)
   const activeModel = useActiveModel()
+  const [promptOpen, setPromptOpen] = useState(false)
+  const root = session?.workspace || workspaceRoot || ''
+  const promptIsCustom = Boolean(session?.systemPrompt?.trim() || (root && settings.workspacePrompts[root]?.trim()))
 
   // Go through the theme registry so Night Owl, Claude Code, Solar and plugin themes count as dark.
   const isDark = themeIsDark(
@@ -126,6 +133,17 @@ export function TopBar({
             <ContextBar messages={session?.messages ?? []} model={activeModel} sessionId={session?.id ?? null} />
           </div>
         )}
+        <button
+          type="button"
+          className={cn('icon-button relative hidden sm:inline-flex', promptIsCustom && 'text-accent')}
+          onClick={() => setPromptOpen(true)}
+          disabled={!session}
+          title={promptIsCustom ? 'Custom system prompt for this session or workspace' : 'Edit the system prompt for this session'}
+          aria-label="Edit system prompt"
+        >
+          <MessageSquareCode size={16} />
+          {promptIsCustom && <span className="absolute right-1 top-1 h-1.5 w-1.5 rounded-full bg-accent" />}
+        </button>
         <button
           type="button"
           onClick={() => setWorkspaceOpen(!workspaceOpen)}
@@ -177,6 +195,7 @@ export function TopBar({
           <Settings size={16} />
         </button>
       </div>
+      <SystemPromptModal session={session} open={promptOpen} onClose={() => setPromptOpen(false)} />
     </header>
   )
 }

package/src/components/WorkspacePanel.tsx

@@ -28,6 +28,7 @@ import { useWorkspace } from '../store/workspace'
 import { PreviewPane } from './PreviewPane'
 import { SessionsTab } from './SessionsTab'
 import { useChats } from '../store/chats'
+import { FileIcon } from './FileIcon'
 import { Spinner } from './ui'
 
 interface TreeNode {
@@ -248,6 +249,9 @@ export function WorkspacePanel() {
     return entries.filter((entry) => entry.path.toLowerCase().includes(clean)).slice(0, 300)
   }, [entries, query])
   const lineCount = content ? content.split('\n').length : 0
+  const dirCount = entries.filter((entry) => entry.type === 'dir').length
+  const fileCount = entries.length - dirCount
+  const dirPaths = useMemo(() => entries.filter((entry) => entry.type === 'dir').map((entry) => entry.path), [entries])
 
   useEffect(() => {
     if (editor) editorRef.current?.focus()
@@ -318,44 +322,54 @@ export function WorkspacePanel() {
       const closed = collapsed.has(path)
       return (
         <div key={path}>
-          <button
-            type="button"
-            onClick={() =>
-              setCollapsed((current) => {
-                const next = new Set(current)
-                if (next.has(path)) next.delete(path)
-                else next.add(path)
-                return next
-              })
-            }
-            className="group flex h-7 w-full items-center gap-1.5 rounded-md pr-1.5 text-left text-[11.5px] font-medium text-muted transition-colors hover:bg-raised hover:text-ink"
-            style={{ paddingLeft: 8 + depth * 13 }}
-            title={path}
+          <div
+            className="group/row relative flex h-7 items-center rounded-lg transition-colors hover:bg-raised/80"
+            style={{ paddingLeft: 6 + depth * 14 }}
           >
-            <ChevronRight size={10} className={cn('shrink-0 text-faint transition-transform', !closed && 'rotate-90')} />
-            {closed ? (
-              <Folder size={12} className="shrink-0 text-faint" />
-            ) : (
-              <FolderOpen size={12} className="shrink-0 text-faint" />
-            )}
-            <span className="min-w-0 flex-1 truncate">{node.entry.name}</span>
-            <span
-              role="button"
-              tabIndex={0}
-              onClick={(event) => {
-                event.stopPropagation()
-                void removeEntry(path)
-              }}
-              onKeyDown={(event) => {
-                if (event.key === 'Enter') void removeEntry(path)
-              }}
-              className="hidden h-5 w-5 items-center justify-center rounded text-faint hover:text-danger group-hover:flex"
+            <button
+              type="button"
+              onClick={() =>
+                setCollapsed((current) => {
+                  const next = new Set(current)
+                  if (next.has(path)) next.delete(path)
+                  else next.add(path)
+                  return next
+                })
+              }
+              className="flex min-w-0 flex-1 items-center gap-1.5 pr-1 text-left text-[11.5px] font-medium text-muted transition-colors hover:text-ink"
+              title={path}
+              aria-expanded={!closed}
+            >
+              <ChevronRight
+                size={10}
+                className={cn('shrink-0 text-faint transition-transform duration-150', !closed && 'rotate-90')}
+              />
+              <FileIcon path={path} type="dir" open={!closed} size={13} />
+              <span className="min-w-0 flex-1 truncate">{node.entry.name}</span>
+              <span className="shrink-0 pr-1 font-mono text-[8.5px] tabular-nums text-faint opacity-0 transition-opacity group-hover/row:opacity-100">
+                {node.children.length}
+              </span>
+            </button>
+            <button
+              type="button"
+              onClick={() => void removeEntry(path)}
+              className="mr-1 flex h-5 w-5 shrink-0 items-center justify-center rounded text-faint opacity-0 transition-all hover:bg-danger/10 hover:text-danger focus-visible:opacity-100 group-hover/row:opacity-100"
               aria-label={`Delete ${path}`}
+              title={`Delete ${path}`}
             >
               <Trash2 size={10} />
-            </span>
-          </button>
-          {!closed && node.children.map((child) => renderNode(child, depth + 1))}
+            </button>
+          </div>
+          {!closed && (
+            <div className="relative">
+              <span
+                aria-hidden
+                className="pointer-events-none absolute bottom-0.5 top-0 w-px bg-line/60"
+                style={{ left: 11 + depth * 14 }}
+              />
+              {node.children.map((child) => renderNode(child, depth + 1))}
+            </div>
+          )}
         </div>
       )
     }
@@ -365,14 +379,24 @@ export function WorkspacePanel() {
         type="button"
         onClick={() => setActiveFile(path)}
         className={cn(
-          'flex h-7 w-full items-center gap-1.5 rounded-md pr-1.5 text-left font-mono text-[10.5px] transition-colors',
-          activeFile === path ? 'bg-accent-soft font-medium text-accent' : 'text-muted hover:bg-raised hover:text-ink',
+          'group/row relative flex h-7 w-full items-center gap-1.5 rounded-lg pr-1.5 text-left font-mono text-[10.5px] transition-colors',
+          activeFile === path
+            ? 'bg-accent-soft/80 font-medium text-accent'
+            : 'text-muted hover:bg-raised/80 hover:text-ink',
         )}
-        style={{ paddingLeft: 8 + depth * 13 + 10 }}
+        style={{ paddingLeft: 22 + depth * 14 }}
         title={path}
       >
-        <FileText size={11} className={cn('shrink-0', activeFile === path ? 'text-accent' : 'text-faint')} />
+        {activeFile === path && (
+          <span aria-hidden className="absolute left-0 top-1 bottom-1 w-[2px] rounded-full bg-accent" />
+        )}
+        <FileIcon path={path} size={12} className={cn(activeFile === path && 'text-accent')} />
         <span className="min-w-0 flex-1 truncate">{node.entry.name}</span>
+        {node.entry.size > 0 && (
+          <span className="shrink-0 font-mono text-[8.5px] tabular-nums text-faint opacity-0 transition-opacity group-hover/row:opacity-100">
+            {formatBytes(node.entry.size)}
+          </span>
+        )}
       </button>
     )
   }
@@ -515,6 +539,20 @@ export function WorkspacePanel() {
                       aria-label="Find a file"
                     />
                   </div>
+                  <div className="flex items-center justify-between gap-2 px-1 pt-1.5 text-[8.5px] text-faint">
+                    <span className="truncate">
+                      {filtered ? `${filtered.length} matches` : `${fileCount} files · ${dirCount} folders`}
+                    </span>
+                    {!filtered && dirCount > 0 && (
+                      <button
+                        type="button"
+                        onClick={() => setCollapsed(collapsed.size > 0 ? new Set() : new Set(dirPaths))}
+                        className="shrink-0 font-medium hover:text-ink"
+                      >
+                        {collapsed.size > 0 ? 'Expand all' : 'Collapse all'}
+                      </button>
+                    )}
+                  </div>
                   {editor && (
                     <div className="mt-1.5 flex items-center gap-1">
                       <input
@@ -549,24 +587,34 @@ export function WorkspacePanel() {
                       <Spinner size={11} /> Reading folder…
                     </p>
                   )}
-                  {filtered
-                    ? filtered.map((entry) => (
+                  {filtered ? (
+                    <>
+                      {filtered.map((entry) => (
                         <button
                           key={entry.path}
                           type="button"
                           onClick={() => entry.type === 'file' && setActiveFile(entry.path)}
                           className={cn(
-                            'flex h-7 w-full items-center gap-1.5 rounded-md px-2 text-left font-mono text-[10.5px]',
+                            'group/row relative flex h-7 w-full items-center gap-1.5 rounded-lg px-2 text-left font-mono text-[10.5px] transition-colors',
                             activeFile === entry.path
-                              ? 'bg-accent-soft font-medium text-accent'
-                              : 'text-muted hover:bg-raised hover:text-ink',
+                              ? 'bg-accent-soft/80 font-medium text-accent'
+                              : 'text-muted hover:bg-raised/80 hover:text-ink',
                           )}
                         >
-                          {entry.type === 'dir' ? <Folder size={11} /> : <FileText size={11} />}
+                          {activeFile === entry.path && (
+                            <span aria-hidden className="absolute left-0 top-1 bottom-1 w-[2px] rounded-full bg-accent" />
+                          )}
+                          <FileIcon path={entry.path} type={entry.type === 'dir' ? 'dir' : 'file'} size={12} />
                           <span className="truncate">{entry.path}</span>
                         </button>
-                      ))
-                    : tree.map((node) => renderNode(node, 0))}
+                      ))}
+                      {filtered.length === 0 && (
+                        <p className="px-2 py-4 text-center text-[10.5px] text-faint">No matches in this folder.</p>
+                      )}
+                    </>
+                  ) : (
+                    tree.map((node) => renderNode(node, 0))
+                  )}
                   {!loadingTree && !treeError && entries.length === 0 && (
                     <p className="px-2 py-4 text-center text-[10.5px] text-faint">This folder is empty.</p>
                   )}

package/src/core/kernel.ts

@@ -17,6 +17,7 @@ import * as toolGrep from './plugins/tools/grep'
 import * as toolGit from './plugins/tools/git'
 import * as toolWeb from './plugins/tools/web'
 import * as toolSubagent from './plugins/tools/subagent'
+import * as toolSkill from './plugins/tools/skill'
 
 export function createAppKernel(): Context {
   const ctx = new Context()
@@ -40,6 +41,7 @@ export function createAppKernel(): Context {
   ctx.plugin(toolGit)
   ctx.plugin(toolWeb)
   ctx.plugin(toolSubagent)
+  ctx.plugin(toolSkill)
 
   return ctx
 }

package/src/core/plugins/tools/skill.ts

@@ -0,0 +1,101 @@
+import type { Context } from 'cordis'
+import { executeDaemonTool } from '../../../lib/daemon'
+import type { Skill } from '../../../types'
+import type { ToolResult } from '../../types'
+
+function findSkill(skills: Skill[], name: string): Skill | undefined {
+  const clean = name.trim().toLowerCase()
+  return skills.find((skill) => skill.id.toLowerCase() === clean || skill.name.toLowerCase() === clean)
+}
+
+function text(args: Record<string, unknown>, key: string): string {
+  return typeof args[key] === 'string' ? String(args[key]).trim() : ''
+}
+
+export const name = 'tool-skill'
+export const inject = ['tools']
+
+export function apply(ctx: Context) {
+  const unregister = ctx.tools.register({
+    name: 'skill',
+    description:
+      'Work with installed skills. Use action "list" to see them, "read" to load a skill’s SKILL.md, and "run" to execute a command inside the skill folder.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', enum: ['list', 'read', 'run'], description: 'What to do.' },
+        name: { type: 'string', description: 'Skill id or name. Required for read and run.' },
+        command: { type: 'string', description: 'Shell command to run inside the skill folder. Required for run.' },
+      },
+      required: ['action'],
+      additionalProperties: false,
+    },
+    allowedInMode: () => true,
+    async execute(args, exec): Promise<ToolResult> {
+      const skills = exec.settings.skills.filter((skill) => skill.enabled)
+      const action = text(args, 'action') || 'list'
+
+      if (action === 'list') {
+        if (skills.length === 0) return { output: 'No skills are installed.', isError: false }
+        return {
+          output: skills
+            .map((skill) => `${skill.name} (${skill.id})${skill.package ? ` · ${skill.package}` : ''}\n  ${skill.description}`)
+            .join('\n'),
+          isError: false,
+        }
+      }
+
+      const target = findSkill(skills, text(args, 'name'))
+      if (!target) {
+        return {
+          output: `No enabled skill matches "${text(args, 'name')}". Call action "list" to see the available skills.`,
+          isError: true,
+        }
+      }
+
+      if (action === 'read') {
+        const files = Object.keys(target.files ?? {})
+        return {
+          output: [
+            `# ${target.name}`,
+            target.description,
+            target.package ? `Package: ${target.package}` : '',
+            files.length > 0 ? `Files:\n${files.map((file) => `- ${file}`).join('\n')}` : '',
+            '---',
+            target.instructions.trim() || 'This skill has no instructions.',
+          ]
+            .filter(Boolean)
+            .join('\n\n'),
+          isError: false,
+        }
+      }
+
+      if (action === 'run') {
+        if (exec.mode === 'plan') {
+          return { output: 'Plan mode is read-only: skill scripts may change the machine, so they cannot run here.', isError: true }
+        }
+        const command = text(args, 'command')
+        if (!command) return { output: 'Pass the command to run inside the skill folder.', isError: true }
+        if (!target.files || Object.keys(target.files).length === 0) {
+          return { output: `"${target.name}" has no files to run. Install it from a folder or npm.`, isError: true }
+        }
+        const result = (await executeDaemonTool(
+          'skill_run',
+          { name: target.id, files: target.files, command },
+          exec.mode,
+          exec.signal,
+        )).result as { stdout?: string; stderr?: string; code?: number }
+        const code = typeof result.code === 'number' ? result.code : 1
+        const body = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim()
+        return {
+          output: body || `The skill command exited with code ${code} and printed nothing.`,
+          isError: code !== 0,
+        }
+      }
+
+      return { output: `Unknown skill action "${action}". Use list, read or run.`, isError: true }
+    },
+  })
+
+  return () => unregister()
+}

package/src/core/services/agent-loop.ts

@@ -4,17 +4,16 @@ import { activeModelId, useSettings } from '../../store/settings'
 import { createId } from '../../store/chats'
 import { findModel } from '../../store/models'
 import { useRuntime } from '../../store/ui'
+import { useWorkspace } from '../../store/workspace'
 import { getProviderName } from '../../data/providers'
 import { describeRequestError } from '../../lib/sse'
+import { MAX_PROVIDER_RETRIES, isRetryableProviderError, retryDelayMs } from '../../lib/retry'
 import type { AdapterResult } from '../../agent/adapters/shared'
 import { createTurnQueue, lastUserMessageId } from '../../agent/queue'
 import { resolveToolSetting } from '../mcp-tools'
 import type { StepContext, StepResult, TurnResult } from '../types'
 
-const MAX_ROUNDS = 16
-const MAX_RETRIES = 2
-/** Provider hiccups worth another try: overload, rate limits, 5xx and dropped connections. */
-const RETRYABLE = /\b(429|500|502|503|504|529)\b|rate.?limit|overloaded|temporar|timed out|could not be reached|lost the connection|failed to fetch|networkerror/i
+const MAX_RETRIES = MAX_PROVIDER_RETRIES
 
 function sleep(ms: number, signal: AbortSignal): Promise<void> {
   return new Promise((resolve) => {
@@ -112,7 +111,8 @@ export class AgentLoopService extends Service {
     let turnError: string | undefined
 
     try {
-      rounds: for (let round = 0; round < MAX_ROUNDS; round += 1) {
+      // No round cap: the turn ends when the model stops calling tools or the user stops it.
+      rounds: for (let round = 0; ; round += 1) {
         totalRounds = round + 1
         if (controller.signal.aborted) break
         let current = this.ctx.sessions.current(sessionId)
@@ -188,7 +188,12 @@ export class AgentLoopService extends Service {
               settings,
               model: findModel(settings.provider, activeModelId(settings)),
               history,
-              system: this.ctx.systemPrompt.assemble(settings, mode),
+              system: this.ctx.systemPrompt.assemble(settings, mode, {
+                sessionPrompt: current.systemPrompt,
+                workspacePrompt: current.workspace
+                  ? settings.workspacePrompts[current.workspace]
+                  : settings.workspacePrompts[useWorkspace.getState().root ?? ''],
+              }),
               mode,
               signal: controller.signal,
               handlers: {
@@ -215,23 +220,34 @@ export class AgentLoopService extends Service {
               attempt < MAX_RETRIES &&
               !streamedContent &&
               !streamedReasoning &&
-              RETRYABLE.test(error instanceof Error ? error.message : '')
+              isRetryableProviderError(error instanceof Error ? error.message : '')
             if (retryable) {
               attempt += 1
+              const reason = (error instanceof Error ? error.message : 'provider error').replace(/\s+/g, ' ').slice(0, 240)
               window.dispatchEvent(
                 new CustomEvent('maxcode:notice', {
                   detail: {
-                    message: `${providerName} is busy. Retrying (${attempt}/${MAX_RETRIES})…`,
+                    message: `${providerName}: ${reason} — retrying ${attempt}/${MAX_RETRIES}…`,
                     tone: 'info',
                   },
                 }),
               )
-              await sleep(1200 * attempt * attempt, controller.signal)
+              await sleep(retryDelayMs(attempt), controller.signal)
               if (controller.signal.aborted) continue
               continue
             }
             if (flushTimer !== undefined) window.clearTimeout(flushTimer)
             turnError = stopped ? undefined : describeRequestError(error, providerName)
+            if (turnError) {
+              window.dispatchEvent(
+                new CustomEvent('maxcode:notice', {
+                  detail: {
+                    message: `${providerName} failed after ${attempt + 1} attempt${attempt === 0 ? '' : 's'}: ${turnError}`,
+                    tone: 'error',
+                  },
+                }),
+              )
+            }
             this.ctx.sessions.updateMessage(sessionId, assistantId, {
               content: streamedContent,
               reasoning: streamedReasoning,
@@ -250,7 +266,7 @@ export class AgentLoopService extends Service {
           reasoning: result.reasoning,
           thinkingBlocks: result.thinkingBlocks,
           toolCalls: result.toolCalls,
-          usage: usage.input || usage.output ? usage : result.usage,
+          usage: usage.input || usage.output || usage.cost ? usage : result.usage,
           durationMs: Date.now() - startedAt,
           stopped: controller.signal.aborted || undefined,
         })
@@ -384,24 +400,6 @@ export class AgentLoopService extends Service {
           break
         }
       }
-
-      const finalSession = this.ctx.sessions.current(sessionId)
-      if (!controller.signal.aborted && finalSession) {
-        const last = finalSession.messages[finalSession.messages.length - 1]
-        if (last?.role === 'tool') {
-          const message: AssistantMessage = {
-            id: createId('msg'),
-            role: 'assistant',
-            content: '',
-            reasoning: '',
-            toolCalls: [],
-            round: MAX_ROUNDS,
-            createdAt: Date.now(),
-            error: `Stopped after ${MAX_ROUNDS} tool rounds. Send another message to continue.`,
-          }
-          this.ctx.sessions.addMessage(sessionId, message)
-        }
-      }
     } finally {
       this.controllers.delete(sessionId)
       useRuntime.getState().setStreaming(sessionId, false)

package/src/core/services/system-prompt.ts

@@ -43,28 +43,30 @@ export class SystemPromptService extends Service {
     return () => this.customSections.delete(name)
   }
 
-  assemble(settings: AppSettings, mode: AgentMode = settings.mode): string {
+  assemble(
+    settings: AppSettings,
+    mode: AgentMode = settings.mode,
+    overrides: { sessionPrompt?: string; workspacePrompt?: string } = {},
+  ): string {
     const sections: PromptSection[] = []
 
-    // 1. Base instruction
-    if (settings.systemPrompt?.trim()) {
-      sections.push({ name: 'base', priority: 10, content: settings.systemPrompt.trim() })
+    // 1. Base instruction: session override, then workspace override, then the shared prompt.
+    const base = overrides.sessionPrompt?.trim() || overrides.workspacePrompt?.trim() || settings.systemPrompt?.trim()
+    if (base) {
+      sections.push({ name: 'base', priority: 10, content: base })
     }
 
-    // 2. Loaded skills
-    const skills = settings.skills.filter((skill) => skill.enabled)
+    // 2. Skills are discovered, not pasted: the model loads one through the skill tool.
+    const skills = settings.tools.skill?.enabled === false ? [] : settings.skills.filter((skill) => skill.enabled)
     if (skills.length > 0) {
       sections.push({
         name: 'skills',
         priority: 20,
         content: [
-          '## Loaded skills',
-          'Apply these skills when the task matches their purpose. They refine the working rules above; they never override safety, tool permissions or plan mode.',
-          ...skills.map(
-            (skill) =>
-              `<skill name="${skill.name}">\nPurpose: ${skill.description}\n${skill.instructions.trim()}\n</skill>`,
-          ),
-        ].join('\n\n'),
+          '## Available skills',
+          'Call the `skill` tool to load the full instructions (and run scripts from the skill folder) when a task matches one of these. Do not guess a skill’s contents.',
+          ...skills.map((skill) => `- ${skill.name} (${skill.id}): ${skill.description}`),
+        ].join('\n'),
       })
     }
 

package/src/core/services/tools.ts

@@ -15,6 +15,7 @@ const READ_ONLY_TOOLS = new Set<ToolName>([
   'grep',
   'web_search',
   'read_url',
+  'skill',
 ])
 
 export function toolAllowedInMode(name: ToolName, mode: AgentMode): boolean {

package/src/lib/daemon.ts

@@ -12,6 +12,7 @@ import type {
   ProviderId,
   ProviderStatus,
   SecretsSummary,
+  Skill,
   WorkspaceFile,
   WorkspaceInfo,
 } from '../types'
@@ -263,6 +264,10 @@ export function setDeployCredentials(provider: DeployProviderId, fields: Record<
   })
 }
 
+export function installSkillFromNpmRequest(packageName: string) {
+  return api<{ skill: Skill }>('/api/skills/install', { method: 'POST', body: JSON.stringify({ package: packageName }) })
+}
+
 export function resetScope(scope: 'history' | 'secrets' | 'settings' | 'all'): Promise<DaemonSnapshot> {
   return api('/api/reset', jsonBody({ scope }))
 }
@@ -452,6 +457,20 @@ export async function requestLLM(
   return response
 }
 
+export interface DeployInspection {
+  path: string
+  name: string
+  hasPackageJson: boolean
+  framework: string
+  buildCommand: string
+  outputDir: string
+  existingOutputs: string[]
+}
+
+export function inspectDeploy(path: string): Promise<DeployInspection> {
+  return api('/api/deploy/inspect', { method: 'POST', body: JSON.stringify({ path }) })
+}
+
 export async function* streamDeploy(
   request: DeployRequest,
   signal?: AbortSignal,

package/src/lib/permissions.ts

@@ -21,7 +21,7 @@ export const PERMISSION_MODES: Array<{ value: PermissionMode; label: string; des
 ]
 
 const WRITE_TOOLS: BuiltinToolName[] = ['write_file', 'edit_file', 'rewrite_file']
-const GUARDED_TOOLS: BuiltinToolName[] = ['shell', 'git', 'subagent']
+const GUARDED_TOOLS: BuiltinToolName[] = ['shell', 'git', 'subagent', 'skill']
 
 export function permissionMode(tools: AppSettings['tools']): PermissionMode {
   const writesAuto = WRITE_TOOLS.every((tool) => tools[tool]?.approval === 'auto')

package/src/lib/retry.test.mjs

@@ -0,0 +1,17 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { MAX_PROVIDER_RETRIES, isRetryableProviderError, retryDelayMs } from './retry.ts'
+
+test('provider hiccups are retried, auth and validation errors are not', () => {
+  assert.equal(isRetryableProviderError('429 Too Many Requests'), true)
+  assert.equal(isRetryableProviderError('503 Service Unavailable'), true)
+  assert.equal(isRetryableProviderError('socket hang up: ECONNRESET'), true)
+  assert.equal(isRetryableProviderError('401 Unauthorized: invalid api key'), false)
+  assert.equal(isRetryableProviderError('400 invalid request: unknown field'), false)
+})
+
+test('five retries with a capped backoff', () => {
+  assert.equal(MAX_PROVIDER_RETRIES, 5)
+  assert.equal(retryDelayMs(1), 1200)
+  assert.equal(retryDelayMs(5), 8000)
+})

package/src/lib/retry.ts

@@ -0,0 +1,13 @@
+/** Automatic retries for provider hiccups: overload, rate limits, 5xx and dropped connections. */
+export const MAX_PROVIDER_RETRIES = 5
+
+const RETRYABLE =
+  /\b(408|409|425|429|500|502|503|504|522|524|529)\b|rate.?limit|overloaded|temporar|timed out|could not be reached|lost the connection|failed to fetch|networkerror|econnreset|etimedout|enotfound|eai_again/i
+
+export function isRetryableProviderError(message: string): boolean {
+  return RETRYABLE.test(message)
+}
+
+export function retryDelayMs(attempt: number): number {
+  return Math.min(1200 * attempt * attempt, 8000)
+}

package/src/lib/skills.test.mjs

@@ -0,0 +1,22 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { parseSkillMarkdown } from './skills.ts'
+
+test('frontmatter supplies the name and description', () => {
+  const skill = parseSkillMarkdown('---\nname: API reviewer\ndescription: "Checks a diff"\n---\n# Ignored\n\nBody text.', 'fallback')
+  assert.equal(skill.name, 'API reviewer')
+  assert.equal(skill.description, 'Checks a diff')
+  assert.equal(skill.instructions, '# Ignored\n\nBody text.')
+})
+
+test('a plain SKILL.md falls back to its heading and first paragraph', () => {
+  const skill = parseSkillMarkdown('# Deploy helper\n\nRuns the release checklist.\n\n## Steps\n1. build', 'fallback')
+  assert.equal(skill.name, 'Deploy helper')
+  assert.equal(skill.description, 'Runs the release checklist.')
+})
+
+test('an empty fallback markdown still returns a usable skill', () => {
+  const skill = parseSkillMarkdown('', 'my-skill')
+  assert.equal(skill.name, 'my-skill')
+  assert.equal(skill.description, 'Installed from a folder')
+})