@swarmclawai/swarmclaw 1.2.4 → 1.2.5

package/src/lib/server/session-tools/subagent.ts

@@ -5,7 +5,13 @@ import type { Extension, ExtensionHooks } from '@/types'
 import { registerNativeCapability } from '../native-capabilities'
 import { normalizeToolInputArgs } from './normalize-tool-args'
 import { errorMessage, sleep } from '@/lib/shared-utils'
-import { loadAgents } from '@/lib/server/storage'
+import { loadAgents } from '@/lib/server/agents/agent-repository'
+import { classifyMessage } from '@/lib/server/chat-execution/message-classifier'
+import {
+  buildDelegationTaskProfile,
+  resolveBestDelegateTarget,
+  type DelegationWorkType,
+} from '@/lib/server/agents/delegation-advisory'
 import {
   cancelDelegationJob,
   getDelegationJob,
@@ -57,6 +63,9 @@ const subagentToolSchema = z.object({
   action: z.enum(SUBAGENT_ACTIONS).optional(),
   agentId: z.string().optional(),
   message: z.string().optional(),
+  selectionMode: z.enum(['explicit', 'best_fit']).optional(),
+  workType: z.enum(['coding', 'research', 'writing', 'review', 'operations', 'general']).optional(),
+  requiredCapabilities: z.union([z.array(z.string()), z.string()]).optional(),
   cwd: z.string().optional(),
   shareBrowserProfile: z.boolean().optional(),
   jobId: z.string().optional(),
@@ -88,6 +97,7 @@ export function resolveSubagentBrowserProfileId(
 // ---------------------------------------------------------------------------
 
 interface ActionContext {
+  agentId?: string
   sessionId?: string
   cwd: string
   delegationTargetMode?: 'all' | 'selected'
@@ -155,10 +165,74 @@ export function coerceSubagentActionArgs(rawArgs: Record<string, unknown>): Reco
 
   const parsedJobIds = parseJsonLike(coerced.jobIds)
   if (Array.isArray(parsedJobIds)) coerced.jobIds = parsedJobIds
+  const parsedRequiredCapabilities = parseJsonLike(coerced.requiredCapabilities)
+  if (Array.isArray(parsedRequiredCapabilities)) coerced.requiredCapabilities = parsedRequiredCapabilities
 
   return coerced
 }
 
+function normalizeWorkType(value: unknown): DelegationWorkType | null {
+  if (
+    value === 'coding'
+    || value === 'research'
+    || value === 'writing'
+    || value === 'review'
+    || value === 'operations'
+    || value === 'general'
+  ) {
+    return value
+  }
+  return null
+}
+
+function normalizeStringList(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const entry of value) {
+    const trimmed = typeof entry === 'string' ? entry.trim() : ''
+    if (!trimmed || seen.has(trimmed.toLowerCase())) continue
+    seen.add(trimmed.toLowerCase())
+    out.push(trimmed)
+  }
+  return out
+}
+
+async function resolveBestFitAgentSelection(
+  args: Record<string, unknown>,
+  ctx: ActionContext,
+): Promise<{ agentId: string; workType: DelegationWorkType; requiredCapabilities: string[] } | null> {
+  const message = typeof args.message === 'string' ? args.message.trim() : ''
+  if (!message) return null
+  const explicitWorkType = normalizeWorkType(args.workType)
+  const explicitCapabilities = normalizeStringList(args.requiredCapabilities)
+  const classification = (!explicitWorkType && explicitCapabilities.length === 0 && ctx.sessionId)
+    ? await classifyMessage({
+        sessionId: ctx.sessionId,
+        agentId: ctx.agentId || null,
+        message,
+      }).catch(() => null)
+    : null
+  const profile = buildDelegationTaskProfile({
+    classification,
+    workType: explicitWorkType,
+    requiredCapabilities: explicitCapabilities,
+  })
+  const selection = resolveBestDelegateTarget({
+    currentAgentId: ctx.agentId || null,
+    agents: loadAgents(),
+    profile,
+    delegationTargetMode: ctx.delegationTargetMode,
+    delegationTargetAgentIds: ctx.delegationTargetAgentIds,
+  })
+  if (!selection) return null
+  return {
+    agentId: selection.agentId,
+    workType: profile.workType,
+    requiredCapabilities: profile.requiredCapabilities,
+  }
+}
+
 function requireString(args: Record<string, unknown>, key: string): string {
   const val = typeof args[key] === 'string' ? (args[key] as string).trim() : ''
   if (!val) throw new Error(`${key} is required.`)
@@ -373,10 +447,21 @@ function handleSwarmCancel(args: Record<string, unknown>): string {
 }
 
 async function handleStart(args: Record<string, unknown>, ctx: ActionContext): Promise<string> {
-  const agentId = (args.agentId ?? args.agent_id) as string | undefined
+  const selectionMode = args.selectionMode === 'best_fit' ? 'best_fit' : 'explicit'
+  let agentId = (args.agentId ?? args.agent_id) as string | undefined
   const message = args.message as string | undefined
-  if (!agentId) return 'Error: agentId is required.'
   if (!message) return 'Error: message is required.'
+  let selectedProfile: { workType: DelegationWorkType; requiredCapabilities: string[] } | null = null
+  if (selectionMode === 'best_fit') {
+    const resolved = await resolveBestFitAgentSelection(args, ctx)
+    if (!resolved) return 'Error: no eligible delegate agent available for best_fit selection.'
+    agentId = resolved.agentId
+    selectedProfile = {
+      workType: resolved.workType,
+      requiredCapabilities: resolved.requiredCapabilities,
+    }
+  }
+  if (!agentId) return 'Error: agentId is required.'
   const targetError = validateAllowedSubagentTarget(agentId, ctx)
   if (targetError) return targetError
 
@@ -393,10 +478,13 @@ async function handleStart(args: Record<string, unknown>, ctx: ActionContext): P
     return JSON.stringify({
       jobId: handle.jobId,
       status: 'running',
+      selectionMode,
       agentId: handle.agentId,
       agentName: handle.agentName,
       sessionId: handle.sessionId,
       lineageId: handle.lineageId,
+      workType: selectedProfile?.workType || null,
+      requiredCapabilities: selectedProfile?.requiredCapabilities || [],
     })
   }
 
@@ -404,6 +492,7 @@ async function handleStart(args: Record<string, unknown>, ctx: ActionContext): P
   return JSON.stringify({
     jobId: result.jobId,
     status: result.status,
+    selectionMode,
     agentId: result.agentId,
     agentName: result.agentName,
     sessionId: result.sessionId,
@@ -412,6 +501,8 @@ async function handleStart(args: Record<string, unknown>, ctx: ActionContext): P
     depth: result.depth,
     childCount: result.childCount,
     durationMs: result.durationMs,
+    workType: selectedProfile?.workType || null,
+    requiredCapabilities: selectedProfile?.requiredCapabilities || [],
   })
 }
 
@@ -463,13 +554,13 @@ const SubagentExtension: Extension = {
   description: 'Delegate tasks to other specialized agents with resumable job handles.',
   hooks: {
     getCapabilityDescription: () =>
-      'Delegate tasks to other agents (spawn_subagent). Single task: action "start". '
+      'Delegate tasks to other agents (spawn_subagent). Single task: action "start" with `agentId`, or use `selectionMode:"best_fit"` with `message` plus optional `workType`/`requiredCapabilities`. '
       + 'Multiple independent tasks: action "batch" with a tasks array. '
       + 'Event-driven parallel with status tracking: action "swarm" with a tasks array. '
       + 'Background swarms return a swarmId you can pass to swarm_status, swarm_list, and swarm_cancel.',
     getOperatingGuidance: () => [
       'SUBAGENT DISPATCH RULES:',
-      '- Single task → action "start" with agentId + message.',
+      '- Single task → action "start" with `agentId` + `message`, or `selectionMode:"best_fit"` with `message` and optional `workType` / `requiredCapabilities`.',
       '- 2+ independent tasks → action "batch" with tasks array [{agentId, message}, ...]. Use `executionMode:"serial"` when local models are rate-limited.',
       '- Background coordination example → `{"action":"swarm","tasks":[...],"background":true}` and then read the returned `swarmId` before calling `swarm_status` or `swarm_cancel`.',
       '- If your final answer depends on all delegated results, set `waitForCompletion:true` and do not summarize early.',
@@ -483,8 +574,9 @@ const SubagentExtension: Extension = {
     {
       name: 'spawn_subagent',
       description: 'Delegate tasks to other agents. '
-            + 'Actions: start (single agent), batch (2+ tasks via "tasks" array), swarm (multi-agent execution with status tracking via "tasks" array). '
+            + 'Actions: start (single agent, either explicit `agentId` or `selectionMode:"best_fit"`), batch (2+ tasks via "tasks" array), swarm (multi-agent execution with status tracking via "tasks" array). '
             + 'Management: status, list, wait, wait_all, cancel, lineage, aggregate, swarm_status, swarm_list, swarm_cancel. '
+            + 'In `best_fit` mode, provide `message` and optionally `workType` / `requiredCapabilities`; the runtime will choose the best allowed teammate and return the chosen agent in the tool output. '
             + 'For multiple independent tasks, prefer one `batch` or `swarm` call with tasks:[{agentId,message},...] over calling `start` repeatedly. '
             + 'When the final answer depends on every delegated result, keep waitForCompletion enabled so you can synthesize after all children finish. '
             + 'Use executionMode:"serial" to avoid rate limits on local models. '
@@ -495,6 +587,21 @@ const SubagentExtension: Extension = {
           action: { type: 'string', enum: ['start', 'status', 'list', 'wait', 'wait_all', 'cancel', 'lineage', 'batch', 'aggregate', 'swarm', 'swarm_status', 'swarm_list', 'swarm_cancel'] },
           agentId: { type: 'string' },
           message: { type: 'string' },
+          selectionMode: {
+            type: 'string',
+            enum: ['explicit', 'best_fit'],
+            description: 'Use "explicit" to target `agentId` directly, or "best_fit" to let the runtime choose the best allowed delegate.',
+          },
+          workType: {
+            type: 'string',
+            enum: ['coding', 'research', 'writing', 'review', 'operations', 'general'],
+            description: 'Optional hint for `best_fit` selection.',
+          },
+          requiredCapabilities: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Optional explicit capability requirements for `best_fit` selection.',
+          },
           cwd: { type: 'string' },
           shareBrowserProfile: {
             type: 'boolean',
@@ -532,7 +639,17 @@ const SubagentExtension: Extension = {
         },
         required: []
       },
-      execute: async (args, context) => executeSubagentAction(args, { sessionId: context.session.id, cwd: context.session.cwd || process.cwd() })
+      execute: async (args, context) => {
+        const sessionAgentId = context.session.agentId || undefined
+        const sessionAgent = sessionAgentId ? loadAgents()[sessionAgentId] : null
+        return executeSubagentAction(args, {
+          agentId: sessionAgentId,
+          sessionId: context.session.id,
+          cwd: context.session.cwd || process.cwd(),
+          delegationTargetMode: sessionAgent?.delegationTargetMode,
+          delegationTargetAgentIds: sessionAgent?.delegationTargetAgentIds,
+        })
+      }
     }
   ]
 }
@@ -562,6 +679,7 @@ export function buildSubagentTools(bctx: ToolBuildContext): StructuredToolInterf
   return [
     tool(
       async (args) => executeSubagentAction(args, {
+        agentId: bctx.ctx?.agentId || undefined,
         sessionId: bctx.ctx?.sessionId || undefined,
         cwd: bctx.cwd,
         delegationTargetMode: bctx.ctx?.delegationTargetMode,

package/src/lib/server/session-tools/team-context.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import { loadAgents, loadTasks, loadSessions } from '../storage'
+import { getRecentMessages } from '@/lib/server/messages/message-repository'
 import { resolveTeam, resolveReachableAgentIds } from '../agents/team-resolution'
 import { getAgentDirectory } from '../agents/agent-registry'
 import { normalizeToolInputArgs } from './normalize-tool-args'
@@ -139,12 +140,12 @@ async function formatPeerContext(agentId: string, peerId: string): Promise<strin
   try {
     const sessions = allSessions || loadSessions()
     const peerSessions = Object.values(sessions)
-      .filter((s) => s.agentId === peerId && Array.isArray(s.messages) && s.messages.length > 0)
+      .filter((s) => s.agentId === peerId && (s.messageCount ?? 0) > 0)
       .sort((a, b) => (b.lastActiveAt || 0) - (a.lastActiveAt || 0))
 
     const latestSession = peerSessions.length > 0 ? peerSessions[0] : null
-    if (latestSession?.messages) {
-      const recentMessages = latestSession.messages
+    if (latestSession) {
+      const recentMessages = getRecentMessages(latestSession.id, 20)
         .filter((m) => m.role === 'assistant' && Array.isArray(m.toolEvents) && m.toolEvents.length > 0)
         .slice(-MAX_RECENT_ACTIVITY)
       result.recentActivity = recentMessages.map((m) => {

package/src/lib/server/session-tools/wallet.ts

@@ -1181,64 +1181,6 @@ const WalletExtension: Extension = {
           'If quote or assembly APIs keep failing, stop venue-shopping and use `wallet_tool` action `call_contract` for direct read-only onchain state or quote reads.',
           'Treat `wallet_tool` as a server-side wallet capability. It does not inject a browser wallet extension or complete third-party wallet-connect prompts for you.',
         ],
-        requestMatchers: [
-          {
-            capability: TOOL_CAPABILITY.walletInspect,
-            patterns: [
-              'wallet',
-              'balance',
-              'address',
-              'fund',
-              'transfer',
-              'send',
-              'deposit',
-              'withdraw',
-              'swap',
-              'bridge',
-              'onchain',
-              'token',
-              'gas',
-              'usdc',
-              'eth',
-              'sol',
-              'solana',
-              'ethereum',
-              'arbitrum',
-              'base',
-              'wallet connect',
-              'walletconnect',
-              'dex',
-              'erc-20',
-              'spl',
-              'trade on',
-              'quote swap',
-            ],
-          },
-          {
-            capability: TOOL_CAPABILITY.walletExecute,
-            patterns: [
-              'swap',
-              'trade',
-              'buy token',
-              'sell token',
-              'sign message',
-              'sign typed data',
-              'signature',
-              'typed data',
-              'eip-712',
-              'sign transaction',
-              'send transaction',
-              'simulate transaction',
-              'broadcast transaction',
-          'contract call',
-          'call contract',
-          'read contract',
-              'calldata',
-              'approve token',
-              'raw transaction',
-            ],
-          },
-        ],
       },
       parameters: {
         type: 'object',

package/src/lib/server/sessions/session-lineage.ts

@@ -0,0 +1,55 @@
+import type { Session } from '@/types'
+import { loadSession } from '@/lib/server/sessions/session-repository'
+
+export interface SessionLineageIds {
+  parentSessionId: string | null
+  rootSessionId: string | null
+}
+
+export function resolveSessionLineageIds(
+  session: Pick<Session, 'id' | 'parentSessionId'> | null | undefined,
+  opts?: {
+    loadSessionById?: (id: string) => Session | null
+    maxDepth?: number
+  },
+): SessionLineageIds {
+  const parentSessionId = typeof session?.parentSessionId === 'string' && session.parentSessionId.trim()
+    ? session.parentSessionId.trim()
+    : null
+  const currentSessionId = typeof session?.id === 'string' && session.id.trim()
+    ? session.id.trim()
+    : null
+
+  if (!currentSessionId) {
+    return {
+      parentSessionId,
+      rootSessionId: parentSessionId,
+    }
+  }
+
+  const loadSessionById = opts?.loadSessionById || loadSession
+  const maxDepth = typeof opts?.maxDepth === 'number' && opts.maxDepth > 0 ? opts.maxDepth : 25
+  const seen = new Set<string>([currentSessionId])
+
+  let rootSessionId = currentSessionId
+  let cursor = parentSessionId
+  let depth = 0
+
+  while (cursor && depth < maxDepth) {
+    if (seen.has(cursor)) break
+    seen.add(cursor)
+    rootSessionId = cursor
+    const parent = loadSessionById(cursor)
+    const nextParentId = typeof parent?.parentSessionId === 'string' && parent.parentSessionId.trim()
+      ? parent.parentSessionId.trim()
+      : null
+    if (!nextParentId) break
+    cursor = nextParentId
+    depth += 1
+  }
+
+  return {
+    parentSessionId,
+    rootSessionId,
+  }
+}

package/src/lib/server/sessions/session-repository.ts

@@ -3,7 +3,6 @@ import type { Message, Session } from '@/types'
 import {
   deleteSession as deleteStoredSession,
   disableAllSessionHeartbeats as disableAllStoredSessionHeartbeats,
-  getSessionMessages as getStoredSessionMessages,
   loadSession as loadStoredSession,
   loadSessions as loadStoredSessions,
   patchSession as patchStoredSession,
@@ -11,6 +10,7 @@ import {
   upsertSession as upsertStoredSession,
 } from '@/lib/server/storage'
 import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+import { getMessages } from '@/lib/server/messages/message-repository'
 
 export const sessionRepository = createRecordRepository<Session>(
   'sessions',
@@ -72,7 +72,7 @@ export function deleteSession(id: string): void {
 }
 
 export function getSessionMessages(sessionId: string): Message[] {
-  return getStoredSessionMessages(sessionId)
+  return getMessages(sessionId)
 }
 
 export function disableAllSessionHeartbeats(): number {

package/src/lib/server/skills/learned-skills.ts

@@ -15,13 +15,15 @@ import type {
 import { errorMessage } from '@/lib/shared-utils'
 import { buildLLM } from '@/lib/server/build-llm'
 import {
+  loadLearnedSkill,
   loadLearnedSkills,
-  loadRunReflections,
-  loadSessions,
+  loadRunReflection,
   loadSkills,
-  saveRunReflections,
+  upsertRunReflection,
   upsertLearnedSkill,
-} from '@/lib/server/storage'
+} from '@/lib/server/skills/skill-repository'
+import { loadSession } from '@/lib/server/sessions/session-repository'
+import { getMessages, getMessageCount } from '@/lib/server/messages/message-repository'
 import { buildSessionTranscript } from './skill-suggestions'
 import { normalizeSkillPayload } from './skills-normalize'
 import { onNextIdleWindow } from '@/lib/server/runtime/idle-window'
@@ -169,7 +171,7 @@ function ensureHeading(name: string, content: string): string {
 }
 
 function collectRecentUserText(session: Session): string {
-  return session.messages
+  return getMessages(session.id)
     .filter((message) => message?.role === 'user' && !message.suppressed && typeof message.text === 'string')
     .slice(-3)
     .map((message) => message.text)
@@ -263,7 +265,7 @@ function buildFailureSourceHash(input: {
 
 function buildObservation(input: ObserveLearnedSkillRunInput, session: Session): Observation | null {
   if (input.status === 'cancelled' || input.status === 'queued' || input.status === 'running') return null
-  if (!Array.isArray(session.messages) || session.messages.length < 2) return null
+  if (getMessageCount(session.id) < 2) return null
 
   const toolEvents = Array.isArray(input.toolEvents) ? input.toolEvents : []
   const sourceSnippet = trimText(buildSessionTranscript(session), 700)
@@ -307,7 +309,7 @@ function buildDraftPrompt(params: {
   reflection: RunReflection | null
   existingSkillNames: string[]
 }): string {
-  const toolSummary = params.session.messages
+  const toolSummary = getMessages(params.session.id)
     .flatMap((message) => message?.toolEvents || [])
     .slice(-8)
     .map((event) => `- ${event.name} (${event.error ? 'error' : 'ok'})`)
@@ -455,20 +457,20 @@ function appendReflectionLearnedSkillNotes(params: {
   skillIds: string[]
 }): void {
   if (!params.reflection || (params.notes.length === 0 && params.skillIds.length === 0)) return
-  const reflections = loadRunReflections()
-  const current = reflections[params.reflection.id]
+  const current = loadRunReflection(params.reflection.id)
   if (!current) return
-  current.learnedSkillNotes = Array.from(new Set([
-    ...(current.learnedSkillNotes || []),
-    ...params.notes,
-  ]))
-  current.learnedSkillIds = Array.from(new Set([
-    ...(current.learnedSkillIds || []),
-    ...params.skillIds,
-  ]))
-  current.updatedAt = Date.now()
-  reflections[current.id] = current
-  saveRunReflections(reflections)
+  upsertRunReflection(current.id, {
+    ...current,
+    learnedSkillNotes: Array.from(new Set([
+      ...(current.learnedSkillNotes || []),
+      ...params.notes,
+    ])),
+    learnedSkillIds: Array.from(new Set([
+      ...(current.learnedSkillIds || []),
+      ...params.skillIds,
+    ])),
+    updatedAt: Date.now(),
+  })
 }
 
 function matchesSelectedLearnedSkill(session: Session, skill: LearnedSkill): boolean {
@@ -599,8 +601,7 @@ export async function observeLearnedSkillRunOutcome(
 ): Promise<{ notes: string[]; skillIds: string[] }> {
   const agentId = typeof input.agentId === 'string' ? input.agentId.trim() : ''
   if (!agentId) return { notes: [], skillIds: [] }
-  const sessions = loadSessions()
-  const session = sessions[input.sessionId] as Session | undefined
+  const session = loadSession(input.sessionId)
   if (!session) return { notes: [], skillIds: [] }
 
   const observation = buildObservation(input, session)
@@ -732,7 +733,7 @@ export async function observeLearnedSkillRunOutcome(
 
   if (validation.status === 'passed') {
     const parent = target.parentSkillId
-      ? loadLearnedSkills()[target.parentSkillId] || null
+      ? loadLearnedSkill(target.parentSkillId)
       : null
     if (parent && parent.lifecycle === 'active') {
       target.lifecycle = 'review_ready'

package/src/lib/server/skills/runtime-skill-resolver.ts

@@ -11,8 +11,9 @@ import type {
 } from '@/types'
 import { dedup, hmrSingleton } from '@/lib/shared-utils'
 import { expandExtensionIds, getExtensionAliases, normalizeExtensionId } from '@/lib/server/tool-aliases'
-import { loadLearnedSkills, loadSettings, loadSkills } from '@/lib/server/storage'
 import { cosineSimilarity, getEmbedding } from '@/lib/server/embeddings'
+import { loadSettings } from '@/lib/server/settings/settings-repository'
+import { loadLearnedSkills, loadSkills } from '@/lib/server/skills/skill-repository'
 import { discoverSkills, type DiscoveredSkill } from './skill-discovery'
 import { evaluateSkillEligibility } from './skill-eligibility'
 import {

package/src/lib/server/skills/skill-repository.ts

@@ -1,14 +1,137 @@
-export {
-  deleteLearnedSkill,
-  deleteSkill,
-  loadLearnedSkill,
-  loadLearnedSkills,
-  loadSkillSuggestions,
-  loadSkills,
-  patchLearnedSkill,
-  patchSkillSuggestion,
-  saveLearnedSkills,
-  saveSkills,
-  upsertLearnedSkill,
-  upsertSkillSuggestion,
+import type { LearnedSkill, RunReflection, Skill, SkillSuggestion } from '@/types'
+
+import {
+  deleteLearnedSkill as deleteStoredLearnedSkill,
+  deleteSkill as deleteStoredSkill,
+  deleteSkillSuggestion as deleteStoredSkillSuggestion,
+  loadLearnedSkill as loadStoredLearnedSkill,
+  loadLearnedSkills as loadStoredLearnedSkills,
+  loadRunReflection as loadStoredRunReflection,
+  loadRunReflections as loadStoredRunReflections,
+  loadSkillSuggestion as loadStoredSkillSuggestion,
+  loadSkillSuggestions as loadStoredSkillSuggestions,
+  loadSkills as loadStoredSkills,
+  patchLearnedSkill as patchStoredLearnedSkill,
+  patchSkillSuggestion as patchStoredSkillSuggestion,
+  saveLearnedSkills as saveStoredLearnedSkills,
+  saveRunReflections as saveStoredRunReflections,
+  saveSkillSuggestions as saveStoredSkillSuggestions,
+  saveSkills as saveStoredSkills,
+  upsertLearnedSkill as upsertStoredLearnedSkill,
+  upsertRunReflection as upsertStoredRunReflection,
+  upsertSkillSuggestion as upsertStoredSkillSuggestion,
+  upsertStoredItem,
 } from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const skillRepository = createRecordRepository<Skill>(
+  'skills',
+  {
+    get(id) {
+      return (loadStoredSkills() as Record<string, Skill>)[id] || null
+    },
+    list() {
+      return loadStoredSkills() as Record<string, Skill>
+    },
+    upsert(id, value) {
+      upsertStoredItem('skills', id, value)
+    },
+    replace(data) {
+      saveStoredSkills(data as Record<string, Skill>)
+    },
+    delete(id) {
+      deleteStoredSkill(id)
+    },
+  },
+)
+
+export const learnedSkillRepository = createRecordRepository<LearnedSkill>(
+  'learned-skills',
+  {
+    get(id) {
+      return loadStoredLearnedSkill(id) as LearnedSkill | null
+    },
+    list() {
+      return loadStoredLearnedSkills() as Record<string, LearnedSkill>
+    },
+    upsert(id, value) {
+      upsertStoredLearnedSkill(id, value as LearnedSkill)
+    },
+    replace(data) {
+      saveStoredLearnedSkills(data as Record<string, LearnedSkill>)
+    },
+    patch(id, updater) {
+      return patchStoredLearnedSkill(id, updater as (current: LearnedSkill | null) => LearnedSkill | null) as LearnedSkill | null
+    },
+    delete(id) {
+      deleteStoredLearnedSkill(id)
+    },
+  },
+)
+
+export const skillSuggestionRepository = createRecordRepository<SkillSuggestion>(
+  'skill-suggestions',
+  {
+    get(id) {
+      return loadStoredSkillSuggestion(id) as SkillSuggestion | null
+    },
+    list() {
+      return loadStoredSkillSuggestions() as Record<string, SkillSuggestion>
+    },
+    upsert(id, value) {
+      upsertStoredSkillSuggestion(id, value as SkillSuggestion)
+    },
+    replace(data) {
+      saveStoredSkillSuggestions(data as Record<string, SkillSuggestion>)
+    },
+    patch(id, updater) {
+      return patchStoredSkillSuggestion(id, updater as (current: SkillSuggestion | null) => SkillSuggestion | null) as SkillSuggestion | null
+    },
+    delete(id) {
+      deleteStoredSkillSuggestion(id)
+    },
+  },
+)
+
+export const runReflectionRepository = createRecordRepository<RunReflection>(
+  'run-reflections',
+  {
+    get(id) {
+      return loadStoredRunReflection(id) as RunReflection | null
+    },
+    list() {
+      return loadStoredRunReflections() as Record<string, RunReflection>
+    },
+    upsert(id, value) {
+      upsertStoredRunReflection(id, value as RunReflection)
+    },
+    replace(data) {
+      saveStoredRunReflections(data as Record<string, RunReflection>)
+    },
+  },
+)
+
+export const loadSkills = () => skillRepository.list()
+export const loadSkill = (id: string) => skillRepository.get(id)
+export const saveSkills = (items: Record<string, Skill | Record<string, unknown>>) => skillRepository.replace(items as Record<string, Skill>)
+export const saveSkill = (id: string, value: Skill | Record<string, unknown>) => skillRepository.upsert(id, value as Skill)
+export const deleteSkill = (id: string) => skillRepository.delete(id)
+
+export const loadLearnedSkills = () => learnedSkillRepository.list()
+export const loadLearnedSkill = (id: string) => learnedSkillRepository.get(id)
+export const saveLearnedSkills = (items: Record<string, LearnedSkill | Record<string, unknown>>) => learnedSkillRepository.replace(items as Record<string, LearnedSkill>)
+export const upsertLearnedSkill = (id: string, value: LearnedSkill | Record<string, unknown>) => learnedSkillRepository.upsert(id, value as LearnedSkill)
+export const patchLearnedSkill = (id: string, updater: (current: LearnedSkill | null) => LearnedSkill | null) => learnedSkillRepository.patch(id, updater)
+export const deleteLearnedSkill = (id: string) => learnedSkillRepository.delete(id)
+
+export const loadSkillSuggestions = () => skillSuggestionRepository.list()
+export const loadSkillSuggestion = (id: string) => skillSuggestionRepository.get(id)
+export const saveSkillSuggestions = (items: Record<string, SkillSuggestion | Record<string, unknown>>) => skillSuggestionRepository.replace(items as Record<string, SkillSuggestion>)
+export const upsertSkillSuggestion = (id: string, value: SkillSuggestion | Record<string, unknown>) => skillSuggestionRepository.upsert(id, value as SkillSuggestion)
+export const patchSkillSuggestion = (id: string, updater: (current: SkillSuggestion | null) => SkillSuggestion | null) => skillSuggestionRepository.patch(id, updater)
+export const deleteSkillSuggestion = (id: string) => skillSuggestionRepository.delete(id)
+
+export const loadRunReflections = () => runReflectionRepository.list()
+export const loadRunReflection = (id: string) => runReflectionRepository.get(id)
+export const saveRunReflections = (items: Record<string, RunReflection | Record<string, unknown>>) => runReflectionRepository.replace(items as Record<string, RunReflection>)
+export const upsertRunReflection = (id: string, value: RunReflection | Record<string, unknown>) => runReflectionRepository.upsert(id, value as RunReflection)