@mndrk/agx 1.4.61 → 1.4.63

package/lib/cli/runCli.js

@@ -72,6 +72,7 @@ const { handleSkillCommand } = require('./skills');
 const { runOnboarding, showConfigStatus, runConfigMenu } = require('./onboarding');
 const { runInteractiveMenu } = require('./interactiveMenu');
 const cloudArtifacts = require('./cloudArtifacts');
+const { sendWebhookEvent } = require('../notifications/webhooks');
 const fallbackExtractSection = (markdown, heading) => {
   if (!markdown) return '';
   const pattern = new RegExp(`^##\\s+${heading}\\s*$`, 'im');
@@ -100,6 +101,9 @@ const {
 } = require('./util');
 const { createCloudRunner } = require('./cloud');
 const daemon = require('./daemon');
+const { loadTemplate, renderTemplateContent } = require('../templates');
+const { applyTemplateDefaults } = require('./templateDefaults');
+const { slugify } = require('../storage/paths');
 const {
   DAEMON_PID_FILE,
   DAEMON_LOG_FILE,
@@ -1045,6 +1049,44 @@ async function checkOnboarding() {
       localArtifacts && lastRun ? `(Local run id: ${lastRun.run_id}, stage: ${lastRun.stage})` : '',
     ].filter(Boolean).join('\n'));
 
+    const stageName = completionResult?.newStage
+      || completionResult?.task?.stage
+      || task?.stage
+      || null;
+    const statusRaw = completionResult?.task?.status ?? task?.status ?? null;
+    const eventPayload = {
+      taskId,
+      taskSlug: task?.slug || null,
+      projectSlug: task?.project_slug || task?.project?.slug || null,
+      stage: stageName,
+      stageLocal,
+      status: statusRaw,
+      decision: decisionPayload.decision,
+      summary: decisionPayload.summary || null,
+      final_result: decisionPayload.final_result || null,
+      run_id: lastRun?.run_id || null,
+      duration_ms: Date.now() - taskStart,
+    };
+    const emitWebhook = async (eventName) => {
+      try {
+        await sendWebhookEvent(eventName, eventPayload);
+      } catch (err) {
+        const message = err?.message || String(err);
+        logger.log('error', `[daemon] webhook ${eventName} failed: ${message}\n`);
+      }
+    };
+
+    await emitWebhook('task.stage_complete');
+    if (decisionPayload.decision === 'failed') {
+      await emitWebhook('task.failed');
+    } else if (decisionPayload.decision === 'blocked') {
+      await emitWebhook('task.blocked');
+    }
+    const normalizedStatus = typeof statusRaw === 'string' ? statusRaw.trim().toLowerCase() : '';
+    if (normalizedStatus === 'completed' || (decisionPayload.decision === 'done' && String(stageName || '').toLowerCase() === 'done')) {
+      await emitWebhook('task.completed');
+    }
+
     {
       const detailRaw = String(decisionPayload.summary || decisionPayload.explanation || '').trim();
       const detail = detailRaw ? detailRaw.replace(/\s+/g, ' ').slice(0, 320) : '';
@@ -1185,29 +1227,29 @@ async function checkOnboarding() {
   // ============================================================
 
   // Provider aliases for convenience
-const PROVIDER_ALIASES = {
-  'c': 'claude', 'cl': 'claude', 'claude': 'claude',
-  'x': 'codex', 'codex': 'codex',
-  'g': 'gemini', 'gem': 'gemini', 'gemini': 'gemini',
-  'o': 'ollama', 'ol': 'ollama', 'ollama': 'ollama'
-};
-
-function collectFlagValues(args, flag) {
-  const values = [];
-  const consumedIndices = new Set();
-  for (let i = 0; i < args.length; i += 1) {
-    if (args[i] === flag) {
-      consumedIndices.add(i);
-      const next = args[i + 1];
-      if (typeof next === 'string' && next.length) {
-        values.push(next);
-        consumedIndices.add(i + 1);
+  const PROVIDER_ALIASES = {
+    'c': 'claude', 'cl': 'claude', 'claude': 'claude',
+    'x': 'codex', 'codex': 'codex',
+    'g': 'gemini', 'gem': 'gemini', 'gemini': 'gemini',
+    'o': 'ollama', 'ol': 'ollama', 'ollama': 'ollama'
+  };
+
+  function collectFlagValues(args, flag) {
+    const values = [];
+    const consumedIndices = new Set();
+    for (let i = 0; i < args.length; i += 1) {
+      if (args[i] === flag) {
+        consumedIndices.add(i);
+        const next = args[i + 1];
+        if (typeof next === 'string' && next.length) {
+          values.push(next);
+          consumedIndices.add(i + 1);
+        }
+        i += 1;
       }
-      i += 1;
     }
+    return { values, consumedIndices };
   }
-  return { values, consumedIndices };
-}
 
   // ============================================================
   // LOCAL-FIRST CLI COMMANDS
@@ -1223,6 +1265,12 @@ function collectFlagValues(args, flag) {
     if (handled) return true;
   }
 
+  {
+    const { maybeHandleTemplateCommand } = require('../commands/templates');
+    const handled = await maybeHandleTemplateCommand({ cmd, args, ctx: { c } });
+    if (handled) return true;
+  }
+
   // Local-first command handlers live in lib/commands/local.js.
 
   // ============================================================
@@ -1250,6 +1298,7 @@ function collectFlagValues(args, flag) {
         process.exit(1);
       }
     }
+    const providerArgProvided = provider !== null;
 
     // Parse --model / -m
     let model = null;
@@ -1257,6 +1306,7 @@ function collectFlagValues(args, flag) {
     if (modelIdx !== -1 && args[modelIdx + 1]) {
       model = args[modelIdx + 1];
     }
+    const modelArgProvided = model !== null;
     let projectSlug = null;
     const projectIdx = args.findIndex(a => a === '--project');
     if (projectIdx !== -1 && args[projectIdx + 1]) {
@@ -1288,15 +1338,26 @@ function collectFlagValues(args, flag) {
       const resolvedType = normalizeTicketType(args[ticketTypeIdx + 1]);
       ticketType = resolvedType === 'spike' ? 'spike' : 'task';
     }
-
-    // Default provider from config
-    if (!provider) {
-      const config = loadConfig();
-      provider = config?.defaultProvider || 'claude';
+    let templateName = null;
+    const templateIdx = args.findIndex(a => a === '--template');
+    if (templateIdx !== -1 && args[templateIdx + 1]) {
+      templateName = args[templateIdx + 1];
     }
 
     // Extract goal text (filter out flags)
-    const flagsToRemove = ['--json', '--run', '-r', '--provider', '-P', '--model', '-m', '--project', '--type', '--ticket-type'];
+    const flagsToRemove = [
+      '--json',
+      '--run',
+      '-r',
+      '--provider',
+      '-P',
+      '--model',
+      '-m',
+      '--project',
+      '--type',
+      '--ticket-type',
+      '--template',
+    ];
     const goalParts = [];
     for (let i = 1; i < args.length; i++) {
       if (dependsOnSkipIndices.has(i)) {
@@ -1307,11 +1368,12 @@ function collectFlagValues(args, flag) {
         if (args[i] === '--model' || args[i] === '-m') i++;
         if (args[i] === '--project') i++;
         if (args[i] === '--type' || args[i] === '--ticket-type') i++;
+        if (args[i] === '--template') i++;
         continue;
       }
       goalParts.push(args[i]);
     }
-    const goalText = goalParts.join(' ');
+    const goalText = goalParts.join(' ').trim();
 
     if (!goalText) {
       if (jsonMode) {
@@ -1322,6 +1384,33 @@ function collectFlagValues(args, flag) {
       process.exit(1);
     }
 
+    let template = null;
+    if (templateName) {
+      try {
+        template = await loadTemplate(templateName);
+      } catch (err) {
+        const message = err?.message || `Template "${templateName}" not found`;
+        if (jsonMode) {
+          console.log(JSON.stringify({ error: message }));
+        } else {
+          console.log(`${c.red}✗${c.reset} ${message}`);
+        }
+        process.exit(1);
+      }
+    }
+
+    const config = loadConfig();
+    const defaults = applyTemplateDefaults({
+      provider,
+      model,
+      template,
+      providerArgProvided,
+      modelArgProvided,
+      defaultProvider: config?.defaultProvider || 'claude',
+    });
+    provider = defaults.provider;
+    model = defaults.model;
+
     try {
       let projectId = null;
       if (projectSlug) {
@@ -1348,8 +1437,25 @@ function collectFlagValues(args, flag) {
       if (projectId) frontmatter.push(`project_id: ${projectId}`);
       if (model) frontmatter.push(`model: ${model}`);
       if (ticketType) frontmatter.push(`type: ${ticketType}`);
-
-      const content = `---\n${frontmatter.join('\n')}\n---\n\n# ${goalText}\n`;
+      if (template) frontmatter.push(`template: ${template.slug}`);
+
+      let bodyContent = `# ${goalText}\n`;
+      if (template) {
+        const rendered = renderTemplateContent(template.content, {
+          title: goalText,
+          goal: goalText,
+          slug: slugify(goalText, { maxLength: 64 }),
+          project: projectSlug || '',
+          template: template.slug,
+        });
+        if (rendered && rendered.trim()) {
+          bodyContent = rendered;
+        }
+      }
+      if (!bodyContent.endsWith('\n')) {
+        bodyContent += '\n';
+      }
+      const content = `---\n${frontmatter.join('\n')}\n---\n\n${bodyContent}`;
 
       const payload = { content };
       if (dependsOnValues.length) {
@@ -1764,7 +1870,7 @@ function collectFlagValues(args, flag) {
     }
   }
 
-  // agx task ls [-a]  (Docker-style namespace)
+  // agx task ls [-a] [search] (Docker-style namespace)
   if ((cmd === 'task' && args[1] === 'ls') || cmd === 'list' || cmd === 'ls' || cmd === 'tasks') {
     const showAll = args.includes('-a') || args.includes('--all');
     const config = loadCloudConfig();
@@ -1773,10 +1879,42 @@ function collectFlagValues(args, flag) {
       process.exit(1);
     }
 
+    // Extract search term
+    const flagsToSkip = ['-a', '--all'];
+    const cmdTokens = (cmd === 'task' && args[1] === 'ls') ? ['task', 'ls'] : [cmd];
+    const searchParts = args.filter((arg, i) => {
+      // Skip flags
+      if (arg.startsWith('-')) return false;
+      // Skip command words (simple heuristic: first occurrence of cmd words)
+      // Actually simpler: iterate args, skip known command words at start.
+      return true;
+    });
+
+    // Better extraction:
+    let startIndex = (cmd === 'task' && args[1] === 'ls') ? 2 : 1;
+    let search = '';
+    const searchTerms = [];
+    for (let i = startIndex; i < args.length; i++) {
+      if (!args[i].startsWith('-')) {
+        searchTerms.push(args[i]);
+      }
+    }
+    if (searchTerms.length > 0) {
+      search = searchTerms.join(' ');
+    }
+
     try {
-      const { tasks } = await cloudRequest('GET', '/api/tasks');
+      let url = '/api/tasks';
+      if (search) {
+        url += `?search=${encodeURIComponent(search)}`;
+      }
+      const { tasks } = await cloudRequest('GET', url);
       if (tasks.length === 0) {
-        console.log(`${c.dim}No tasks in queue${c.reset}`);
+        if (search) {
+           console.log(`${c.dim}No tasks found matching "${search}"${c.reset}`);
+        } else {
+           console.log(`${c.dim}No tasks in queue${c.reset}`);
+        }
         process.exit(0);
       }
 
@@ -2330,7 +2468,7 @@ function collectFlagValues(args, flag) {
         if (config?.token) {
           esOptions.headers = { Authorization: `Bearer ${config.token}` };
         }
-        const streamUrl = `${config.apiUrl}/api/logs/stream?taskId=${encodeURIComponent(taskId)}`;
+        const streamUrl = `${config.apiUrl}/api/tasks/${encodeURIComponent(taskId)}/logs/stream`;
         const es = new EventSource(streamUrl, esOptions);
 
         es.onmessage = (event) => {
@@ -2732,6 +2870,117 @@ function collectFlagValues(args, flag) {
     process.exit(0);
   }
 
+  // ============================================================
+  // agx feedback - Quick bug reports with context
+  // ============================================================
+  if (cmd === 'feedback') {
+    const readline = require('readline');
+    const { exec, execSync } = require('child_process');
+    
+    // Get description from args or prompt
+    let description = args.slice(1).join(' ');
+    if (!description) {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      description = await new Promise(resolve => {
+        rl.question(`${c.cyan}What went wrong?${c.reset} `, answer => {
+          rl.close();
+          resolve(answer.trim());
+        });
+      });
+    }
+    
+    if (!description) {
+      console.log(`${c.yellow}No description provided. Aborting.${c.reset}`);
+      process.exit(1);
+    }
+    
+    console.log(`\n${c.dim}Collecting context...${c.reset}`);
+    
+    // Collect system info
+    const version = (() => { try { return require('../../package.json').version; } catch { return 'unknown'; } })();
+    const nodeVersion = process.version;
+    const platform = `${os.platform()} ${os.arch()}`;
+    
+    // Collect recent daemon logs (sanitized)
+    let recentLogs = '';
+    const logDir = path.join(os.homedir(), '.agx', 'logs');
+    try {
+      const logFiles = fs.readdirSync(logDir).filter(f => f.endsWith('.log')).sort().reverse();
+      if (logFiles.length > 0) {
+        const latestLog = fs.readFileSync(path.join(logDir, logFiles[0]), 'utf8');
+        const lines = latestLog.split('\n').slice(-30).join('\n');
+        // Sanitize: remove potential secrets, paths with usernames
+        recentLogs = lines
+          .replace(/\/Users\/[^\/\s]+/g, '/Users/***')
+          .replace(/\/home\/[^\/\s]+/g, '/home/***')
+          .replace(/sk-[a-zA-Z0-9]+/g, 'sk-***')
+          .replace(/key["\s:=]+[a-zA-Z0-9]+/gi, 'key=***');
+      }
+    } catch { }
+    
+    // Build issue body
+    const issueTitle = description.length > 60 ? description.substring(0, 60) + '...' : description;
+    const issueBody = `## Description
+${description}
+
+## Environment
+- **agx version:** ${version}
+- **Node.js:** ${nodeVersion}
+- **Platform:** ${platform}
+
+## Recent Logs
+\`\`\`
+${recentLogs || 'No logs available'}
+\`\`\`
+
+---
+*Submitted via \`agx feedback\`*`;
+
+    // Try gh CLI first
+    let ghAvailable = false;
+    try {
+      execSync('gh --version', { stdio: 'ignore' });
+      ghAvailable = true;
+    } catch { }
+    
+    const repoUrl = 'https://github.com/ramarlina/agx';
+    
+    if (ghAvailable) {
+      console.log(`${c.dim}Using GitHub CLI...${c.reset}`);
+      try {
+        const result = execSync(
+          `gh issue create --repo ramarlina/agx --title "${issueTitle.replace(/"/g, '\\"')}" --body "${issueBody.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`,
+          { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+        );
+        console.log(`\n${c.green}✓${c.reset} Issue created: ${result.trim()}`);
+      } catch (err) {
+        console.log(`${c.yellow}GitHub CLI failed, opening browser instead...${c.reset}`);
+        ghAvailable = false;
+      }
+    }
+    
+    if (!ghAvailable) {
+      // Fall back to opening browser with pre-filled URL
+      const params = new URLSearchParams({
+        title: issueTitle,
+        body: issueBody,
+        labels: 'bug,user-feedback'
+      });
+      const issueUrl = `${repoUrl}/issues/new?${params.toString()}`;
+      
+      const openCmd = os.platform() === 'darwin' ? 'open' : os.platform() === 'win32' ? 'start' : 'xdg-open';
+      try {
+        execSync(`${openCmd} "${issueUrl}"`, { stdio: 'ignore' });
+        console.log(`\n${c.green}✓${c.reset} Opened GitHub issue form in browser`);
+      } catch {
+        console.log(`\n${c.cyan}Open this URL to submit:${c.reset}\n${issueUrl}`);
+      }
+    }
+    
+    console.log(`\n${c.dim}Thanks for the feedback! 🙏${c.reset}`);
+    process.exit(0);
+  }
+
   // ============================================================
   // agx telemetry - Manage anonymous usage telemetry
   // ============================================================

package/lib/cli/skillText.js

@@ -1,60 +1,5 @@
 // agx skill - instructions for LLMs on how to use agx
 
-const AGX_SKILL = `---
-name: agx
-description: Task orchestrator for AI agents. Uses cloud API for persistence.
----
-
-# agx - AI Agent Task Orchestrator
-
-agx manages tasks and coordinates AI agents. Uses cloud API for persistence.
-
-## Quick Start
-
-\`\`\`bash
-agx -a -p "Build a REST API"  # Autonomous: works until done
-agx -p "explain this code"     # One-shot question
-\`\`\`
-
-## Task Lifecycle
-
-\`\`\`bash
-agx new "goal"          # Create task
-agx run [task]          # Run a task
-agx complete <taskId>   # Mark task stage complete
-agx status <taskId>     # Show detailed info for a specific task
-agx status              # Show current status
-\`\`\`
-
-## Checking Tasks
-
-\`\`\`bash
-agx task ls             # List tasks
-agx task logs <id> [-f] # View/tail task logs
-agx task tail <id>      # Tail task logs
-agx comments tail <id>  # Tail task comments
-agx logs tail <id>      # Tail task logs
-agx watch               # Watch task updates in real-time (SSE)
-\`\`\`
-
-## Cloud
-
-\`\`\`bash
-AGX_CLOUD_URL=http://localhost:41741 agx status
-AGX_CLOUD_URL=http://localhost:41741 agx task ls
-agx daemon start  # Start local daemon
-\`\`\`
-
-## Providers
-
-claude (c), gemini (g), ollama (o), codex (x)
-
-## Key Flags
-
--a  Autonomous mode (daemon + work until done)
--p  Prompt/goal
--y  Skip confirmations (implied by -a)
--P, --provider <c|g|o|x>  Provider for new task (claude/gemini/ollama/codex)
-`;
+const { AGX_SKILL } = require('../prompts/templates');
 
 module.exports = { AGX_SKILL };

package/lib/cli/templateDefaults.js

@@ -0,0 +1,22 @@
+'use strict';
+
+function applyTemplateDefaults({
+    provider,
+    model,
+    template,
+    providerArgProvided,
+    modelArgProvided,
+    defaultProvider,
+}) {
+    let resolvedProvider = provider;
+    if (!providerArgProvided) {
+        resolvedProvider = template?.provider || defaultProvider || 'claude';
+    }
+    let resolvedModel = model;
+    if (!modelArgProvided) {
+        resolvedModel = template?.model || model;
+    }
+    return { provider: resolvedProvider, model: resolvedModel };
+}
+
+module.exports = { applyTemplateDefaults };

package/lib/commands/templates.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { listTemplates, createTemplate, getTemplatesDir } = require('../templates');
+
+function getFlagValue(args, flag) {
+    const idx = args.findIndex(a => a === flag);
+    if (idx === -1) return null;
+    return args[idx + 1] || null;
+}
+
+async function maybeHandleTemplateCommand({ cmd, args, ctx }) {
+    if (cmd !== 'templates') {
+        return false;
+    }
+    const { c } = ctx || {};
+    const subcommand = args[1];
+
+    switch (subcommand) {
+        case 'list':
+        case 'ls': {
+            const templates = await listTemplates();
+            if (args.includes('--json')) {
+                console.log(JSON.stringify({ templates }));
+                process.exit(0);
+            }
+            console.log(`${c?.bold || ''}Templates (${templates.length})${c?.reset || ''}`);
+            console.log(`Directory: ${getTemplatesDir()}`);
+            if (!templates.length) {
+                console.log('  No templates found. Use `agx templates create <name>` to add one.');
+                process.exit(0);
+            }
+            console.log('');
+            for (const template of templates) {
+                const info = [];
+                if (template.description) info.push(template.description);
+                if (template.provider) info.push(`provider=${template.provider}`);
+                if (template.model) info.push(`model=${template.model}`);
+                const displayName = template.name === template.slug
+                    ? template.slug
+                    : `${template.name} (${template.slug})`;
+                console.log(`  ${displayName}${info.length ? `  (${info.join(', ')})` : ''}`);
+            }
+            process.exit(0);
+        }
+        case 'create': {
+            const name = args[2];
+            if (!name) {
+                console.log('Usage: agx templates create <name> [--description "desc"] [--provider claude] [--model claude-sonnet-4-5] [--content-file ./template.md]');
+                process.exit(1);
+            }
+
+            const description = getFlagValue(args, '--description');
+            const provider = getFlagValue(args, '--provider');
+            const model = getFlagValue(args, '--model');
+            const contentInline = getFlagValue(args, '--content');
+            const contentFile = getFlagValue(args, '--content-file');
+            let content = contentInline;
+            if (!content && contentFile) {
+                try {
+                    content = await fs.promises.readFile(path.resolve(contentFile), 'utf8');
+                } catch (err) {
+                    console.log(`${c?.red || ''}Error:${c?.reset || ''} Could not read content file: ${err.message}`);
+                    process.exit(1);
+                }
+            }
+
+            const created = await createTemplate({ name, description, provider, model, content });
+            console.log(`${c?.green || ''}✓${c?.reset || ''} Template created: ${created.slug}`);
+            console.log(`  Path: ${created.file}`);
+            process.exit(0);
+        }
+        default:
+            console.log(`Template Commands:
+  agx templates list   List available templates
+  agx templates create <name>  Scaffold a new template file (options: --description, --provider, --model, --content-file)
+`);
+            process.exit(0);
+    }
+}
+
+module.exports = { maybeHandleTemplateCommand };

package/lib/executor.js

@@ -10,22 +10,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { commandExists } = require('./proc/commandExists');
-
-const DEFAULT_STAGE_PROMPT = 'Execute this stage using the latest stage prompt from the cloud task context.';
-
-const PROJECT_CONTEXT = [
-  'AGX orchestrates autonomous AI agents with tasks defined via `agx new` and managed through `agx run`, `agx tasks`, `agx status`, and `agx context` so agents can wake, work, and sleep across sessions.',
-  'Task state lives in the cloud API (goal, criteria, progress, learnings) along with the orchestration worker (pg-boss); `agx info`/`agx context` expose structured project metadata.',
-  'Quick-start workflow: `agx new "<goal>"`, optionally `agx -a -p "<goal>"` for autonomous execution, then use `agx run`, `agx tasks`, `agx status`, and `agx context` to manage work.',
-  'Task management commands include `agx task ls`, `agx task logs`, `agx task stop`, `agx task rm`, `agx complete`, `agx pull`.',
-  'Daemon mode runs via `agx daemon start/stop/status/logs` so agents can poll for work continuously.',
-  'Providers: `agx claude` (alias `c`), `agx gemini` (alias `g`), and `agx ollama` (alias `o`).',
-  'Key flags: `-a/--autonomous`, `-p/--prompt`, `--prompt-file`, `-y/--yolo`, `--continue <task>`.',
-  'Key principles: persistent storage, criteria-driven completion, checkpoint often, ask when stuck, learn and adapt.',
-  'Agent workflow: orient on saved state, plan, execute, checkpoint, adapt to blockers, and report learnings.',
-  'State operations: define objectives via `agx new`, update learnings with `[learn: ...]`, mark completion via `agx complete`, and sync via `agx info`/`agx context`.',
-  'Project metadata: attach `--metadata key=value` and `--repo` info so `/api/projects` keeps structured context.',
-].join('\n');
+const { interpolate, DEFAULT_STAGE_PROMPT, PROJECT_CONTEXT, EXECUTOR_PROMPT } = require('./prompts/templates');
 
 // Engine configurations
 const ENGINES = {
@@ -238,30 +223,13 @@ async function executeTask(options) {
  * Build the full prompt for a stage
  */
 function buildPrompt(title, content, stage, stageConfig) {
-  return `# Task: ${title}
-
-## Stage: ${stage}
-
-${stageConfig.prompt}
-
-## Project Context
-
-${PROJECT_CONTEXT}
-
-## Task Details
-
-${content}
-
-## Instructions
-
-1. Complete the work for this stage
-2. Use [checkpoint: message] to save progress
-3. Use [learn: insight] to record learnings
-4. Use [done] when stage is complete
-5. Use [blocked: reason] if you need human help
-
-Focus on this stage only. The task will automatically advance to the next stage when complete.
-`;
+  return interpolate(EXECUTOR_PROMPT, {
+    title,
+    stage,
+    stagePrompt: stageConfig.prompt,
+    projectContext: PROJECT_CONTEXT,
+    content,
+  });
 }
 
 /**