@bibobonking/opensol 3.1.1 → 3.1.3

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 {
@@ -333,11 +334,7 @@ export function WorkspacePanel() {
             title={path}
           >
             <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" />
-            )}
+            <FileIcon path={path} type="dir" open={!closed} size={13} />
             <span className="min-w-0 flex-1 truncate">{node.entry.name}</span>
             <span
               role="button"
@@ -365,14 +362,19 @@ 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',
+          'group 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',
         )}
         style={{ paddingLeft: 8 + depth * 13 + 10 }}
         title={path}
       >
-        <FileText size={11} className={cn('shrink-0', activeFile === path ? 'text-accent' : 'text-faint')} />
+        <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 text-[8.5px] tabular-nums text-faint/70 opacity-0 transition-opacity group-hover:opacity-100">
+            {formatBytes(node.entry.size)}
+          </span>
+        )}
       </button>
     )
   }
@@ -562,7 +564,7 @@ export function WorkspacePanel() {
                               : 'text-muted hover:bg-raised hover:text-ink',
                           )}
                         >
-                          {entry.type === 'dir' ? <Folder size={11} /> : <FileText size={11} />}
+                          {entry.type === 'dir' ? <FileIcon path={entry.path} type="dir" size={12} /> : <FileIcon path={entry.path} size={12} />}
                           <span className="truncate">{entry.path}</span>
                         </button>
                       ))

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,6 +4,7 @@ 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 type { AdapterResult } from '../../agent/adapters/shared'
@@ -11,7 +12,6 @@ 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
@@ -112,7 +112,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 +189,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: {
@@ -250,7 +256,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 +390,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/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')
+})

package/src/lib/skills.ts

@@ -0,0 +1,93 @@
+import type { Skill } from '../types'
+
+const TEXT_FILE = /\.(md|markdown|txt|json|ya?ml|toml|js|mjs|cjs|ts|tsx|jsx|py|sh|bash|zsh|css|html|xml|csv)$/i
+const MAX_FILE = 512 * 1024
+const MAX_TOTAL = 4 * 1024 * 1024
+const MAX_FILES = 200
+
+export interface ParsedSkill {
+  name: string
+  description: string
+  instructions: string
+}
+
+/** Read the optional YAML frontmatter, then the first heading and paragraph. */
+export function parseSkillMarkdown(markdown: string, fallbackName: string): ParsedSkill {
+  const text = String(markdown ?? '').replace(/\r\n/g, '\n')
+  const front = /^---\n([\s\S]*?)\n---\n?/.exec(text)
+  const meta: Record<string, string> = {}
+  let body = text
+  if (front) {
+    for (const line of front[1].split('\n')) {
+      const match = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(line.trim())
+      if (match) meta[match[1].toLowerCase()] = match[2].replace(/^["']|["']$/g, '').trim()
+    }
+    body = text.slice(front[0].length)
+  }
+  const heading = /^#\s+(.+)$/m.exec(body)
+  const paragraph = body
+    .split(/\n\s*\n/)
+    .map((part) => part.trim())
+    .find((part) => part && !part.startsWith('#') && !part.startsWith('---'))
+  return {
+    name: meta.name || heading?.[1]?.trim() || fallbackName,
+    description: (meta.description || paragraph || 'Installed from a folder')
+      .replace(/[#>*`]/g, '')
+      .replace(/\s+/g, ' ')
+      .slice(0, 200),
+    instructions: body.trim(),
+  }
+}
+
+function slug(value: string) {
+  return (
+    value
+      .toLowerCase()
+      .replace(/[^a-z0-9-]+/g, '-')
+      .replace(/^-+|-+$/g, '')
+      .slice(0, 48) || 'skill'
+  )
+}
+
+type FolderFile = { path: string; text: string }
+
+function pickSkillPath(files: FolderFile[]) {
+  const candidates = files.filter((file) => /(^|\/)SKILL\.md$/i.test(file.path))
+  candidates.sort((a, b) => a.path.split('/').length - b.path.split('/').length || a.path.localeCompare(b.path))
+  return candidates[0]?.path ?? ''
+}
+
+/** Turn a folder upload into a skill. Files stay in settings so the skill tool can run them. */
+export async function skillFromFolder(files: File[]): Promise<Skill> {
+  const queue = files.slice(0, MAX_FILES)
+  const read: FolderFile[] = []
+  let total = 0
+  for (const file of queue) {
+    const path = file.webkitRelativePath || file.name
+    if (file.size > MAX_FILE || !TEXT_FILE.test(path)) continue
+    if (total + file.size > MAX_TOTAL) break
+    const text = await file.text()
+    total += text.length
+    read.push({ path, text })
+  }
+  if (read.length === 0) throw new Error('That folder has no readable text files.')
+  const skillPath = pickSkillPath(read)
+  if (!skillPath) throw new Error('That folder has no SKILL.md.')
+  // Strip the folder the user picked so paths are relative to the skill root.
+  const rootMatch = /^(.*?)\//.exec(skillPath)
+  const root = rootMatch?.[1] ?? ''
+  const scoped = read
+    .filter((file) => !root || file.path === root || file.path.startsWith(`${root}/`))
+    .map((file) => ({ path: root ? file.path.slice(root.length + 1) : file.path, text: file.text }))
+  const manifest = scoped.find((file) => /^SKILL\.md$/i.test(file.path)) ?? scoped[0]
+  const parsed = parseSkillMarkdown(manifest.text, root.split('/').pop() || 'skill')
+  return {
+    id: `skill_${slug(parsed.name)}`,
+    name: parsed.name,
+    description: parsed.description,
+    instructions: parsed.instructions,
+    enabled: true,
+    source: 'folder',
+    files: Object.fromEntries(scoped.map((file) => [file.path, file.text])),
+  }
+}

package/src/lib/usage.ts

@@ -18,6 +18,7 @@ export interface UsageStats {
   sessions: number
   messages: number
   tokens: number
+  credits: number
   activeDays: number
   peakHour: string
   favoriteModel: string
@@ -81,6 +82,7 @@ export function computeUsage(sessions: ChatSession[], range: UsageRange, now = D
   const days = new Map<string, HeatmapDay>()
   const models = new Map<string, ModelUsage>()
   let tokens = 0
+  let credits = 0
 
   for (const { message, session } of messages) {
     const at = messageTime(message, session.updatedAt)
@@ -93,6 +95,9 @@ export function computeUsage(sessions: ChatSession[], range: UsageRange, now = D
     if (message.role !== 'assistant') continue
     const messageTokens = estimateTokens(message)
     tokens += messageTokens
+    if (typeof message.usage?.cost === 'number' && Number.isFinite(message.usage.cost)) {
+      credits += Math.max(0, message.usage.cost)
+    }
     const model = typeof message.model === 'string' ? message.model.trim() : ''
     if (!model) continue
     const entry = models.get(model) ?? { model, messages: 0, tokens: 0 }
@@ -119,6 +124,7 @@ export function computeUsage(sessions: ChatSession[], range: UsageRange, now = D
     sessions: filteredSessions.length,
     messages: messages.length,
     tokens,
+    credits,
     activeDays: days.size,
     peakHour: messages.length ? hourLabel(peak) : '—',
     favoriteModel: favorite?.model ?? '—',
@@ -148,6 +154,12 @@ export function formatTokens(value: number): string {
   return String(value)
 }
 
+export function formatCredits(value: number): string {
+  if (!value) return '—'
+  if (value < 0.01) return `$${value.toFixed(4)}`
+  return `$${value.toFixed(2)}`
+}
+
 export function shortModelName(model: string): string {
   if (!model || model === '—') return model
   const parts = model.split('/')

package/src/store/chats.ts

@@ -48,6 +48,7 @@ function normalizeSession(session: ChatSession): ChatSession {
     updatedAt: typeof session.updatedAt === 'number' ? session.updatedAt : Date.now(),
     mode: session.mode === 'plan' ? 'plan' : session.mode === 'build' ? 'build' : undefined,
     workspace: typeof session.workspace === 'string' ? session.workspace : undefined,
+    systemPrompt: typeof session.systemPrompt === 'string' ? session.systemPrompt : undefined,
     titleSource:
       session.titleSource === 'ai' || session.titleSource === 'user' || session.titleSource === 'auto'
         ? session.titleSource

package/src/store/settings.ts

@@ -13,7 +13,6 @@ import type {
   BuiltinToolName,
   ToolSetting,
 } from '../types'
-import { BUILTIN_SKILLS } from '../data/skills'
 import { PROVIDER_MAP } from '../data/providers'
 import {
   patchSettings,
@@ -59,6 +58,7 @@ const DEFAULT_TOOLS: Record<BuiltinToolName, ToolSetting> = {
   read_url: { enabled: true, approval: 'auto' },
   git: { enabled: true, approval: 'ask' },
   subagent: { enabled: true, approval: 'ask' },
+  skill: { enabled: true, approval: 'ask' },
 }
 
 const DEFAULTS: AppSettings = {
@@ -69,10 +69,11 @@ const DEFAULTS: AppSettings = {
   temperature: 0.4,
   maxTokens: 8192,
   systemPrompt: DEFAULT_SYSTEM_PROMPT,
+  workspacePrompts: {},
   providers: {},
   searchProvider: 'duckduckgo',
   tools: DEFAULT_TOOLS,
-  skills: BUILTIN_SKILLS,
+  skills: [],
   theme: 'system',
   showTokenEstimate: true,
   mode: 'build',
@@ -122,13 +123,15 @@ function mergeTools(saved?: Partial<Record<BuiltinToolName, Partial<ToolSetting>
 }
 
 function mergeSkills(saved?: Skill[]) {
-  const byId = new Map<string, Skill>()
-  for (const skill of BUILTIN_SKILLS) byId.set(skill.id, skill)
-  for (const skill of saved ?? []) {
-    if (!skill || typeof skill.id !== 'string') continue
-    byId.set(skill.id, { ...(byId.get(skill.id) ?? {}), ...skill, builtIn: skill.builtIn ?? byId.has(skill.id) })
-  }
-  return [...byId.values()]
+  // Built-in skills were removed; drop any leftovers persisted by older versions.
+  return (saved ?? [])
+    .filter((skill): skill is Skill => Boolean(skill) && typeof skill.id === 'string' && typeof skill.name === 'string' && !skill.builtIn)
+    .map((skill) => ({
+      ...skill,
+      description: typeof skill.description === 'string' ? skill.description : '',
+      instructions: typeof skill.instructions === 'string' ? skill.instructions : '',
+      enabled: skill.enabled !== false,
+    }))
 }
 
 function upgradePrompt(value: unknown) {
@@ -178,6 +181,14 @@ function buildSettings(persisted?: Partial<AppSettings>): AppSettings {
         ? Math.max(256, Math.min(200_000, Math.round(saved.maxTokens)))
         : DEFAULTS.maxTokens,
     systemPrompt: upgradePrompt(saved.systemPrompt),
+    workspacePrompts:
+      saved.workspacePrompts && typeof saved.workspacePrompts === 'object'
+        ? Object.fromEntries(
+            Object.entries(saved.workspacePrompts).filter(
+              ([key, value]) => key.startsWith('/') && typeof value === 'string',
+            ),
+          )
+        : {},
     providers: sanitizeBaseUrls(saved.providers),
     searchProvider:
       saved.searchProvider && ['duckduckgo', 'tavily', 'brave', 'serper'].includes(saved.searchProvider)
@@ -211,6 +222,7 @@ function persistedPatch(patch: Partial<AppSettings>): Partial<AppSettings> {
     'temperature',
     'maxTokens',
     'systemPrompt',
+    'workspacePrompts',
     'providers',
     'searchProvider',
     'tools',