@mndrk/agx 1.4.61 → 1.4.63

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/worker/index.js

@@ -11768,11 +11768,11 @@ var init_worker = __esm({
       loopDelayPromise = null;
       beenNotified = false;
       runPromise = null;
-      constructor({ id, name, options, interval, fetch, onFetch, onError }) {
+      constructor({ id, name, options, interval, fetch: fetch2, onFetch, onError }) {
         this.id = id;
         this.name = name;
         this.options = options;
-        this.fetch = fetch;
+        this.fetch = fetch2;
         this.onFetch = onFetch;
         this.onError = onError;
         this.interval = interval;
@@ -12181,7 +12181,7 @@ var init_manager = __esm({
         }
         const firstWorkerId = (0, import_node_crypto.randomUUID)({ disableEntropyCache: true });
         const createWorker = (workerId) => {
-          const fetch = () => {
+          const fetch2 = () => {
             const ignoreGroups = localGroupConcurrency != null ? this.#getGroupsAtLocalCapacity(name) : void 0;
             return this.fetch(name, { batchSize, includeMetadata, priority, orderByCreatedOn, groupConcurrency, ignoreGroups });
           };
@@ -12214,7 +12214,7 @@ var init_manager = __esm({
           const onError = (error) => {
             this.emit(events.error, { ...error, message: error.message, stack: error.stack, queue: name, worker: workerId });
           };
-          return new worker_default({ id: workerId, name, options, interval, fetch, onFetch, onError });
+          return new worker_default({ id: workerId, name, options, interval, fetch: fetch2, onFetch, onError });
         };
         for (let i = 0; i < localConcurrency; i++) {
           const workerId = i === 0 ? firstWorkerId : (0, import_node_crypto.randomUUID)({ disableEntropyCache: true });
@@ -18581,6 +18581,14 @@ var QueryBuilder = class {
             params.push(toSqlValue(value));
             return `${column} IS NOT DISTINCT FROM $${params.length}`;
           }
+          if (op === "ilike") {
+            params.push(toSqlValue(value));
+            return `${column} ILIKE $${params.length}`;
+          }
+          if (op === "like") {
+            params.push(toSqlValue(value));
+            return `${column} LIKE $${params.length}`;
+          }
           return "1=1";
         });
         if (clauses.length > 0) {
@@ -18872,8 +18880,129 @@ function isDependencyBlockedReason(reason) {
   return typeof reason === "string" && reason.startsWith(DEPENDENCY_BLOCKED_REASON_PREFIX);
 }
 
-// ../agx-cloud/lib/db.ts
+// ../agx-cloud/lib/notifications/constants.ts
+var NOTIFICATION_EVENT_OPTIONS = [
+  {
+    value: "task.created",
+    label: "Task created",
+    description: "Fires immediately when a new task is added to the queue."
+  },
+  {
+    value: "task.stage_complete",
+    label: "Stage completed",
+    description: "Emitted whenever a stage finishes and the task advances."
+  },
+  {
+    value: "task.completed",
+    label: "Task completed",
+    description: "When the task reaches a completed status (done)."
+  },
+  {
+    value: "task.failed",
+    label: "Task failed",
+    description: "When the task may have errored, including cancellations."
+  },
+  {
+    value: "task.blocked",
+    label: "Task blocked",
+    description: "When the agent raises the task as blocked awaiting manual input."
+  }
+];
+var NOTIFICATION_EVENT_VALUES = NOTIFICATION_EVENT_OPTIONS.map((option) => option.value);
+
+// ../agx-cloud/lib/notifications/index.ts
+var SchemaNotReadyError = class extends Error {
+};
 function isMissingRelationError(error, relation) {
+  if (!error || typeof error !== "object") return false;
+  const code = error.code;
+  const message = typeof error.message === "string" ? error.message : "";
+  return code === "42P01" || code === "PGRST205" || message.includes(`relation "${relation}" does not exist`) || message.includes(`Could not find the table 'agx.${relation}'`) || message.includes(`Could not find the table 'public.${relation}'`);
+}
+function mapWebhookRecord(raw) {
+  const events5 = Array.isArray(raw.events) ? raw.events.filter((value) => typeof value === "string").map((value) => value.trim()).filter(
+    (value) => NOTIFICATION_EVENT_VALUES.includes(value)
+  ) : [];
+  return {
+    id: String(raw.id),
+    user_id: String(raw.user_id),
+    url: String(raw.url),
+    name: raw.name != null ? String(raw.name) : null,
+    events: events5,
+    enabled: raw.enabled !== false,
+    created_at: String(raw.created_at),
+    updated_at: String(raw.updated_at)
+  };
+}
+async function handleRelationError(relation, error) {
+  if (isMissingRelationError(error, relation)) {
+    throw new SchemaNotReadyError(`Missing relation: ${relation}`);
+  }
+  throw error;
+}
+async function listNotificationWebhooks(userId) {
+  const db = createAdminDbClient();
+  const { data, error } = await db.from("notification_webhooks").select("*").eq("user_id", userId).order("created_at", { ascending: false });
+  if (error) {
+    await handleRelationError("notification_webhooks", error);
+  }
+  if (!data) return [];
+  return (Array.isArray(data) ? data : [data]).map(mapWebhookRecord);
+}
+async function notifyTaskEvent(payload) {
+  if (!payload.userId) return;
+  let endpoints = [];
+  try {
+    endpoints = await listNotificationWebhooks(payload.userId);
+  } catch (error) {
+    if (error instanceof SchemaNotReadyError) {
+      console.debug("[notifications] notification_webhooks schema not ready, skipping");
+      return;
+    }
+    console.error("[notifications] failed to load webhooks", error);
+    return;
+  }
+  const targets = endpoints.filter(
+    (endpoint) => endpoint.enabled && endpoint.events.includes(payload.eventType)
+  );
+  if (!targets.length) return;
+  const timestamp = payload.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  const body = {
+    eventType: payload.eventType,
+    taskId: payload.taskId,
+    userId: payload.userId,
+    title: payload.title || null,
+    slug: payload.slug || null,
+    stage: payload.stage || null,
+    previousStage: payload.previousStage || null,
+    nextStage: payload.nextStage || null,
+    status: payload.status || null,
+    error: payload.error || null,
+    timestamp,
+    details: payload.details || {}
+  };
+  await Promise.all(
+    targets.map(async (endpoint) => {
+      try {
+        const response = await fetch(endpoint.url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          console.error(
+            `[notifications] webhook ${endpoint.url} responded with ${response.status}`
+          );
+        }
+      } catch (error) {
+        console.error(`[notifications] failed to send to ${endpoint.url}`, error);
+      }
+    })
+  );
+}
+
+// ../agx-cloud/lib/db.ts
+function isMissingRelationError2(error, relation) {
   if (!error) return false;
   const message = typeof error.message === "string" ? error.message : "";
   return error.code === "42P01" || error.code === "PGRST205" || message.includes(`relation "${relation}" does not exist`) || message.includes(`Could not find the table 'agx.${relation}'`) || message.includes(`Could not find the table 'public.${relation}'`);
@@ -19084,13 +19213,36 @@ async function updateTask(id, content, userId, options) {
   }
   await ensureTaskDependencyState(data, userId);
   const refreshed = await getTask(data.id, userId);
-  return refreshed || data;
+  const taskRecord = refreshed || data;
+  const resolvedUserId = userId || taskRecord.user_id;
+  if (resolvedUserId) {
+    const eventTimestamp = taskRecord.created_at || (/* @__PURE__ */ new Date()).toISOString();
+    const details = {
+      dependsOn: Array.isArray(taskRecord.depends_on) ? taskRecord.depends_on : [],
+      project: taskRecord.project || null,
+      projectId: taskRecord.project_id || null,
+      workflowId: taskRecord.workflow_id || null,
+      createdBy: taskRecord.created_by || null
+    };
+    void notifyTaskEvent({
+      taskId: taskRecord.id,
+      userId: resolvedUserId,
+      eventType: "task.created",
+      title: taskRecord.title || null,
+      slug: taskRecord.slug || null,
+      stage: taskRecord.stage || null,
+      status: taskRecord.status || null,
+      timestamp: eventTimestamp,
+      details
+    });
+  }
+  return taskRecord;
 }
 async function getWorkflowNodes(workflowId) {
   const db = createAdminDbClient();
   const { data, error } = await db.from("workflow_nodes").select("*").eq("workflow_id", workflowId).order("position", { ascending: true });
   if (error) {
-    if (isMissingRelationError(error, "workflow_nodes")) return [];
+    if (isMissingRelationError2(error, "workflow_nodes")) return [];
     throw error;
   }
   return data || [];
@@ -19099,7 +19251,7 @@ async function getWorkflowNodeByName(workflowId, name) {
   const db = createAdminDbClient();
   const { data, error } = await db.from("workflow_nodes").select("*").eq("workflow_id", workflowId).eq("name", name).maybeSingle();
   if (error) {
-    if (isMissingRelationError(error, "workflow_nodes")) return null;
+    if (isMissingRelationError2(error, "workflow_nodes")) return null;
     throw error;
   }
   return data;
@@ -19108,7 +19260,7 @@ async function getWorkflowTransitionsFromNode(workflowId, fromNodeId) {
   const db = createAdminDbClient();
   const { data, error } = await db.from("workflow_transitions").select("*").eq("workflow_id", workflowId).eq("from_node_id", fromNodeId).order("priority", { ascending: true });
   if (error) {
-    if (isMissingRelationError(error, "workflow_transitions")) return [];
+    if (isMissingRelationError2(error, "workflow_transitions")) return [];
     throw error;
   }
   return data || [];
@@ -19135,6 +19287,24 @@ var DEFAULT_STAGE_SEQUENCE = [
   "done"
 ];
 var STANDARD_STAGE_SEQUENCES = [DEFAULT_STAGE_SEQUENCE];
+function normalizeTicketType(value) {
+  if (typeof value !== "string") return "task";
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "spike" || normalized === "spikes") return "spike";
+  return "task";
+}
+function getTicketType(frontmatter, markdownBody) {
+  const typeKeys = ["ticket_type", "type", "issue_type", "kind"];
+  for (const key of typeKeys) {
+    if (normalizeTicketType(frontmatter[key]) === "spike") return "spike";
+  }
+  const titleMatch = markdownBody.match(/^#\s+(.+)$/m);
+  const title = titleMatch?.[1]?.trim().toLowerCase() || "";
+  if (title.startsWith("spike:") || title.startsWith("[spike]")) {
+    return "spike";
+  }
+  return "task";
+}
 function getNextStage(currentStage, ticketType) {
   if (ticketType === "spike") {
     if (currentStage === "ideation") return "planning";
@@ -19334,6 +19504,131 @@ ${stringifyFrontmatter(frontmatter)}
 ${body}`;
 }
 
+// ../agx-cloud/lib/dependency-manager.ts
+var READY_STATUS = "completed";
+function describeDependency2(dep) {
+  return dep.title || dep.slug || dep.id || "(unknown)";
+}
+function summarizeRecord(record, id) {
+  if (!record) {
+    return { id: id || "" };
+  }
+  return {
+    id: record.id || id || "",
+    title: record.title || void 0,
+    slug: record.slug || void 0,
+    status: record.status,
+    stage: record.stage
+  };
+}
+async function fetchTasksByIds(ids, userId) {
+  if (!ids.length) return [];
+  const db = createAdminDbClient();
+  let query = db.from("tasks").select("id, title, slug, status, stage").in("id", ids);
+  if (userId) {
+    query = query.eq("user_id", userId);
+  }
+  const { data } = await query;
+  const map = /* @__PURE__ */ new Map();
+  if (Array.isArray(data)) {
+    for (const row of data) {
+      if (row && row.id) {
+        map.set(row.id, summarizeRecord(row, row.id));
+      }
+    }
+  }
+  return ids.map((id) => map.get(id) || { id });
+}
+function formatMissingDependencies(missing) {
+  if (!missing.length) return "";
+  const maxItems = 3;
+  const entries = missing.slice(0, maxItems).map((dep) => {
+    const label = describeDependency2(dep);
+    const suffix = dep.status ? ` (${dep.status})` : "";
+    return `${label}${suffix}`;
+  });
+  let message = `Waiting on dependencies: ${entries.join(", ")}`;
+  if (missing.length > maxItems) {
+    message += ` +${missing.length - maxItems} more`;
+  }
+  return message;
+}
+async function getMissingDependencies(task, userId) {
+  const dependsOn = Array.isArray(task.depends_on) ? task.depends_on : [];
+  if (!dependsOn.length) return [];
+  const records = await fetchTasksByIds(dependsOn, userId);
+  return records.filter((dep) => (dep.status || "") !== READY_STATUS);
+}
+async function attemptStartTask(taskId, userId, options) {
+  const resolvedUserId = userId || LOCAL_USER.id;
+  const task = await getTask(taskId, resolvedUserId);
+  if (!task) {
+    throw new Error(`Task not found: ${taskId}`);
+  }
+  const missingDependencies = await getMissingDependencies(task, resolvedUserId);
+  if (missingDependencies.length) {
+    const reason = formatMissingDependencies(missingDependencies);
+    const adminDb2 = createAdminDbClient();
+    const { error: error2 } = await adminDb2.from("tasks").update({
+      status: "blocked",
+      blocked_reason: reason,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }).eq("id", taskId);
+    if (error2 && error2.code !== "42703") {
+      throw error2;
+    }
+    return {
+      started: false,
+      missingDependencies,
+      blockedReason: reason
+    };
+  }
+  if (!options?.force && task.status === "queued" && !task.blocked_reason) {
+    return {
+      started: false,
+      missingDependencies: [],
+      alreadyQueued: true
+    };
+  }
+  const { frontmatter, body } = parseFrontmatter(task.content || "");
+  const ticketType = options?.ticketType ?? getTicketType(frontmatter, body);
+  const boss2 = await getBoss();
+  const jobId = await boss2.send(QUEUE_NAMES.TASK_PROCESS, {
+    taskId,
+    userId: resolvedUserId,
+    signal: "start",
+    ticketType
+  });
+  const adminDb = createAdminDbClient();
+  const { error } = await adminDb.from("tasks").update({
+    status: "queued",
+    blocked_reason: null,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).eq("id", taskId);
+  if (error && error.code !== "42703") {
+    throw error;
+  }
+  return {
+    started: Boolean(jobId),
+    jobId,
+    missingDependencies: [],
+    ticketType
+  };
+}
+async function triggerDependentTasks(taskId, userId) {
+  const resolvedUserId = userId || LOCAL_USER.id;
+  const db = createAdminDbClient();
+  let query = db.from("tasks").select("id").contains("depends_on", [taskId]);
+  if (userId) {
+    query = query.eq("user_id", userId);
+  }
+  const { data } = await query;
+  if (!Array.isArray(data) || !data.length) return;
+  await Promise.all(
+    data.map((row) => row?.id).filter(Boolean).map((dependentId) => attemptStartTask(dependentId, resolvedUserId))
+  );
+}
+
 // ../agx-cloud/lib/orchestrator/activities.ts
 function isMissingStageDecisionsError(error) {
   if (!error || typeof error !== "object") return false;
@@ -19375,6 +19670,15 @@ async function applyStageTransitionActivity(input) {
   if (!task) {
     throw new Error(`Task ${input.taskId} not found`);
   }
+  const previousStage = task.stage || null;
+  const eventTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const baseNotification = {
+    taskId: input.taskId,
+    userId: input.userId,
+    title: task.title || null,
+    slug: task.slug || null,
+    timestamp: eventTimestamp
+  };
   const { frontmatter, body } = parseFrontmatter(task.content);
   frontmatter.stage = input.nextStage;
   frontmatter.status = input.nextStatus;
@@ -19395,6 +19699,43 @@ async function applyStageTransitionActivity(input) {
   }).eq("id", input.taskId).eq("user_id", input.userId);
   if (input.nextStatus === "completed") {
     await db.from("tasks").update({ completed_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", input.taskId).eq("user_id", input.userId);
+    await triggerDependentTasks(input.taskId, input.userId);
+  }
+  const shouldEmitStageComplete = input.nextStatus !== "blocked" && input.nextStatus !== "failed";
+  if (shouldEmitStageComplete) {
+    void notifyTaskEvent({
+      ...baseNotification,
+      eventType: "task.stage_complete",
+      stage: previousStage,
+      previousStage,
+      nextStage: input.nextStage,
+      status: input.nextStatus,
+      details: { nextStatus: input.nextStatus }
+    });
+  }
+  if (input.nextStatus === "completed") {
+    void notifyTaskEvent({
+      ...baseNotification,
+      eventType: "task.completed",
+      stage: input.nextStage,
+      status: input.nextStatus,
+      details: {
+        previousStage,
+        nextStage: input.nextStage
+      }
+    });
+  }
+  if (input.nextStatus === "failed") {
+    void notifyTaskEvent({
+      ...baseNotification,
+      eventType: "task.failed",
+      stage: input.nextStage,
+      status: input.nextStatus,
+      error: input.error,
+      details: {
+        previousStage
+      }
+    });
   }
 }
 async function appendTaskLogActivity(input) {
@@ -19418,6 +19759,20 @@ async function markCancelledActivity(input) {
     error: input.reason || "Cancelled",
     updated_at: (/* @__PURE__ */ new Date()).toISOString()
   }).eq("id", input.taskId).eq("user_id", input.userId);
+  void notifyTaskEvent({
+    taskId: input.taskId,
+    userId: input.userId,
+    eventType: "task.failed",
+    title: task.title || null,
+    slug: task.slug || null,
+    stage: task.stage || null,
+    status: "failed",
+    error: input.reason || "Cancelled",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    details: {
+      previousStage: task.stage || null
+    }
+  });
 }
 
 // ../agx-cloud/lib/orchestrator/processor.ts

package/lib/cli/cloud/prompts.js

@@ -1,6 +1,8 @@
 /* eslint-disable no-console */
 'use strict';
 
+const { interpolate, AGGREGATOR_PROMPT, EXECUTE_ITERATION, VERIFY_PROMPT } = require('../../prompts/templates');
+
 function createCloudPromptHelpers(env) {
   const { path, truncateForPrompt, VERIFY_PROMPT_MAX_CHARS } = env || {};
 
@@ -49,57 +51,20 @@ function createCloudPromptHelpers(env) {
         '- artifacts/ (additional artifacts, if any)',
       ].join('\n');
 
-    return `You are the decision aggregator for a ${role} run.
-
-Task ID: ${taskId}
-Title: ${task?.title || taskId}
-Stage: ${task?.stage || 'unknown'}
-
-User Request: 
-"""
-${task?.title}
-${task?.content}
----
-Task Thread:
-${taskComments.map(c => `${c.author}: ${c.content}`).join('\n')}
-"""
-
-Stage Objective: ${stagePrompt}
-Stage Completion Requirement: ${stageRequirement}
-
-Local run artifacts folder: ${runRoot || '(not available)'}
-Key run files:
-${runFiles}
-
-Relevant files referenced during execution (detected from output/logs):
-${refsBlock}
-
-Decide if the task is done. If not, provide the next instruction for another iteration.
-Only set "done": true when the Stage Completion Requirement is satisfied.
-
-You may think through your analysis first, but you MUST end your response with valid JSON.
-
-Output contract (strict):
-- You may include thinking/reasoning at the start of your response
-- Your response MUST end with exactly one raw JSON object
-- Do not use markdown/code fences/backticks around the JSON
-- Do not add commentary after the JSON
-- Use double-quoted keys and strings
-- Keep newlines escaped inside strings
-- If "done" is false, "next_prompt" must be a non-empty actionable instruction
-
-The final JSON in your response must have this exact shape:
-{
-  "done": false,
-  "decision": "done|blocked|not_done|failed",
-  "explanation": "clear explanation of the decision",
-  "final_result": "final result if done, empty string otherwise",
-  "next_prompt": "specific actionable instruction for next iteration",
-  "summary": "brief summary of current state"
-}
-
-If uncertain, still return valid JSON with decision "failed" and explain why in "explanation".
-`;
+    return interpolate(AGGREGATOR_PROMPT, {
+      role,
+      taskId,
+      title: task?.title || taskId,
+      stage: task?.stage || 'unknown',
+      taskTitle: task?.title,
+      taskContent: task?.content,
+      taskComments: taskComments.map(c => `${c.author}: ${c.content}`).join('\n'),
+      stagePrompt,
+      stageRequirement,
+      runRoot: runRoot || '(not available)',
+      runFiles,
+      refsBlock,
+    });
   }
 
   function truncateForPromptLocal(text, maxChars) {
@@ -114,26 +79,10 @@ If uncertain, still return valid JSON with decision "failed" and explain why in
       ? nextPrompt.trim()
       : 'Pick the next concrete step and implement it.';
 
-    return [
-      'EXECUTE PHASE',
-      `Iteration: ${iteration}`,
-      '',
-      'Keep output concise and avoid dumping full file contents or long logs.',
-      'If you need to reference code, cite paths and describe changes instead of pasting whole files.',
-      '',
-      'Output contract:',
-      '- Start with "PLAN:" then 2-5 bullets.',
-      '- Do the work.',
-      '- End with "IMPLEMENTATION SUMMARY:" bullets:',
-      '  - Changed: (paths only, 10 max)',
-      '  - Commands: (what you ran)',
-      '  - Notes:',
-      '',
-      `Task for this iteration: ${instruction}`,
-      '',
-      'Do not output JSON in this phase.',
-      ''
-    ].join('\n');
+    return interpolate(EXECUTE_ITERATION, {
+      iteration,
+      instruction,
+    });
   }
 
   function buildVerifyPrompt({ taskId, task, stagePrompt, stageRequirement, gitSummary, verifyResults, iteration, lastRunPath, agentOutput }) {
@@ -161,68 +110,21 @@ If uncertain, still return valid JSON with decision "failed" and explain why in
 
     const runRoot = lastRunPath ? String(lastRunPath) : '';
 
-    const prompt = `You are the verifier for an agx run.
-
-Task ID: ${taskId}
-Title: ${title || taskId}
-Stage: ${task?.stage || 'unknown'}
-Iteration: ${iteration}
-
-Stage Objective: ${stagePrompt}
-Stage Completion Requirement: ${stageRequirement}
-
-Local run artifacts folder: ${runRoot || '(not available)'}
-
-User Request:
-"""
-${title}
-${content}
-"""
-
-Target state evidence:
-- Before reviewing git status or diff, first ask whether the target state already exists and fully satisfies the user request.
-- Check the agent output and verification command logs for evidence (files, folders, config values, summaries) that the desired outcome is already in place, even if the diff is empty.
-- If those signals show the target is already achieved and verification commands pass, treat the work as done without requiring new diffs; only rely on git status/diff when the target state is missing or unclear.
-
-Repo summary (git):
-Status (porcelain):
-${statusShort || '(none)'}
-
-Diff (stat):
-${diffShort || '(none)'}
-
-Verification commands:
-${cmdLines}
-
-Agent output (last iteration):
-${agentOutputShort || '(not available)'}
-
-Decide if the stage is complete. Use verification commands as evidence.
-Ignore unrelated working tree changes; focus on whether the user request is satisfied.
-If not complete, provide the next smallest instruction for another iteration.
-Set "done": true when the user request is satisfied and the evidence supports it. Treat the stage objective/requirement as guidance, not a keyword checklist.
-
-IMPORTANT: Before you look at the git status/diff, first ask whether the target state already exists and the user request is satisfied. Check the agent output and verification command logs for evidence (files, folders, config values, summaries) that the outcome is already in place, even if the diff is empty. Treat that as "target achieved" and you may mark the stage done without requiring new diffs. Use git status/diff only when the target state is missing or unclear and you need to verify what changed to reach it. If verification commands pass and the evidence shows the desired result already exists, mark the work done.
-
-Output contract (strict): your response MUST be exactly one raw JSON object with this shape:
-{
-  "done": false,
-  "decision": "done|blocked|not_done|failed",
-  "explanation": "clear explanation of the decision",
-  "final_result": "final result if done, empty string otherwise",
-  "next_prompt": "specific actionable instruction for next iteration",
-  "summary": "brief summary of current state",
-  "plan_md": "PLAN markdown for this iteration (newlines escaped)",
-  "implementation_summary_md": "IMPLEMENTATION SUMMARY markdown (newlines escaped)",
-  "verification_md": "VERIFICATION markdown (newlines escaped)"
-}
-
-Rules:
-- Use double-quoted keys and strings.
-- Keep newlines escaped inside strings (use \\n).
-- Keep the markdown fields short and checklist-style.
-- Always fill "explanation". For "blocked", include what is blocking and what input/action would unblock. For "failed", include what failed (command/tool/error) and a recovery step.
-`;
+    const prompt = interpolate(VERIFY_PROMPT, {
+      taskId,
+      title: title || taskId,
+      stage: task?.stage || 'unknown',
+      iteration,
+      stagePrompt,
+      stageRequirement,
+      runRoot: runRoot || '(not available)',
+      requestTitle: title,
+      requestContent: content,
+      statusShort: statusShort || '(none)',
+      diffShort: diffShort || '(none)',
+      cmdLines,
+      agentOutputShort: agentOutputShort || '(not available)',
+    });
 
     return (typeof truncateForPrompt === 'function'
       ? truncateForPrompt(prompt, VERIFY_PROMPT_MAX_CHARS)