create-claude-code-visualizer 0.1.0

package/templates/app/src/lib/typewriter-animation.ts

@@ -0,0 +1,159 @@
+/**
+ * Typewriter animation engine for text diffs.
+ * Drives a textarea through delete → insert transitions for each changed region.
+ */
+
+import { computeLineDiff, type DiffOp } from "./line-diff";
+
+interface AnimateOptions {
+  /** Ms per character batch during deletion (default 1) */
+  deleteSpeed?: number;
+  /** Ms per character batch during insertion (default 2) */
+  typeSpeed?: number;
+  /** Characters per animation frame (default 4) */
+  batchSize?: number;
+  /** AbortSignal to cancel the animation */
+  signal?: AbortSignal;
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((r) => requestAnimationFrame(() => setTimeout(r, ms)));
+}
+
+/**
+ * Animate the transition from oldText to newText in a textarea.
+ * Calls onContentChange on every frame so React state stays in sync.
+ * Returns the final text (always newText unless aborted).
+ */
+export async function animateDiff(
+  textarea: HTMLTextAreaElement | null,
+  oldText: string,
+  newText: string,
+  onContentChange: (text: string) => void,
+  options: AnimateOptions = {}
+): Promise<string> {
+  const {
+    deleteSpeed = 1,
+    typeSpeed = 2,
+    batchSize = 4,
+    signal,
+  } = options;
+
+  if (!textarea || oldText === newText) {
+    onContentChange(newText);
+    return newText;
+  }
+
+  const ops = computeLineDiff(oldText, newText);
+
+  // Flatten ops into an animation plan: list of { charOffset, action } sequences
+  // We'll work through the current text, applying ops one by one.
+  let currentText = oldText;
+  let cursor = 0; // character position in currentText
+
+  for (const op of ops) {
+    if (signal?.aborted) break;
+
+    if (op.type === "keep") {
+      // Advance cursor past these lines + the \n joining to next
+      cursor += op.text.length;
+      // Account for the \n between this keep block and the next op
+      if (cursor < currentText.length && currentText[cursor] === "\n") {
+        cursor += 1;
+      }
+      continue;
+    }
+
+    if (op.type === "delete" || op.type === "replace") {
+      const deleteText = op.type === "delete" ? op.text : op.oldText;
+      // Also account for the trailing newline that separates this block
+      let deleteLen = deleteText.length;
+      // Check if there's a \n after this block that should also be removed
+      if (cursor + deleteLen < currentText.length && currentText[cursor + deleteLen] === "\n") {
+        deleteLen += 1;
+      }
+
+      // Delete phase: remove characters from end of region backward
+      let remaining = deleteLen;
+      while (remaining > 0 && !signal?.aborted) {
+        const chunk = Math.min(batchSize, remaining);
+        const deleteAt = cursor + remaining - chunk;
+        currentText =
+          currentText.slice(0, deleteAt) + currentText.slice(deleteAt + chunk);
+        remaining -= chunk;
+        onContentChange(currentText);
+        // Position cursor in textarea
+        textarea.value = currentText;
+        textarea.selectionStart = textarea.selectionEnd = cursor;
+        scrollToCursor(textarea, cursor);
+        await delay(deleteSpeed);
+      }
+
+      if (op.type === "replace") {
+        // Insert phase: type new text character by character
+        const insertText = op.newText + (deleteLen > op.oldText.length ? "\n" : "");
+        let inserted = 0;
+        while (inserted < insertText.length && !signal?.aborted) {
+          const chunk = Math.min(batchSize, insertText.length - inserted);
+          const chars = insertText.slice(inserted, inserted + chunk);
+          currentText =
+            currentText.slice(0, cursor + inserted) +
+            chars +
+            currentText.slice(cursor + inserted);
+          inserted += chunk;
+          onContentChange(currentText);
+          textarea.value = currentText;
+          textarea.selectionStart = textarea.selectionEnd = cursor + inserted;
+          scrollToCursor(textarea, cursor + inserted);
+          await delay(typeSpeed);
+        }
+        cursor += insertText.length;
+      }
+      continue;
+    }
+
+    if (op.type === "insert") {
+      // Pure insertion — add a newline before if needed
+      const prefix = cursor > 0 && currentText[cursor - 1] !== "\n" ? "\n" : "";
+      const insertText = prefix + op.text + "\n";
+      let inserted = 0;
+      while (inserted < insertText.length && !signal?.aborted) {
+        const chunk = Math.min(batchSize, insertText.length - inserted);
+        const chars = insertText.slice(inserted, inserted + chunk);
+        currentText =
+          currentText.slice(0, cursor + inserted) +
+          chars +
+          currentText.slice(cursor + inserted);
+        inserted += chunk;
+        onContentChange(currentText);
+        textarea.value = currentText;
+        textarea.selectionStart = textarea.selectionEnd = cursor + inserted;
+        scrollToCursor(textarea, cursor + inserted);
+        await delay(typeSpeed);
+      }
+      cursor += insertText.length;
+      continue;
+    }
+  }
+
+  // Safety: ensure we land exactly on newText
+  onContentChange(newText);
+  if (textarea) textarea.value = newText;
+  return newText;
+}
+
+function scrollToCursor(textarea: HTMLTextAreaElement, cursorPos: number) {
+  // Approximate line from cursor position
+  const textBefore = textarea.value.slice(0, cursorPos);
+  const lineNumber = textBefore.split("\n").length;
+  const lineHeight = parseInt(getComputedStyle(textarea).lineHeight) || 20;
+  const targetScroll = lineNumber * lineHeight - textarea.clientHeight / 2;
+  if (Math.abs(textarea.scrollTop - targetScroll) > lineHeight * 3) {
+    textarea.scrollTop = Math.max(0, targetScroll);
+  }
+}
+
+/** Quick check: does the diff have any actual changes? */
+export function hasChanges(ops: DiffOp[]): boolean {
+  return ops.some((op) => op.type !== "keep");
+}

package/templates/app/src/middleware.ts

@@ -0,0 +1,13 @@
+import { type NextRequest } from "next/server";
+import { updateSession } from "@/lib/supabase-middleware";
+
+export async function middleware(request: NextRequest) {
+  return await updateSession(request);
+}
+
+export const config = {
+  matcher: [
+    // Match all paths except static files and Next.js internals
+    "/((?!_next/static|_next/image|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)",
+  ],
+};

package/templates/app/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [{ "name": "next" }],
+    "paths": { "@/*": ["./src/*"] }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/templates/app/worker/index.ts

@@ -0,0 +1,342 @@
+import { Worker, Queue } from "bullmq";
+import { createClient } from "@supabase/supabase-js";
+import path from "path";
+
+// Load env from .env.local if available
+import { config } from "dotenv";
+config({ path: path.join(__dirname, "..", ".env.local") });
+
+const REDIS_URL = process.env.REDIS_URL || "redis://localhost:6379";
+const SUPABASE_URL = process.env.SUPABASE_URL || process.env.NEXT_PUBLIC_SUPABASE_URL!;
+const SUPABASE_KEY = process.env.SUPABASE_ANON_KEY || process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!;
+const PROJECT_ROOT = process.env.PROJECT_ROOT || path.resolve(__dirname, "../..");
+const QUEUE_NAME = "agent-runs";
+
+function getRedisConfig() {
+  const url = new URL(REDIS_URL);
+  return {
+    host: url.hostname,
+    port: parseInt(url.port || "6379", 10),
+    password: url.password || undefined,
+    maxRetriesPerRequest: null as null,
+  };
+}
+
+const connection = getRedisConfig();
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+
+// Dynamic import for ESM compatibility with agent SDK
+async function loadAgentRunner() {
+  // We need to load agents and execute them
+  const fs = await import("fs");
+  const matter = (await import("gray-matter")).default;
+
+  const agentsDir = path.join(PROJECT_ROOT, ".claude", "agents");
+
+  function getAgentMeta(slug: string) {
+    if (slug === "main") {
+      return {
+        slug: "main",
+        name: "My Assistant",
+        description: "Personal AI assistant with full access to all tools and subagents.",
+        tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "WebSearch", "WebFetch", "Agent"],
+        model: undefined,
+        filePath: "",
+      };
+    }
+    const filePath = path.join(agentsDir, `${slug}.md`);
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const { data } = matter(raw);
+    return {
+      slug,
+      name: data.name || slug,
+      description: data.description || "",
+      tools: data.tools ? String(data.tools).split(",").map((t: string) => t.trim()).filter(Boolean) : [],
+      color: data.color,
+      emoji: data.emoji,
+      vibe: data.vibe,
+      model: data.model,
+      filePath,
+    };
+  }
+
+  function getProjectInstructions(): string {
+    try {
+      return fs.readFileSync(path.join(PROJECT_ROOT, "CLAUDE.md"), "utf-8").trim();
+    } catch { return ""; }
+  }
+
+  function getAgentSystemPrompt(slug: string): string {
+    const projectInstructions = getProjectInstructions();
+    if (slug === "main") return projectInstructions;
+    const filePath = path.join(agentsDir, `${slug}.md`);
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const { content } = matter(raw);
+    return [projectInstructions, content.trim()].filter(Boolean).join("\n\n---\n\n");
+  }
+
+  function getSubagentDefinitions(): Record<string, { description: string; prompt: string; tools: string[] }> {
+    const defs: Record<string, { description: string; prompt: string; tools: string[] }> = {};
+    const files = fs.readdirSync(agentsDir).filter((f: string) => f.endsWith(".md"));
+    for (const file of files) {
+      const filePath = path.join(agentsDir, file);
+      const raw = fs.readFileSync(filePath, "utf-8");
+      const { data, content } = matter(raw);
+      const slug = path.basename(file, ".md");
+      const tools = data.tools ? String(data.tools).split(",").map((t: string) => t.trim()).filter(Boolean) : ["Read", "Write", "Edit", "Bash", "Glob", "Grep"];
+      defs[slug] = { description: data.description || slug, prompt: content.trim(), tools };
+    }
+    return defs;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function getMcpServers(): Record<string, any> {
+    try {
+      const mcpPath = path.join(PROJECT_ROOT, ".mcp.json");
+      const raw = JSON.parse(fs.readFileSync(mcpPath, "utf-8"));
+      return raw.mcpServers || {};
+    } catch { return {}; }
+  }
+
+  function getSkillContent(slug: string): string | null {
+    try {
+      const skillFile = path.join(PROJECT_ROOT, ".claude", "skills", slug, "SKILL.md");
+      if (!fs.existsSync(skillFile)) return null;
+      const raw = fs.readFileSync(skillFile, "utf-8");
+      const { content } = matter(raw);
+      return content.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+
+  return { getAgentMeta, getAgentSystemPrompt, getSubagentDefinitions, getMcpServers, getSkillContent };
+}
+
+async function main() {
+  const { getAgentMeta, getAgentSystemPrompt, getSubagentDefinitions, getMcpServers, getSkillContent } = await loadAgentRunner();
+  const { query } = await import("@anthropic-ai/claude-agent-sdk");
+
+  // Sync schedules from Supabase to BullMQ on startup
+  const queue = new Queue(QUEUE_NAME, { connection });
+
+  const { data: schedules } = await supabase
+    .from("agent_schedules")
+    .select("*")
+    .eq("enabled", true);
+
+  if (schedules) {
+    for (const schedule of schedules) {
+      await queue.upsertJobScheduler(
+        `schedule-${schedule.id}`,
+        { pattern: schedule.cron },
+        {
+          name: "scheduled-agent-run",
+          data: {
+            scheduleId: schedule.id,
+            agentSlug: schedule.agent_slug,
+            agentName: schedule.agent_name,
+            prompt: schedule.prompt,
+            skillSlug: schedule.skill_slug || undefined,
+          },
+        }
+      );
+      console.log(`[worker] Registered scheduler: schedule-${schedule.id} (${schedule.cron})`);
+    }
+  }
+
+  const worker = new Worker(
+    QUEUE_NAME,
+    async (job) => {
+      const { scheduleId, agentSlug, agentName, prompt, skillSlug } = job.data;
+      console.log(`[worker] Processing job ${job.id}: agent=${agentSlug}`);
+
+      const agent = getAgentMeta(agentSlug);
+      if (!agent) {
+        throw new Error(`Agent ${agentSlug} not found`);
+      }
+
+      // Create a run record in Supabase
+      const { data: run, error: insertError } = await supabase
+        .from("agent_runs")
+        .insert({
+          agent_slug: agentSlug,
+          agent_name: agentName,
+          prompt,
+          status: "running",
+          schedule_id: scheduleId || null,
+          started_at: new Date().toISOString(),
+        })
+        .select()
+        .single();
+
+      if (insertError || !run) {
+        throw new Error(`Failed to create run record: ${insertError?.message}`);
+      }
+
+      const startTime = Date.now();
+      let output = "";
+      let sessionId = "";
+      let costUsd = 0;
+
+      try {
+        const isMainAgent = agentSlug === "main";
+        const mcpServers = getMcpServers();
+        let systemPrompt = getAgentSystemPrompt(agentSlug);
+
+        // Inject skill content into system prompt if a skill is specified
+        if (skillSlug) {
+          const skillContent = getSkillContent(skillSlug);
+          if (skillContent) {
+            systemPrompt = [systemPrompt, `## Active Skill: ${skillSlug}\n\n${skillContent}`]
+              .filter(Boolean).join("\n\n---\n\n");
+          }
+        }
+        const subagents = isMainAgent ? getSubagentDefinitions() : undefined;
+
+        const q = query({
+          prompt,
+          options: {
+            cwd: PROJECT_ROOT,
+            permissionMode: "bypassPermissions",
+            allowDangerouslySkipPermissions: true,
+            systemPrompt,
+            maxBudgetUsd: isMainAgent ? 5.0 : 2.0,
+            model: agent.model || undefined,
+            mcpServers,
+            ...(subagents ? { agents: subagents, allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "WebSearch", "WebFetch", "Agent"] } : {}),
+            env: {
+              ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || "",
+            },
+          },
+        });
+
+        for await (const message of q) {
+          if (message.type === "system" && "subtype" in message && message.subtype === "init") {
+            sessionId = message.session_id;
+          }
+
+          if (message.type === "result") {
+            const result = message as {
+              total_cost_usd: number;
+              session_id: string;
+              result?: string;
+              subtype: string;
+              errors?: string[];
+            };
+            costUsd = result.total_cost_usd;
+            sessionId = result.session_id || sessionId;
+
+            if (result.subtype !== "success") {
+              throw new Error(result.errors?.join("; ") || `Agent ended with ${result.subtype}`);
+            }
+            if (result.result) {
+              output = result.result;
+            }
+          }
+        }
+
+        const durationMs = Date.now() - startTime;
+
+        await supabase
+          .from("agent_runs")
+          .update({
+            status: "completed",
+            output,
+            cost_usd: costUsd,
+            duration_ms: durationMs,
+            session_id: sessionId,
+            completed_at: new Date().toISOString(),
+          })
+          .eq("id", run.id);
+
+        // Update schedule last_run_at
+        if (scheduleId) {
+          await supabase
+            .from("agent_schedules")
+            .update({ last_run_at: new Date().toISOString() })
+            .eq("id", scheduleId);
+        }
+
+        // Create notification
+        const contentSkills = ["create-blog-post", "create-linkedin-post", "create-post-designs", "publish-wordpress"];
+        const notifType = skillSlug && contentSkills.includes(skillSlug) ? "needs_review" : "completed";
+        await supabase.from("notifications").insert({
+          run_id: run.id,
+          schedule_id: scheduleId || null,
+          agent_slug: agentSlug,
+          session_id: sessionId || null,
+          type: notifType,
+          title: `${agentName}: ${notifType === "needs_review" ? "Ready for review" : "Completed"}`,
+          summary: output ? output.slice(0, 200) : null,
+        });
+
+        console.log(`[worker] Job ${job.id} completed: cost=$${costUsd.toFixed(4)}, duration=${durationMs}ms`);
+        return { runId: run.id, costUsd, durationMs };
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+
+        await supabase
+          .from("agent_runs")
+          .update({
+            status: "failed",
+            error: errorMsg,
+            completed_at: new Date().toISOString(),
+          })
+          .eq("id", run.id);
+
+        // Create failure notification
+        await supabase.from("notifications").insert({
+          run_id: run.id,
+          schedule_id: scheduleId || null,
+          agent_slug: agentSlug,
+          session_id: sessionId || null,
+          type: "failed",
+          title: `${agentName}: Failed`,
+          summary: errorMsg.slice(0, 200),
+        });
+
+        console.error(`[worker] Job ${job.id} failed: ${errorMsg}`);
+        throw err;
+      }
+    },
+    {
+      connection,
+      concurrency: 2,
+      lockDuration: 600_000, // 10 min for long-running agents
+      stalledInterval: 600_000,
+      maxStalledCount: 2,
+    }
+  );
+
+  worker.on("completed", (job) => {
+    console.log(`[worker] Job ${job?.id} completed`);
+  });
+
+  worker.on("failed", (job, error) => {
+    console.error(`[worker] Job ${job?.id} failed:`, error.message);
+  });
+
+  worker.on("error", (error) => {
+    console.error("[worker] Worker error:", error);
+  });
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    console.log("[worker] Shutting down...");
+    await worker.close();
+    await queue.close();
+    process.exit(0);
+  };
+
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+
+  console.log(`[worker] Started. Listening on queue: ${QUEUE_NAME}`);
+}
+
+main().catch((err) => {
+  console.error("[worker] Fatal error:", err);
+  process.exit(1);
+});

package/templates/claude/agents/ai-trends-scout.md

@@ -0,0 +1,66 @@
+---
+name: AI Trends Scout
+description: >-
+  Researches the latest AI models, tools, and trending content to keep you
+  updated on what's new and popular in the AI community.
+tools: 'WebSearch, WebFetch, Read'
+color: '#8B5CF6'
+emoji: "\U0001F52E"
+vibe: Spotting tomorrow's AI breakthroughs today
+---
+# AI Trends Scout Agent
+
+## Identity
+You are an AI Trends Scout - a dedicated researcher who stays on top of the rapidly evolving artificial intelligence landscape. Your mission is to uncover what's new in AI, identify emerging models and tools that are gaining traction, and discover what content is resonating with audiences on platforms like YouTube. You provide timely, accurate intelligence on the AI ecosystem.
+
+## Core Responsibilities
+
+### Research Focus Areas
+1. **New AI Models & Releases**: Track announcements of new language models, vision models, multimodal systems, and specialized AI tools
+2. **Emerging Tools & Platforms**: Identify new AI applications, frameworks, and services that developers and businesses are adopting
+3. **Community Conversations**: Monitor what people are actively discussing - trending topics, breakthroughs, controversies
+4. **YouTube Trends**: Research popular AI-related video content, what tutorials are getting views, and what creators are covering
+
+## Operational Guidelines
+
+### Search Strategy
+- Conduct multiple targeted searches using keywords like "AI news," "new AI models 2024," "trending AI tools," "AI YouTube trending"
+- Search for specific platforms and sources: Reddit AI communities, Product Hunt, Hacker News, ArXiv papers, YouTube trending AI content
+- Look for both technical depth and broader adoption signals
+- Search for "AI tutorial YouTube trending" and "most viewed AI content" to identify popular educational videos
+
+### Research Methodology
+1. Start with broad searches to identify current hot topics
+2. Follow up with specific searches on high-interest items
+3. Fetch and read content from credible sources
+4. Cross-reference information across multiple sources
+5. Identify both hype and substantive developments
+
+### Content Analysis
+- Distinguish between genuine innovation and marketing hype
+- Note engagement metrics when available (views, discussion volume)
+- Identify patterns in what content resonates (tutorials, reviews, debates, how-tos)
+- Pay attention to YouTube video titles, view counts, and channel focus areas
+
+## Output Format
+
+When presenting findings, structure your response as:
+
+1. **Latest Model Releases** - New AI systems announced/released recently with key capabilities
+2. **Trending Tools & Platforms** - Tools gaining momentum and what makes them notable
+3. **Community Hot Topics** - What AI discussions are getting the most attention
+4. **YouTube Trending Content** - Top-performing AI videos, creators, and content types with approximate view counts
+5. **Key Insights** - Patterns and significance of current trends
+
+## Constraints & Guidelines
+
+- Be specific with dates and timeframes (e.g., "in the last week", "this month")
+- Include source attribution when possible
+- Focus on publicly available, verified information
+- Note if information is recent (within days) vs. older
+- Distinguish between official releases and community/unofficial projects
+- Be honest about information limitations or uncertainty
+- Avoid speculation; stick to what's actually being discussed and released
+
+## Tone
+Be conversational yet informative. You're an expert scout helping someone stay current, not an academic paper. Make insights accessible and highlight what's genuinely important vs. just noisy trending topics.

package/templates/claude/commands/add-to-todos.md

@@ -0,0 +1,56 @@
+---
+description: Add todo item to TO-DOS.md with context from conversation
+argument-hint: <todo-description> (optional - infers from conversation if omitted)
+allowed-tools:
+  - Read
+  - Edit
+  - Write
+---
+
+# Add Todo Item
+
+## Context
+
+- Current timestamp: !`date "+%Y-%m-%d %H:%M"`
+
+## Instructions
+
+1. Read TO-DOS.md in the working directory (create with Write tool if it doesn't exist)
+
+2. Check for duplicates:
+   - Extract key concept/action from the new todo
+   - Search existing todos for similar titles or overlapping scope
+   - If found, ask user: "A similar todo already exists: [title]. Would you like to:\n\n1. Skip adding (keep existing)\n2. Replace existing with new version\n3. Add anyway as separate item\n\nReply with the number of your choice."
+   - Wait for user response before proceeding
+
+3. Extract todo content:
+   - **With $ARGUMENTS**: Use as the focus/title for the todo and context heading
+   - **Without $ARGUMENTS**: Analyze recent conversation to extract:
+     - Specific problem or task discussed
+     - Relevant file paths that need attention
+     - Technical details (line numbers, error messages, conflicting specifications)
+     - Root cause if identified
+
+4. Append new section to bottom of file:
+   - **Heading**: `## Brief Context Title - YYYY-MM-DD HH:MM` (3-8 word title, current timestamp)
+   - **Todo format**: `- **[Action verb] [Component]** - [Brief description]. **Problem:** [What's wrong/why needed]. **Files:** [Comma-separated paths with line numbers]. **Solution:** [Approach hints or constraints, if applicable].`
+   - **Required fields**: Problem and Files (with line numbers like `path/to/file.ts:123-145`)
+   - **Optional field**: Solution
+   - Make each section self-contained for future Claude to understand weeks later
+   - Use simple list items (not checkboxes) - todos are removed when work begins
+
+5. Confirm and offer to continue with original work:
+   - Identify what the user was working on before `/add-to-todos` was called
+   - Confirm the todo was saved: "✓ Saved to todos."
+   - Ask if they want to continue with the original work: "Would you like to continue with [original task]?"
+   - Wait for user response
+
+## Format Example
+
+```markdown
+## Add Todo Command Improvements - 2025-11-15 14:23
+
+- **Add structured format to add-to-todos** - Standardize todo entries with Problem/Files/Solution pattern. **Problem:** Current todos lack consistent structure, making it hard for Claude to have enough context when revisiting tasks later. **Files:** `commands/add-to-todos.md:22-29`. **Solution:** Use inline bold labels with required Problem and Files fields, optional Solution field.
+
+- **Create check-todos command** - Build companion command to list and select todos. **Problem:** Need workflow to review outstanding todos and load context for selected item. **Files:** `commands/check-todos.md` (new), `TO-DOS.md` (reads from). **Solution:** Parse markdown list, display numbered list, accept selection to load full context and remove item.
+```