@muskanmeet/invoicing-design-system 0.1.0

package/.local/skills/expo/references/device_features_and_permissions.md

@@ -0,0 +1,48 @@
+# Permissions — use real device features
+
+General Flow:
+
+- Use permission hooks: Camera.useCameraPermissions(), Location.useForegroundPermissions(), etc.
+- If a feature requires permission, show a button to request it when not granted
+- Never use fake/mock data - always use real device capabilities
+- If user denies permission and canAskAgain is false, show Settings button (guard with Platform.OS !== "web" and wrap in try-catch)
+
+Single Permission Pattern:
+
+- Call permission hook: const [permission, requestPermission] = Camera.useCameraPermissions()
+- If !permission, show loading
+- If !permission.granted && permission.status === "denied" && !permission.canAskAgain, show "Open Settings" button
+- Otherwise show button to request permission
+- WRONG: Never check and return without giving user a way to request
+
+PermissionResponse: { status, granted, canAskAgain, expires }
+
+Per-Permission Guidelines:
+
+- Camera (expo-camera, expo-image-picker): Button to take photo or select from gallery
+- Location (expo-location): Use useForegroundPermissions hook. Accuracy levels: Lowest (3km), Low (1km), Balanced (100m), High (10m), Highest (best). Background location needs BOTH foreground AND background permissions
+- Notifications (expo-notifications): Button or toggle (starts OFF) to enable
+- Contacts (expo-contacts): Button to access. Provide alternative input if denied
+- Media Library (expo-media-library): Button to access photos, videos, or audio
+- Local Authentication (expo-local-authentication): Check hasHardwareAsync first. Provide PIN/password fallback
+- Maps (react-native-maps): Use expo-location to request permission first, then showsUserLocation prop
+
+Expo Go: Most permissions work. Background location and some advanced permissions need a development build.
+
+## File Uploads
+
+CRITICAL - Correct imports for file uploads:
+
+- `import { File } from 'expo-file-system'` - File class for creating uploadable files
+- `import { fetch } from 'expo/fetch'` - fetch function for uploading
+- NEVER import fetch from expo-file-system (it doesn't exist there)
+
+Usage: `const file = new File(uri); formData.append('file', file);`
+PDFs: Open in WebView (react-native-webview) - preferred for iOS and Expo Go
+
+## Library Compatibility
+
+- ONLY use libraries from the Expo Go compatible list
+- Do not install additional native libraries unless they're JS only
+- Pre-installed: expo-router, @expo/vector-icons, @tanstack/react-query, react-native-reanimated
+- Error boundary: Custom ErrorBoundary component (components/ErrorBoundary.tsx)

package/.local/skills/expo/references/first_build.md

@@ -0,0 +1,114 @@
+<first_build>
+When building a new Expo app for the first time, follow this sequence for speed and quality.
+
+**Scaffold** — these files are already opened in your context (do NOT re-read them). The scaffold also includes these components you won't see opened: `ErrorBoundary`, `ErrorFallback`, `KeyboardAwareScrollViewCompat`. Providers wired in `_layout.tsx`: SafeAreaProvider, ErrorBoundary, QueryClientProvider, GestureHandlerRootView, KeyboardProvider. Fonts: Inter (400/500/600/700) pre-loaded with SplashScreen gating. Packages pre-installed: expo-router, @expo/vector-icons, @tanstack/react-query, react-native-reanimated, react-native-keyboard-controller, react-native-gesture-handler, react-native-safe-area-context, expo-haptics.
+
+## Build Sequence
+
+1. **Generate images FIRST** — kick off ALL image generation via `generateImageAsync` (from the `media-generation` skill) in a single batch before writing any code. This includes:
+   - App icon & splash. Save to `assets/images/icon.png`.
+   - If the app is image-heavy (streaming, social, media, recipes, travel, etc.), also generate 2-3 content placeholder images for the initial UI (e.g., hero banners, category thumbnails, placeholder cards). Save to `assets/images/`. Do NOT over-generate — 2-3 images max for first build content.
+   Images generate in the background while you continue building.
+
+2. **Plan the full app structure** — decide on all screens, components, context providers, navigation, and colors BEFORE writing any code. You need this plan to write everything in one batch.
+
+3. **Write ALL files in a single parallel batch** — this is critical for speed. Every new file is independent. In ONE tool call, write:
+   - `constants/colors.ts` (updated theme)
+   - All component files (cards, inputs, headers, etc.)
+   - All context/provider files
+   - All screen files (`app/index.tsx`, `app/detail.tsx`, etc.)
+   Do NOT write files one at a time. Batch every new file into a single parallel write call.
+
+4. **Update existing scaffold files in a second parallel batch** — in ONE tool call, edit:
+   - `app/_layout.tsx` (add new providers, adjust Stack screens)
+   - `app/(tabs)/_layout.tsx` (add/remove tabs, or delete if not using tabs)
+   - `app.json` (update name if needed)
+
+5. **Install additional packages** if any are needed beyond what's pre-installed.
+
+6. **Restart workflow** once at the end — not before. After restarting, check logs (`refresh_all_logs`) to confirm the app is running without errors. Fix any errors before presenting.
+
+## First Build Rules
+
+- **Expo apps default to frontend-only.** Unless the user explicitly asks for a backend, database, or server-side features, do NOT provision a database, write an OpenAPI spec, run codegen, or create backend routes. Use AsyncStorage for all local persistence. This is the single most common mistake — avoid it.
+- Do NOT restart the workflow until all files are written.
+- Do NOT re-read scaffold files — their content is documented above.
+- Do NOT take screenshots while building — take exactly ONE at the very end after restarting the workflow to confirm the app is live (see Screenshot Rules below).
+- Every feature must be complete — no placeholder buttons or unfinished states.
+- Only use Expo Go compatible packages.
+- **Maximize parallel tool calls.** Writing 10 files sequentially is 10x slower than writing them in one batch. If files don't depend on each other, write them together.
+
+## Scope Guidance
+
+**Features to AVOID in the first build:**
+
+- Backend databases or servers (use AsyncStorage)
+- Complex integration with multiple third-party services
+- Push notifications
+
+**Features you CAN include:**
+
+- GenAI/External integrations (OpenAI, Anthropic, etc.)
+- Single integration use (RevenueCat, Firebase, etc.)
+- CRUD operations with AsyncStorage
+- Forms, navigation, routing
+- Native device capabilities (camera, location) when relevant
+
+## Design Quality
+
+Design quality is the top priority. Build a production-ready app with polished UI — no placeholder buttons or unfinished states. Draw inspiration from market-leading apps (Airbnb, Instagram, Notion, Apple Notes, ChatGPT Mobile).
+
+**Component standards** — every component must be complete with proper states:
+
+- Loading: Skeleton shimmer or activity indicator
+- Empty: Icon + text (no generated images, no emojis)
+- Error: Message + retry button
+- Buttons: Press feedback (opacity/scale), disabled state
+- Lists: Empty state, pull-to-refresh where appropriate
+- Forms: Validation feedback
+- Key actions: Haptic feedback via expo-haptics
+
+**Navigation structure:**
+The template comes with a tab bar and header, but most apps don't need them. Evaluate your app's needs:
+
+- Single-screen apps (chat, camera, simple tools): NO tabs, NO header. Delete `app/(tabs)/`, create `app/index.tsx`.
+- Multi-section apps (social, e-commerce): Tabs may be useful. Hide the header with `headerShown: false` in Tabs screenOptions.
+- Market-leading apps like Instagram, ChatGPT, WhatsApp have minimal chrome — no visible title bars.
+- Liquid glass tab bars (NativeTabs) are a major wow factor for iOS 26+ users.
+
+**Design principles:**
+
+- Draw inspiration from iOS, Instagram, Airbnb, Coinbase
+- Mobile-native design patterns, not web-like designs
+- Avoid generic aesthetics (purple gradients on white, predictable layouts)
+- Every screen should feel cohesive
+- Icons over text for buttons — use @expo/vector-icons, NEVER emojis
+- Choose a font that matches the app's personality (see Typography below)
+
+**Typography personality:**
+
+- Chat/AI apps: Inter, DM Sans, or Source Sans Pro for clean readability
+- Finance/Crypto: Inter, DM Sans, or Roboto for trust and clarity
+- Creative/Social: Poppins, Nunito, or Montserrat for friendliness
+- Fitness/Health: Rubik, Work Sans, or Outfit for energy
+- Notes/Productivity: Merriweather (serif) + Inter (sans) for hierarchy
+
+**Color choices** are very important. Be inspired by production-level applications:
+
+- Note Taking Apps: Notion, Apple Notes
+- AI Chatbots: ChatGPT Mobile App, Claude Mobile App
+- Social: Instagram, Twitter
+- Finance: Coinbase, Robinhood
+
+## Screenshot Rules
+
+**First build:** Take exactly ONE screenshot at the very end, after restarting the workflow, to confirm the app is live and not crashing. That is it. Do NOT screenshot repeatedly to iterate on UI or debug layout issues during the first build.
+
+**After first build (iterations):** Screenshots are allowed for verifying specific bug fixes or user-requested changes, but do NOT loop — if a screenshot shows a problem, fix the code and move on. Do NOT take another screenshot to verify the fix unless the user asks. Trust your code changes.
+
+**Web preview caveats:**
+
+- Safe area insets render differently on web vs native — content may appear clipped at top/bottom
+- The web preview runs in an iframe which affects safe area calculations
+- Do NOT debug layout issues visible only in web screenshots — these are web rendering artifacts, not real bugs. The native preview (Expo Go) is the source of truth.
+</first_build>

package/.local/skills/expo/references/react_context.md

@@ -0,0 +1,54 @@
+# React Context Docs
+
+React context usage for shared state:
+
+```tsx
+import { createContext, useContext, useState, useMemo, ReactNode } from 'react';
+import { useQuery } from '@tanstack/react-query';
+
+interface TodoContextValue {
+  todos: Todo[];
+  addTodo: (todo: Todo) => void;
+  isLoading: boolean;
+}
+
+const TodoContext = createContext<TodoContextValue | null>(null);
+
+export function TodoProvider({ children }: { children: ReactNode }) {
+  const [todos, setTodos] = useState<Todo[]>([]);
+  const todosQuery = useQuery({ queryKey: ['todos'] });
+
+  const addTodo = (todo: Todo) => {
+    setTodos(prev => [...prev, todo]);
+  };
+
+  const value = useMemo(() => ({
+    todos,
+    addTodo,
+    isLoading: todosQuery.isLoading,
+  }), [todos, todosQuery.isLoading]);
+
+  return (
+    <TodoContext.Provider value={value}>
+      {children}
+    </TodoContext.Provider>
+  );
+}
+
+export function useTodos() {
+  const context = useContext(TodoContext);
+  if (!context) {
+    throw new Error('useTodos must be used within a TodoProvider');
+  }
+  return context;
+}
+
+// Custom hooks can use the context hook
+export function useFilteredTodos(search: string) {
+  const { todos } = useTodos();
+  return useMemo(() => todos.filter(t => t.title.includes(search)), [todos, search]);
+}
+```
+
+- Don't wrap RootLayoutNav in context - wrap at root layout level
+- React Query provider should be top level, other providers nested inside

package/.local/skills/external_apis/.fingerprint

@@ -0,0 +1 @@
+c20ea4eda39d780d5287a39bea7a9a70

package/.local/skills/external_apis/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: external_apis
+description: "Access external APIs through Replit-managed billing"
+---
+
+# External APIs
+
+This skill provides access to external APIs through Replit-managed
+passthrough billing. Requests are proxied through OpenInt with
+managed credentials.
+
+## Recommended workflow
+
+1. Open the connector reference for request and response details.
+2. Call `externalApi__<connector_name>` from `code_execution`.
+3. Use `query` for URL parameters and parse `result.body`.
+4. For media URLs, save files under `attached_assets/` and present them.
+
+## Available APIs
+
+- [Brave](references/brave.md) - Search real web image results through Brave passthrough billing.
+- [ElevenLabs](references/elevenlabs.md)
+- [Exa](references/exa.md)
+- [Firecrawl](references/firecrawl.md)
+- [Nano Banana](references/nano_banana.md)

package/.local/skills/external_apis/references/brave.md

@@ -0,0 +1,116 @@
+# Brave
+
+Proxy requests to Brave via Replit-managed billing.
+
+## Callback
+
+Use `externalApi__brave` in `code_execution`.
+
+## Allowed operations
+
+- `GET` `/res/v1/images/search/*?` - Brave Image Search
+
+Authorization is handled automatically by Replit. Do not pass an `Authorization` header.
+
+## Skill
+
+## Brave image search
+
+Search real web image results through Brave passthrough billing.
+
+### When to use
+
+- The user asks for real-world images from the web
+- You need image URLs to support analysis, reports, or artifacts
+
+---
+
+## Callback quickstart
+
+Use `externalApi__brave` with this allowed operation:
+
+- `GET /res/v1/images/search`
+
+Put URL params in `query`.
+
+```javascript
+const result = await externalApi__brave({
+  path: '/res/v1/images/search',
+  method: 'GET',
+  query: {q: 'vintage travel posters', count: '6'},
+})
+
+const items = result.body?.results ?? []
+for (const item of items) {
+  console.log(item.title, item.properties?.url)
+}
+```
+
+Common response paths:
+
+- Image URL: `body.results[i].properties.url`
+- Title: `body.results[i].title`
+
+Authorization is managed by passthrough billing. Do not set an
+`Authorization` header manually.
+
+---
+
+## Render Brave images in chat
+
+For chat panel rendering, use the `media-generation` skill flow:
+
+1. Select up to 4 relevant results
+2. Download each URL to `attached_assets/brave_images/`
+3. Call `presentAsset({awaitUserInput: false})` for each saved file
+
+```javascript
+const fs = await import('node:fs/promises')
+const path = await import('node:path')
+
+const result = await externalApi__brave({
+  path: '/res/v1/images/search',
+  method: 'GET',
+  query: {q: 'mid-century chair', count: '4'},
+})
+
+const items = (result.body?.results ?? []).slice(0, 4)
+await fs.mkdir('attached_assets/brave_images', {recursive: true})
+
+for (const [index, item] of items.entries()) {
+  const imageUrl = item.properties?.url
+  if (!imageUrl) continue
+
+  const response = await fetch(imageUrl)
+  if (!response.ok) continue
+
+  const filePath = path.join(
+    'attached_assets/brave_images',
+    'result_' + String(index + 1) + '.jpg',
+  )
+
+  await fs.writeFile(
+    filePath,
+    Buffer.from(await response.arrayBuffer()),
+  )
+
+  await presentAsset({
+    filePath,
+    title: item.title ?? 'Brave image',
+    awaitUserInput: false,
+  })
+}
+```
+
+## Example
+
+```javascript
+const result = await externalApi__brave({
+  path: '/res/v1/images/search/*?',
+  method: 'GET',
+  query: {},
+})
+
+console.log(result.status)
+console.log(result.body)
+```

package/.local/skills/external_apis/references/elevenlabs.md

@@ -0,0 +1,44 @@
+# ElevenLabs
+
+Proxy requests to ElevenLabs via Replit-managed billing.
+
+## Callback
+
+Use `externalApi__elevenlabs` in `code_execution`.
+
+## Allowed operations
+
+- `POST` `/v1/text-to-speech/:voice_id{/stream}?{/with-timestamps}?` - Text to Speech (non-streaming, streaming, with-timestamps, and stream/with-timestamps variants)
+- `POST` `/v1/text-to-dialogue{/stream}?{/with-timestamps}?` - Text to Dialogue (multi-voice; non-streaming, streaming, with-timestamps, and stream/with-timestamps variants)
+- `POST` `/v1/speech-to-text` - Speech to Text (Scribe v1/v2)
+- `POST` `/v1/speech-to-speech/:voice_id{/stream}?` - Voice Changer (speech-to-speech; non-streaming and streaming variants)
+- `POST` `/v1/sound-generation` - Sound Effects (text → sound generation)
+- `POST` `/v1/audio-isolation{/stream}?` - Voice Isolator (audio-isolation; non-streaming and streaming variants)
+- `POST` `/v1/forced-alignment` - Forced Alignment (audio + text → word/char timings)
+- `POST` `/v1/text-to-voice/:variant(design|create-previews)` - Voice Design (text → three voice previews; charged once on response.text characters). Covers `/design` and legacy `/create-previews`.
+- `POST` `/v1/text-to-voice/:voice_id/remix` - Voice Remix (remix existing voice → three previews; charged once on response.text characters). Shares billing mechanics with text_to_voice_design.
+- `POST` `/v1/dubbing` - Dubbing v1 — creates a dub job; bills on response expected_duration_sec × tier-per-sec (watermark vs clean)
+- `POST` `/v1/music{/:variant(detailed|stream)}?` - Music composition (non-streaming binary, multipart-detailed with JSON metadata, and event-stream variants)
+- `POST` `/v1/music/video-to-music` - Video to Music (multipart videos → generated music matching combined video length)
+- `POST` `/v1/music/stem-separation` - Music Stem Separation (split input audio into N stems; bills on multipart input file size ÷ nominal 128 kbps — see preamble for bitrate-assumption rationale)
+- `GET` | `POST` | `PUT` | `PATCH` | `DELETE` `/:path+` - Catch-all — no charge for paths not explicitly listed (CRUD, metadata, workspace/convai management).
+
+Authorization is handled automatically by Replit. Do not pass an `Authorization` header.
+
+## Quickstart
+
+1. Call the callback with a supported `path` and `method`.
+2. Put URL params in `query` and inspect `result.body`.
+
+## Example
+
+```javascript
+const result = await externalApi__elevenlabs({
+  path: '/v1/text-to-speech/:voice_id{/stream}?{/with-timestamps}?',
+  method: 'POST',
+  query: {},
+})
+
+console.log(result.status)
+console.log(result.body)
+```

package/.local/skills/external_apis/references/exa.md

@@ -0,0 +1,34 @@
+# Exa
+
+Proxy requests to Exa via Replit-managed billing.
+
+## Callback
+
+Use `externalApi__exa` in `code_execution`.
+
+## Allowed operations
+
+- `POST` `/search` - Web search (auto, neural, fast, deep, deep-reasoning).
+- `POST` `/contents` - Page contents retrieval (text, highlights, summary, subpages, livecrawl).
+- `POST` `/findSimilar` - Find similar links by URL similarity (optional contents pulldown).
+- `POST` `/answer` - Web-grounded answer (with optional SSE streaming).
+
+Authorization is handled automatically by Replit. Do not pass an `Authorization` header.
+
+## Quickstart
+
+1. Call the callback with a supported `path` and `method`.
+2. Put URL params in `query` and inspect `result.body`.
+
+## Example
+
+```javascript
+const result = await externalApi__exa({
+  path: '/search',
+  method: 'POST',
+  query: {},
+})
+
+console.log(result.status)
+console.log(result.body)
+```

package/.local/skills/external_apis/references/firecrawl.md

@@ -0,0 +1,37 @@
+# Firecrawl
+
+Proxy requests to Firecrawl via Replit-managed billing.
+
+## Callback
+
+Use `externalApi__firecrawl` in `code_execution`.
+
+## Allowed operations
+
+- `POST` `/scrape` - Scrape any URL and get its content in markdown, HTML, or other formats.
+- `POST` `/batch/scrape` - Scrape multiple URLs and get their content in markdown, HTML, or other formats.
+- `POST` `/map` - Discover all URLs on a website without scraping their content.
+- `POST` `/crawl` - Scrape an entire website by following links from a starting URL. The same per-page scrape option costs apply to each page crawled.
+- `POST` `/agent` - Autonomous web research agent. 5 daily runs free; usage-based pricing beyond that.
+- `POST` `/search` - Search the web and optionally scrape the results. Rounded up per 10 results (e.g., 11 results = 4 credits). Additional per-page scrape costs apply to each result that is scraped. Enterprise ZDR search costs 10 credits / 10 results.
+- `POST` | `GET` | `DELETE` `/*` - All other paths are no-charge.
+
+Authorization is handled automatically by Replit. Do not pass an `Authorization` header.
+
+## Quickstart
+
+1. Call the callback with a supported `path` and `method`.
+2. Put URL params in `query` and inspect `result.body`.
+
+## Example
+
+```javascript
+const result = await externalApi__firecrawl({
+  path: '/scrape',
+  method: 'POST',
+  query: {},
+})
+
+console.log(result.status)
+console.log(result.body)
+```

package/.local/skills/external_apis/references/nano_banana.md

@@ -0,0 +1,33 @@
+# Nano Banana
+
+Proxy requests to Nano Banana via Replit-managed billing.
+
+## Callback
+
+Use `externalApi__nano_banana` in `code_execution`.
+
+## Allowed operations
+
+- `POST` `/gemini-3.1-flash-image-preview:generateContent` - Generate image (Nano Banana 2 / Flash)
+- `POST` `/gemini-3-pro-image-preview:generateContent` - Generate image (Nano Banana Pro)
+- `POST` `/gemini-2.5-flash-image:generateContent` - Generate or edit image (Nano Banana v1)
+
+Authorization is handled automatically by Replit. Do not pass an `Authorization` header.
+
+## Quickstart
+
+1. Call the callback with a supported `path` and `method`.
+2. Put URL params in `query` and inspect `result.body`.
+
+## Example
+
+```javascript
+const result = await externalApi__nano_banana({
+  path: '/gemini-3.1-flash-image-preview:generateContent',
+  method: 'POST',
+  query: {},
+})
+
+console.log(result.status)
+console.log(result.body)
+```

package/.local/skills/follow-up-tasks/.fingerprint

@@ -0,0 +1 @@
+3a30de262964bb0b1105738cb22f36ac

package/.local/skills/follow-up-tasks/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: follow-up-tasks
+description: Propose follow-up tasks before marking your current task as complete.
+---
+
+# Follow-Up Tasks
+
+As you work on your current task, watch for additional work that should be done as follow-up tasks — separate units of work related to your current task but outside its scope.
+
+Categorize each follow-up task using one of these categories:
+
+- **`incomplete_scope`**: Parts of the original request that you intentionally deferred to keep the current task focused
+- **`next_steps`**: Functionality or features users would want next, whether directly extending what you just built or addressing unmet needs in the project
+- **`tech_debt`**: Code quality issues, hardcoded values, shortcuts, or refactoring opportunities you noticed while working
+- **`test_gaps`**: Tests that should be written but aren't part of the current task's deliverable
+
+Write titles for non-technical users — lead with impact, not implementation - especially for tech debt and test gaps.
+
+Before submitting, review each title by asking: "Would a non-technical user understand what this means and why they'd want it?" If not, rewrite it. Examples:
+
+- "Store recipes in a database with full CRUD support" -> "Let users add, edit, and delete their own recipes"
+- "Add server-side validation for recipe API endpoints" -> "Prevent broken recipes from being saved"
+
+Before marking your task as complete, propose up to 3 follow-up tasks by calling `proposeFollowUpTasks` — NOT `bulkCreateProjectTasks` or `createProjectTask`. The `proposeFollowUpTasks` callback automatically links follow-ups to your current task as the parent — required for correct task hierarchy. Submit them all in a single call with clear titles, descriptions, and a `category` (required). Keep only the highest-impact follow-ups. Each description should include relevant file paths and enough context for another agent to pick up the work independently.
+
+Only propose follow-ups that represent genuine, actionable work.
+
+- Do not propose follow-ups that overlap with tasks already visible in the project task list
+- Do not propose follow-ups for trivial items or things already in your current task's scope
+- Do not propose follow-ups for agent housekeeping (e.g. updating replit.md, adding comments, improving documentation — handle those inline)
+
+If your current task already has downstream tasks depending on it (listed in your task assignment), skip calling `proposeFollowUpTasks` entirely — those tasks already cover the planned next steps.
+
+`proposeFollowUpTasks` is **one-shot per assigned project task** — not per turn, not per subfeature, not per `mark_task_complete` cycle. The system rejects duplicate calls. If you're marking complete again after more work on the same assigned task, review your previously proposed follow-ups; if any are now stale, call `markFollowUpTaskObsolete` to retract them.
+
+## Examples
+
+```javascript
+// Log the result so you have taskRefs for later use with markFollowUpTaskObsolete
+const followUps = await proposeFollowUpTasks({
+    tasks: [
+        {
+            title: "Let users save favorite recipes to a personal collection",
+            category: "next_steps",
+            description: `# Let users save favorite recipes to a personal collection
+
+## What & Why
+Users currently can't keep track of recipes they like. A favorites collection is the natural next feature on top of the existing browsing flow — it gives the app stickiness and a reason to return.
+
+## Done looks like
+- Authenticated users can favorite / unfavorite a recipe from the list and detail pages
+- A "My favorites" page shows the user's collection
+- Favorites persist across sessions
+
+## Relevant files
+- \`src/pages/recipes/[id].tsx\`
+- \`src/components/RecipeCard.tsx\``
+        },
+        {
+            title: "Save recipes permanently so they aren't lost on refresh",
+            category: "tech_debt",
+            description: `# Save recipes permanently so they aren't lost on refresh
+
+## What & Why
+Recipe data is hardcoded in a static file. Users who add or edit recipes will lose their changes on page refresh. Moving data to the database ensures persistence.
+
+## Done looks like
+- Recipes are stored in the database and served via API
+- Users can add, edit, and delete recipes without losing data
+
+## Relevant files
+- \`src/data/recipes.ts\``
+        }
+    ]
+});
+console.log(followUps.map(t => ({ taskRef: t.taskRef, title: t.title })));
+
+// Remove an obsolete follow-up
+await markFollowUpTaskObsolete({ taskRef: "#12" });
+```

package/.local/skills/image-search/.fingerprint

@@ -0,0 +1 @@
+db9ce85b0a95e288311aa7629b87cd7b