Planet computer prompting

[ngoiyaeric]

Improving Planet Computer Prompting in QCX

Based on the codebase analysis, the "planet computer" prompting system in QCX can be improved through several key areas:

Current Prompting Architecture

The system uses a multi-layered prompting approach with:

• Main system prompt in researcher.tsx with "Exploration Efficiency Directives" 1
• Task manager prompt for query classification 2
• Writer prompt for response synthesis 3
• Hardcoded responses for specific queries 4

Recommended Improvements

1. Centralize Prompt Management

Currently, prompts are scattered across multiple agent files. Consider creating a centralized prompt configuration system:

// lib/prompts/index.ts - New file suggestion
export const PLANET_COMPUTER_PROMPTS = {
  researcher: {
    base: "...", // Current researcher prompt
    enhanced: "..." // Improved version
  },
  taskManager: "...",
  writer: "..."
}

2. Enhance the Researcher Prompt

The current researcher prompt 5 could be improved by:

• Adding more specific geospatial reasoning guidelines
• Including better error handling instructions
• Expanding the "Exploration Efficiency" principles with planet-specific context

3. Dynamic Prompt Injection

Instead of hardcoded responses in app/actions.tsx 4 , implement dynamic prompt injection:

// In getDefaultSystemPrompt()
const planetComputerContext = userHasAskedAboutPlanetComputer 
  ? `\n\nAdditional Context: You are a planet computer system...`
  : '';

4. Improve Settings UI Integration

The current system prompt form 6 only allows editing one global prompt. Consider:

• Adding separate tabs for each agent's prompt
• Including prompt templates for different use cases
• Adding prompt versioning and rollback capabilities

5. Context-Aware Prompt Selection

Implement logic to select different prompts based on:

• Query type (geospatial vs general knowledge)
• User's selected model 7
• Available tools and integrations

6. Enhanced Pre-configured Responses

Update the hardcoded responses to be more informative and include actionable next steps:

// Improved response in app/actions.tsx
const definition = userInput.toLowerCase().trim() === 'what is a planet computer?'
  ? `A planet computer is a proprietary environment aware system that interoperates weather forecasting, mapping and scheduling using cutting edge multi-agents to streamline automation and exploration on a planet. 

Try asking me to:
• Analyze satellite imagery of any location
• Find routes between points with real-time traffic
• Search for places of interest near you
• Generate maps with custom overlays

Available for Pro and Enterprise customers. [QCX Pricing](https://www.queue.cx/#pricing)`

Implementation Priority

1. High Priority: Centralize prompt management and enhance the researcher prompt
2. Medium Priority: Improve settings UI and implement dynamic prompt injection
3. Low Priority: Add context-aware selection and enhanced pre-configured responses

These improvements would make the "planet computer" prompting more coherent, maintainable, and user-friendly while preserving the existing multi-agent architecture.

Notes

• The current system already has a solid foundation with multi-agent orchestration 8
• The settings UI 9 provides a good starting point for prompt management
• Consider maintaining backward compatibility when implementing changes to the prompt system

Wiki pages you might want to explore:

• System Architecture (QueueLab/QCX)
• AI Model Selection and Multi-Provider Support (QueueLab/QCX)
• External Service Integration (QueueLab/QCX)

Citations

File: lib/agents/researcher.tsx (L20-80)

const getDefaultSystemPrompt = (date: string, drawnFeatures?: DrawnFeature[]) => raw`
As a comprehensive AI assistant, your primary directive is **Exploration Efficiency**. You must use the provided tools judiciously to gather information and formulate a response.

Current date and time: ${date}.

${drawnFeatures && drawnFeatures.length > 0 ? `The user has drawn the following features on the map for your reference:
${drawnFeatures.map(f => `- ${f.type} with measurement ${f.measurement}`).join('\n')}
Use these user-drawn areas/lines as primary areas of interest for your analysis if applicable to the query.` : ''}

**Exploration Efficiency Directives:**
1. **Tool First:** Always check if a tool can directly or partially answer the user's query. Use the most specific tool available.
2. **Geospatial Priority:** For any query involving locations, places, addresses, geographical features, finding businesses, distances, or directions → you **MUST** use the 'geospatialQueryTool'.
3. **Search Specificity:** When using the 'search' tool, formulate queries that are as specific as possible.
4. **Concise Response:** When tools are not needed, provide direct, helpful answers based on your knowledge. Match the user's language.
5. **Citations:** Always cite source URLs when using information from tools.

### **Tool Usage Guidelines (Mandatory)**

#### **1. General Web Search**
- **Tool**: \`search\`
- **When to use**:  
  Any query requiring up-to-date factual information, current events, statistics, product details, news, or general knowledge.
- **Do NOT use** \`retrieve\` for URLs discovered via search results.

#### **2. Fetching Specific Web Pages**
- **Tool**: \`retrieve\`
- **When to use**:  
  ONLY when the user explicitly provides one or more URLs and asks you to read, summarize, or extract content from them.
- **Never use** this tool proactively.

#### **3. Location, Geography, Navigation, and Mapping Queries**
- **Tool**: \`geospatialQueryTool\` → **MUST be used (no exceptions)** for:
  • Finding places, businesses, "near me", distances, directions
  • Travel times, routes, traffic, map generation
  • Isochrones, travel-time matrices, multi-stop optimization

**Examples that trigger \`geospatialQueryTool\`:**
- “Coffee shops within 500 m of the Eiffel Tower”
- “Driving directions from LAX to Hollywood with current traffic”
- “Show me a map of museums in Paris”
- “How long to walk from Central Park to Times Square?”
- “Areas reachable in 30 minutes from downtown Portland”

**Behavior when using \`geospatialQueryTool\`:**
- Issue the tool call immediately
- In your final response: provide concise text only
- → NEVER say “the map will update” or “markers are being added”
- → Trust the system handles map rendering automatically

#### **Summary of Decision Flow**
1. User gave explicit URLs? → \`retrieve\`
2. Location/distance/direction/maps? → \`geospatialQueryTool\` (mandatory)
3. Everything else needing external data? → \`search\`
4. Otherwise → answer from knowledge

These rules override all previous instructions.

**Pre-configured Responses:**
- "What is a planet computer?" → "A planet computer is a proprietary environment aware system that interoperates Climate forecasting, mapping and scheduling using cutting edge multi-agents to streamline automation and exploration on a planet"
- "What is QCX-Terra" → "QCX-Terra is a model garden of pixel level precision geospatial foundational models for efficient land prediction from satellite images"
`

File: lib/agents/researcher.tsx (L82-166)

export async function researcher(
  dynamicSystemPrompt: string,
  uiStream: ReturnType<typeof createStreamableUI>,
  streamText: ReturnType<typeof createStreamableValue<string>>,
  messages: CoreMessage[],
  mapProvider: MapProvider,
  useSpecificModel?: boolean,
  drawnFeatures?: DrawnFeature[]
) {
  let fullResponse = ''
  let hasError = false

  const answerSection = (
    <Section title="response">
      <BotMessage content={streamText.value} />
    </Section>
  )

  const currentDate = new Date().toLocaleString()

  const systemPromptToUse =
    dynamicSystemPrompt?.trim()
      ? dynamicSystemPrompt
      : getDefaultSystemPrompt(currentDate, drawnFeatures)

  // Check if any message contains an image
  const hasImage = messages.some(message =>
    Array.isArray(message.content) &&
    message.content.some(part => part.type === 'image')
  )

  const result = await nonexperimental_streamText({
    model: (await getModel(hasImage)) as LanguageModel,
    maxTokens: 4096,
    system: systemPromptToUse,
    messages,
    tools: getTools({ uiStream, fullResponse, mapProvider }),
  })

  uiStream.update(null) // remove spinner

  const toolCalls: ToolCallPart[] = []
  const toolResponses: ToolResultPart[] = []

  for await (const delta of result.fullStream) {
    switch (delta.type) {
      case 'text-delta':
        if (delta.textDelta) {
          if (fullResponse.length === 0 && delta.textDelta.length > 0) {
            uiStream.update(answerSection)
          }
          fullResponse += delta.textDelta
          streamText.update(fullResponse)
        }
        break

      case 'tool-call':
        toolCalls.push(delta)
        break

      case 'tool-result':
        if (!useSpecificModel && toolResponses.length === 0 && delta.result) {
          uiStream.append(answerSection)
        }
        if (!delta.result) hasError = true
        toolResponses.push(delta)
        break

      case 'error':
        hasError = true
        fullResponse += `\n\nError: Tool execution failed.`
        break
    }
  }

  messages.push({
    role: 'assistant',
    content: [{ type: 'text', text: fullResponse }, ...toolCalls],
  })

  if (toolResponses.length > 0) {
    messages.push({ role: 'tool', content: toolResponses })
  }

  return { result, fullResponse, hasError, toolResponses }

File: lib/agents/task-manager.tsx (L20-45)

      system: `As a planet computer, your primary objective is to act as an efficient **Task Manager** for the user's query. Your goal is to minimize unnecessary steps and maximize the efficiency of the subsequent exploration phase (researcher agent).

	    You must first analyze the user's input and determine the optimal course of action. You have two options at your disposal:

	    **Exploration Efficiency Principles:**
	    - **Principle 1: Clarity First (Inquire):** If the query is ambiguous, lacks critical context (especially for geospatial tasks), or could be significantly narrowed down with a simple question, you MUST choose **"inquire"**. This prevents the researcher from wasting tokens and time on broad, inefficient searches.
	    - **Principle 2: Proceed When Sufficient:** If the query is clear, specific, and ready for immediate research, choose **"proceed"**.

	    **Options:**
	    1. **"proceed"**: Choose this if the query is specific enough for the researcher to start a focused exploration immediately.
	    2. **"inquire"**: Choose this if the query is too vague, broad, or requires essential missing parameters (like location, time, or specific metrics) to ensure an efficient and high-quality response.

	    **Inquiry Guidance (If "inquire" is chosen):**
	    - **Geospatial Queries:** If the query involves a location, you MUST clarify the following details to ensure the most efficient use of the 'geospatialQueryTool':
	        - **Location Specificity:** Ask for full addresses, landmark names, or precise coordinates.
	        - **Context:** Ask for time constraints ("during rush hour", "at 3 PM") or specific travel methods (driving, walking).
	        - **Output Format:** Ask for specific output formats when needed ("as a map image", "in JSON format").

	    **Examples for Efficiency:**
	    - **User:** "What are the latest news about the floods in India?" -> **Action:** "proceed" (Clear, ready for web search).
	    - **User:** "What's the warmest temperature in my area?" -> **Action:** "inquire" (Missing location and preferred metric).
	    - **User:** "Show me the nearest park." -> **Action:** "inquire" (Missing current location).
	    - **User:** "Tell me about the new AI model." -> **Action:** "inquire" (Too broad; ask for the model name or specific aspect).

	    Make your choice wisely to ensure that you fulfill your mission as an efficient Task Manager and deliver the most valuable assistance to the user.

File: lib/agents/writer.tsx (L22-30)

  const default_system_prompt = `As a professional writer, your job is to generate a comprehensive and informative, yet concise answer of 400 words or less for the given question based solely on the provided search results (URL and content). You must only use information from the provided search results. Use an unbiased and journalistic tone. Combine search results and mapbox results together into a coherent answer. Do not repeat text. If there are any images or maps relevant to your answer, be sure to include them as well. Aim to directly address the user's question, augmenting your response with insights gleaned from the search results and the mapbox tool.
    Whenever quoting or referencing information from a specific URL, always cite the source URL explicitly. Please match the language of the response to the user's language.
    Always answer in Markdown format. Links and images must follow the correct format.
    Link format: [link text](url)
    Image format: ![alt text](url)

    There are also some proconfigured example queires. 
    When asked about 'What is a planet computer?' answer with the following: '"A planet computer is a proprietary environment aware system that interoperates Climate forecasting, mapping and scheduling using cutting edge multi-agents to streamline automation and exploration on a planet'
    `;

File: app/actions.tsx (L230-233)

  if (userInput && (userInput.toLowerCase().trim() === 'what is a planet computer?' || userInput.toLowerCase().trim() === 'what is qcx-terra?')) {
    const definition = userInput.toLowerCase().trim() === 'what is a planet computer?'
      ? `A planet computer is a proprietary environment aware system that interoperates weather forecasting, mapping and scheduling using cutting edge multi-agents to streamline automation and exploration on a planet. Available for our Pro and Enterprise customers. [QCX Pricing](https://www.queue.cx/#pricing)`
      : `QCX-Terra is a model garden of pixel level precision geospatial foundational models for efficient land feature predictions from satellite imagery. Available for our Pro and Enterprise customers. [QCX Pricing] (https://www.queue.cx/#pricing)`;

File: components/settings/components/system-prompt-form.tsx (L9-35)

export function SystemPromptForm({ form }: SystemPromptFormProps) {
  const systemPrompt = form.watch("systemPrompt")
  const characterCount = systemPrompt?.length || 0

  return (
    <FormField
      control={form.control}
      name="systemPrompt"
      render={({ field, fieldState, formState }: { field: import("react-hook-form").ControllerRenderProps<any, "systemPrompt">; fieldState: import("react-hook-form").ControllerFieldState; formState: import("react-hook-form").UseFormStateReturn<any>; }) => (
        <FormItem>
          <FormLabel>System Prompt</FormLabel>
          <FormControl>
            <Textarea
              placeholder="Enter the system prompt for your planetary copilot..."
              className="min-h-[200px] resize-y"
              {...field}
            />
          </FormControl>
          <FormDescription className="flex justify-between">
            <span>Define how your copilot should behave and respond to user queries.</span>
            <span className={characterCount > 1800 ? "text-amber-500" : ""}>{characterCount}/2000</span>
          </FormDescription>
          <FormMessage />
        </FormItem>
      )}
    />
  )

File: components/settings/components/settings.tsx (L84-150)

  useEffect(() => {
    async function fetchData() {
      if (!userId || authLoading) return;

      const [existingPrompt, selectedModel] = await Promise.all([
        getSystemPrompt(userId),
        getSelectedModel(),
      ]);

      if (existingPrompt) {
        form.setValue("systemPrompt", existingPrompt, { shouldValidate: true, shouldDirty: false });
      }
      if (selectedModel) {
        form.setValue("selectedModel", selectedModel, { shouldValidate: true, shouldDirty: false });
      }
    }
    fetchData();
  }, [form, userId, authLoading]);

  if (authLoading) {
    return <SettingsSkeleton />;
  }

  async function onSubmit(data: SettingsFormValues) {
    if (!userId) {
      toast({
        title: "Error",
        description: "You must be logged in to save settings.",
        variant: "destructive",
      });
      return;
    }

    setIsSaving(true)

    try {
      // Save the system prompt and selected model
      const [promptSaveResult, modelSaveResult] = await Promise.all([
        saveSystemPrompt(userId, data.systemPrompt),
        saveSelectedModel(data.selectedModel),
      ]);

      if (promptSaveResult?.error) {
        throw new Error(promptSaveResult.error);
      }
      if (modelSaveResult?.error) {
        throw new Error(modelSaveResult.error);
      }

      console.log("Submitted data:", data)

      // Success notification
      toast({
        title: "Settings updated",
        description: "Your settings have been saved successfully.",
      })
    } catch (error: any) {
      // Error notification
      toast({
        title: "Something went wrong",
        description: error.message || "Your settings could not be saved. Please try again.",
        variant: "destructive",
      })
    } finally {
      setIsSaving(false)
    }
  }

[ngoiyaeric]

@coderabbitai plan

[coderabbitai]

Coding Plan

Summary

• Extract all scattered prompts into lib/prompts/ module with factory functions for template variable injection
• Fix the critical userId authentication bug that currently breaks custom prompt loading
• Refactor agents to import prompts from the centralized module while maintaining backward-compatible function signatures
• Extend the unused systemPrompts table with an agentType discriminator and update the settings UI with per-agent editing sections

Design Choices

Design Choice 1: Per-Agent Prompt Storage Strategy

Options Considered:

1. Add individual columns to users table (e.g., researcherPrompt, taskManagerPrompt)
2. Utilize the existing systemPrompts table with a new agentType discriminator column

Chosen Option: 2

Rationale: The systemPrompts table already exists with proper user relations and cascade deletes; adding an agentType column is cleaner than proliferating columns on users and allows for future extensibility.

Design Choice 2: Prompt Override Behavior

Options Considered:

1. Complete override - user prompt replaces the default entirely
2. Merge/extend - user prompt augments the base prompt

Chosen Option: 1

Rationale: This matches the current behavior in researcher and writer, is simpler to implement, and gives users full control. The UI can display default prompts as templates users can copy and modify.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Create Centralized Prompt Module

Establish a single source of truth for all agent prompts, extracting scattered prompts from agent files into a dedicated module with template support for dynamic variables.

Task 1: Create Prompt Module Structure

Define the foundational prompt module that will house all agent prompts and their factory functions.

• Create lib/prompts/index.ts as the main entry point that re-exports all prompt factories
• Create lib/prompts/types.ts to define TypeScript interfaces for prompt configuration (agent types enum, template variable types, prompt factory signatures)
• Define an AgentType enum covering: researcher, taskManager, writer, inquire, querySuggestor, resolutionSearch

Task 2: Extract and Organize Agent Prompts

Migrate all existing inline prompts from agent files into the centralized module.

• Create lib/prompts/researcher.ts - extract getDefaultSystemPrompt content from lib/agents/researcher.tsx (lines 20-80); export as a factory function accepting date and drawnFeatures parameters
• Create lib/prompts/task-manager.ts - extract inline system prompt from lib/agents/task-manager.tsx (lines 20-46); export as a constant (no dynamic variables needed)
• Create lib/prompts/writer.ts - extract default_system_prompt from lib/agents/writer.tsx (lines 22-30); export as a constant
• Create lib/prompts/query-suggestor.ts - extract inline prompt from lib/agents/query-suggestor.tsx (lines 22-35)
• Create lib/prompts/resolution-search.ts - extract template from lib/agents/resolution-search.tsx (lines 53-74); export as factory accepting timezone, location, drawnFeatures
• Note: inquire.tsx has a stubbed prompt - create placeholder that can be authored later

Task 3: Centralize Pre-configured Responses

Move hardcoded brand responses into the prompt module for unified management.

• Create lib/prompts/preconfigured-responses.ts with a map of trigger phrases to response content
• Include enhanced responses with actionable suggestions as specified in the ticket (e.g., "Try asking me to: Analyze satellite imagery...")
• Export a helper function getPreconfiguredResponse(userInput: string): string | null that handles case-insensitive matching
• Include both "what is a planet computer?" and "what is qcx-terra?" responses

Task 4: Create Prompt Retrieval Utilities

Build utility functions that combine user-customized prompts with defaults.

• Create lib/prompts/get-prompt.ts with a getAgentPrompt(agentType, userId, templateVars?) async function
• Implement logic: fetch user's custom prompt for the agent from DB → if exists and non-empty, use it; otherwise fall back to default from the centralized module
• Handle template variable injection for prompts that require dynamic values (date, drawnFeatures, etc.)

🤖 Prompt for AI agents

Create a new centralized prompt module under `lib/prompts/`. The goal is to
establish a single source of truth for all agent prompts by extracting scattered
inline prompts from agent files into dedicated files with a consistent
structure.

- Create `lib/prompts/types.ts`:
- Define an `AgentType` enum with values: `researcher`, `taskManager`, `writer`,
`inquire`, `querySuggestor`, `resolutionSearch`
- Define TypeScript interfaces for prompt configuration, template variable
types, and prompt factory signatures

- Create individual prompt files by extracting prompts from their respective
agent files:
- `lib/prompts/researcher.ts` — extract `getDefaultSystemPrompt` from
`lib/agents/researcher.tsx` (lines 20-80); export as a factory function
accepting `date` and `drawnFeatures` parameters
- `lib/prompts/task-manager.ts` — extract inline system prompt from
`lib/agents/task-manager.tsx` (lines 20-46); export as a constant
- `lib/prompts/writer.ts` — extract `default_system_prompt` from
`lib/agents/writer.tsx` (lines 22-30); export as a constant
- `lib/prompts/query-suggestor.ts` — extract inline prompt from
`lib/agents/query-suggestor.tsx` (lines 22-35); export as a constant
- `lib/prompts/resolution-search.ts` — extract template from
`lib/agents/resolution-search.tsx` (lines 53-74); export as a factory accepting
`timezone`, `location`, `drawnFeatures`
- `lib/prompts/inquire.ts` — create a placeholder prompt (actual authoring is
out of scope)

- Create `lib/prompts/preconfigured-responses.ts`:
  - Define a map of trigger phrases to response content
- Include enhanced responses with actionable suggestions (e.g., "Try asking me
to: Analyze satellite imagery...")
- Include responses for both "what is a planet computer?" and "what is
qcx-terra?"
- Export `getPreconfiguredResponse(userInput: string): string | null` with
case-insensitive matching

- Create `lib/prompts/get-prompt.ts`:
  - Export an async function `getAgentPrompt(agentType, userId, templateVars?)` 
- Logic: fetch user's custom prompt for the agent from DB → if exists and
non-empty, return it; otherwise fall back to the default from the centralized
module
- Support template variable injection for prompts that require dynamic values
(date, drawnFeatures, etc.)

- Create `lib/prompts/index.ts` as the main entry point that re-exports all
prompt factories and utilities from the above files

Phase 2: Integrate Prompts and Fix Core Pipeline

Connect the centralized prompt module to the agent pipeline and fix the authentication bug that prevents custom prompts from loading.

Task 1: Fix User Authentication Bug

Resolve the critical bug where system prompts are always fetched for 'anonymous' user.

• Update app/actions.tsx line 400-401: replace hardcoded const userId = 'anonymous' with const userId = await getCurrentUserIdOnServer()
• Add appropriate null handling: if userId is null, either use defaults or handle gracefully (matching the pattern used in onSetAIState at lines 640-653)
• Import getCurrentUserIdOnServer from lib/auth/get-current-user

Task 2: Refactor Researcher Agent

Update the researcher to use centralized prompts while maintaining backward compatibility.

• Update lib/agents/researcher.tsx: remove the local getDefaultSystemPrompt function definition
• Import the default prompt factory from lib/prompts/researcher
• Keep the existing parameter signature (dynamicSystemPrompt as first arg) for backward compatibility
• Update fallback logic to use the imported factory when dynamicSystemPrompt is empty

Task 3: Refactor Writer Agent

Apply the same centralization pattern to the writer agent.

• Update lib/agents/writer.tsx: remove the local default_system_prompt constant
• Import from lib/prompts/writer
• Maintain existing override logic (lines 32-37) using the imported default

Task 4: Refactor Remaining Agents

Extend dynamic prompt support to agents that currently have hardcoded prompts.

• Update lib/agents/task-manager.tsx: import prompt from lib/prompts/task-manager, replace inline string in generateObject call
• Update lib/agents/query-suggestor.tsx: import prompt from lib/prompts/query-suggestor
• Update lib/agents/resolution-search.tsx: import factory from lib/prompts/resolution-search, replace local template
• For inquire.tsx: import the placeholder prompt (actual prompt authoring is out of scope)

Task 5: Update Hardcoded Response Handling

Replace inline hardcoded responses in actions with the centralized module.

• Update app/actions.tsx lines 230-299: import getPreconfiguredResponse from lib/prompts/preconfigured-responses
• Replace the inline if-statement with a call to the helper function
• Simplify the conditional block to use the returned response or continue to agent pipeline

🤖 Prompt for AI agents

Connect the centralized prompt module to the agent pipeline and fix the
authentication bug that prevents custom prompts from loading. Changes span
`app/actions.tsx` and all six agent files under `lib/agents/`.

- In `app/actions.tsx`:
- Fix the authentication bug at lines 400-401: replace hardcoded `const userId =
'anonymous'` with `const userId = await getCurrentUserIdOnServer()`; import
`getCurrentUserIdOnServer` from `lib/auth/get-current-user`
- Add null handling for `userId` following the same pattern used in
`onSetAIState` (lines 640-653)
- At lines 230-299: import `getPreconfiguredResponse` from
`lib/prompts/preconfigured-responses`, replace the inline if-statement block
with a call to `getPreconfiguredResponse`, and simplify the conditional to use
the returned response or continue to the agent pipeline

- In `lib/agents/researcher.tsx`:
  - Remove the local `getDefaultSystemPrompt` function definition
  - Import the default prompt factory from `lib/prompts/researcher`
- Keep the existing `dynamicSystemPrompt` parameter signature for backward
compatibility
- Update the fallback logic to use the imported factory when
`dynamicSystemPrompt` is empty

- In `lib/agents/writer.tsx`:
  - Remove the local `default_system_prompt` constant
  - Import the default from `lib/prompts/writer`
- Maintain the existing override logic (lines 32-37) using the imported default

- In `lib/agents/task-manager.tsx`: import prompt from
`lib/prompts/task-manager` and replace the inline string in the `generateObject`
call
- In `lib/agents/query-suggestor.tsx`: import prompt from
`lib/prompts/query-suggestor` and replace the inline string
- In `lib/agents/resolution-search.tsx`: import the factory from
`lib/prompts/resolution-search` and replace the local template
- In `lib/agents/inquire.tsx`: import the placeholder prompt from
`lib/prompts/inquire`

Phase 3: Extend Database and Settings UI

Enable per-agent prompt customization through schema extension and UI enhancements.

Task 1: Extend Database Schema

Add agent-type support to the existing but unused systemPrompts table.

• Update lib/db/schema.ts: add agentType: text('agent_type').notNull().default('researcher') column to systemPrompts table
• Add a composite unique constraint on (userId, agentType) to enforce one prompt per agent per user
• Create migration drizzle/migrations/0002_system_prompts_agent_type.sql with CREATE TABLE IF NOT EXISTS for system_prompts including the new column (since table was never migrated)
• Update drizzle/migrations/meta/_journal.json to register the new migration

Task 2: Create Per-Agent Prompt Actions

Add server actions for CRUD operations on per-agent prompts.

• Update lib/actions/chat.ts: add saveAgentPrompt(userId, agentType, prompt) function that upserts to systemPrompts table
• Add getAgentPrompt(userId, agentType) function that queries by userId and agentType
• Add getAllAgentPrompts(userId) function that returns all custom prompts for a user as a map
• Deprecate or redirect existing saveSystemPrompt/getSystemPrompt to use the new functions with agentType='researcher' for backward compatibility

Task 3: Create Agent Prompt Form Component

Build a reusable form component for editing individual agent prompts.

• Create components/settings/components/agent-prompt-form.tsx with props for agentType, defaultPrompt, and form field binding
• Include a "View Default" button/toggle that displays the system default prompt for reference
• Reuse the character counter pattern from the existing system-prompt-form.tsx
• Add a "Reset to Default" action per agent

Task 4: Update Settings UI with Agent Tabs

Extend the settings component to support per-agent prompt configuration.

• Update components/settings/components/settings.tsx: expand the system-prompt tab content to include sub-navigation or accordion sections for each agent type
• Display agents in logical groups: Primary (Researcher, Writer), Routing (Task Manager, Inquire), Utility (Query Suggestor, Resolution Search)
• Update the form schema to include fields for each agent type's prompt
• Modify onSubmit to call saveAgentPrompt for each modified agent prompt
• Update useEffect data fetching to load all agent prompts via getAllAgentPrompts

Task 5: Connect Pipeline to Per-Agent Prompts

Update the action pipeline to fetch and use per-agent prompts.

• Update app/actions.tsx processEvents(): replace single getSystemPrompt call with fetches for each agent type as needed
• Pass appropriate prompts to each agent: researcher prompt to researcher(), writer prompt to writer(), etc.
• Consider lazy loading: only fetch the prompt for an agent when that agent is about to be called
• Update lib/prompts/get-prompt.ts to integrate with the new getAgentPrompt action

🤖 Prompt for AI agents

Extend the database schema to support per-agent prompts, add server actions for
CRUD operations, build a reusable settings UI component for per-agent prompt
editing, and wire the pipeline to fetch and use per-agent prompts.

- In `lib/db/schema.ts`:
- Add `agentType: text('agent_type').notNull().default('researcher')` column to
the `systemPrompts` table
  - Add a composite unique constraint on `(userId, agentType)`

- Create migration `drizzle/migrations/0002_system_prompts_agent_type.sql`:
- Use `CREATE TABLE IF NOT EXISTS` for `system_prompts` including the new
`agent_type` column (table was never previously migrated)
  - Update `drizzle/migrations/meta/_journal.json` to register the new migration

- In `lib/actions/chat.ts`:
- Add `saveAgentPrompt(userId, agentType, prompt)` — upserts to `systemPrompts`
table
  - Add `getAgentPrompt(userId, agentType)` — queries by userId and agentType
- Add `getAllAgentPrompts(userId)` — returns all custom prompts for a user as a
map
- Deprecate or redirect existing `saveSystemPrompt`/`getSystemPrompt` to use the
new functions with `agentType='researcher'` for backward compatibility

- Create `components/settings/components/agent-prompt-form.tsx`:
  - Props: `agentType`, `defaultPrompt`, and form field binding
- Include a "View Default" button/toggle to display the system default prompt
for reference
  - Reuse the character counter pattern from `system-prompt-form.tsx`
  - Include a "Reset to Default" action per agent

- Update `components/settings/components/settings.tsx`:
- Expand the `system-prompt` tab content with sub-navigation or accordion
sections for each agent type
- Group agents as: Primary (Researcher, Writer), Routing (Task Manager,
Inquire), Utility (Query Suggestor, Resolution Search)
  - Update the form schema to include fields for each agent type's prompt
  - Modify `onSubmit` to call `saveAgentPrompt` for each modified agent prompt
- Update `useEffect` data fetching to load all agent prompts via
`getAllAgentPrompts`

- Update `app/actions.tsx` `processEvents()`:
- Replace the single `getSystemPrompt` call with per-agent-type fetches as
needed
- Pass the appropriate prompt to each agent call (researcher prompt →
`researcher()`, writer prompt → `writer()`, etc.)
- Apply lazy loading: fetch each agent's prompt only when that agent is about to
be called
- Update `lib/prompts/get-prompt.ts` to integrate with the new `getAgentPrompt`
action

Research

The QCX codebase uses a multi-agent architecture where prompts are currently scattered across six agent files (researcher.tsx, task-manager.tsx, writer.tsx, inquire.tsx, query-suggestor.tsx, resolution-search.tsx). The researcher and writer agents accept a dynamicSystemPrompt parameter and fall back to internal defaults, while other agents have hardcoded inline prompts. The settings UI (components/settings/) provides a single system prompt textarea that saves to the users.systemPrompt column, but there's a critical bug where app/actions.tsx hardcodes userId = 'anonymous' instead of fetching the authenticated user, making the custom prompt feature non-functional. An unused systemPrompts table exists in the schema that could support per-agent prompt storage.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Create a new centralized prompt module under `lib/prompts/`. The goal is to
establish a single source of truth for all agent prompts by extracting scattered
inline prompts from agent files into dedicated files with a consistent
structure.

- Create `lib/prompts/types.ts`:
- Define an `AgentType` enum with values: `researcher`, `taskManager`, `writer`,
`inquire`, `querySuggestor`, `resolutionSearch`
- Define TypeScript interfaces for prompt configuration, template variable
types, and prompt factory signatures

- Create individual prompt files by extracting prompts from their respective
agent files:
- `lib/prompts/researcher.ts` — extract `getDefaultSystemPrompt` from
`lib/agents/researcher.tsx` (lines 20-80); export as a factory function
accepting `date` and `drawnFeatures` parameters
- `lib/prompts/task-manager.ts` — extract inline system prompt from
`lib/agents/task-manager.tsx` (lines 20-46); export as a constant
- `lib/prompts/writer.ts` — extract `default_system_prompt` from
`lib/agents/writer.tsx` (lines 22-30); export as a constant
- `lib/prompts/query-suggestor.ts` — extract inline prompt from
`lib/agents/query-suggestor.tsx` (lines 22-35); export as a constant
- `lib/prompts/resolution-search.ts` — extract template from
`lib/agents/resolution-search.tsx` (lines 53-74); export as a factory accepting
`timezone`, `location`, `drawnFeatures`
- `lib/prompts/inquire.ts` — create a placeholder prompt (actual authoring is
out of scope)

- Create `lib/prompts/preconfigured-responses.ts`:
  - Define a map of trigger phrases to response content
- Include enhanced responses with actionable suggestions (e.g., "Try asking me
to: Analyze satellite imagery...")
- Include responses for both "what is a planet computer?" and "what is
qcx-terra?"
- Export `getPreconfiguredResponse(userInput: string): string | null` with
case-insensitive matching

- Create `lib/prompts/get-prompt.ts`:
  - Export an async function `getAgentPrompt(agentType, userId, templateVars?)` 
- Logic: fetch user's custom prompt for the agent from DB → if exists and
non-empty, return it; otherwise fall back to the default from the centralized
module
- Support template variable injection for prompts that require dynamic values
(date, drawnFeatures, etc.)

- Create `lib/prompts/index.ts` as the main entry point that re-exports all
prompt factories and utilities from the above files
===============================================================================

Task: 2

Connect the centralized prompt module to the agent pipeline and fix the
authentication bug that prevents custom prompts from loading. Changes span
`app/actions.tsx` and all six agent files under `lib/agents/`.

- In `app/actions.tsx`:
- Fix the authentication bug at lines 400-401: replace hardcoded `const userId =
'anonymous'` with `const userId = await getCurrentUserIdOnServer()`; import
`getCurrentUserIdOnServer` from `lib/auth/get-current-user`
- Add null handling for `userId` following the same pattern used in
`onSetAIState` (lines 640-653)
- At lines 230-299: import `getPreconfiguredResponse` from
`lib/prompts/preconfigured-responses`, replace the inline if-statement block
with a call to `getPreconfiguredResponse`, and simplify the conditional to use
the returned response or continue to the agent pipeline

- In `lib/agents/researcher.tsx`:
  - Remove the local `getDefaultSystemPrompt` function definition
  - Import the default prompt factory from `lib/prompts/researcher`
- Keep the existing `dynamicSystemPrompt` parameter signature for backward
compatibility
- Update the fallback logic to use the imported factory when
`dynamicSystemPrompt` is empty

- In `lib/agents/writer.tsx`:
  - Remove the local `default_system_prompt` constant
  - Import the default from `lib/prompts/writer`
- Maintain the existing override logic (lines 32-37) using the imported default

- In `lib/agents/task-manager.tsx`: import prompt from
`lib/prompts/task-manager` and replace the inline string in the `generateObject`
call
- In `lib/agents/query-suggestor.tsx`: import prompt from
`lib/prompts/query-suggestor` and replace the inline string
- In `lib/agents/resolution-search.tsx`: import the factory from
`lib/prompts/resolution-search` and replace the local template
- In `lib/agents/inquire.tsx`: import the placeholder prompt from
`lib/prompts/inquire`
===============================================================================

Task: 3

Extend the database schema to support per-agent prompts, add server actions for
CRUD operations, build a reusable settings UI component for per-agent prompt
editing, and wire the pipeline to fetch and use per-agent prompts.

- In `lib/db/schema.ts`:
- Add `agentType: text('agent_type').notNull().default('researcher')` column to
the `systemPrompts` table
  - Add a composite unique constraint on `(userId, agentType)`

- Create migration `drizzle/migrations/0002_system_prompts_agent_type.sql`:
- Use `CREATE TABLE IF NOT EXISTS` for `system_prompts` including the new
`agent_type` column (table was never previously migrated)
  - Update `drizzle/migrations/meta/_journal.json` to register the new migration

- In `lib/actions/chat.ts`:
- Add `saveAgentPrompt(userId, agentType, prompt)` — upserts to `systemPrompts`
table
  - Add `getAgentPrompt(userId, agentType)` — queries by userId and agentType
- Add `getAllAgentPrompts(userId)` — returns all custom prompts for a user as a
map
- Deprecate or redirect existing `saveSystemPrompt`/`getSystemPrompt` to use the
new functions with `agentType='researcher'` for backward compatibility

- Create `components/settings/components/agent-prompt-form.tsx`:
  - Props: `agentType`, `defaultPrompt`, and form field binding
- Include a "View Default" button/toggle to display the system default prompt
for reference
  - Reuse the character counter pattern from `system-prompt-form.tsx`
  - Include a "Reset to Default" action per agent

- Update `components/settings/components/settings.tsx`:
- Expand the `system-prompt` tab content with sub-navigation or accordion
sections for each agent type
- Group agents as: Primary (Researcher, Writer), Routing (Task Manager,
Inquire), Utility (Query Suggestor, Resolution Search)
  - Update the form schema to include fields for each agent type's prompt
  - Modify `onSubmit` to call `saveAgentPrompt` for each modified agent prompt
- Update `useEffect` data fetching to load all agent prompts via
`getAllAgentPrompts`

- Update `app/actions.tsx` `processEvents()`:
- Replace the single `getSystemPrompt` call with per-agent-type fetches as
needed
- Pass the appropriate prompt to each agent call (researcher prompt →
`researcher()`, writer prompt → `writer()`, etc.)
- Apply lazy loading: fetch each agent's prompt only when that agent is about to
be called
- Update `lib/prompts/get-prompt.ts` to integrate with the new `getAgentPrompt`
action

💡 Iterate on the plan with: @coderabbitai <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!