@mndrk/agx 2.0.55 → 2.1.0

package/cloud-runtime/standalone/apps/local/src/prompt-scheduler/processor.ts

@@ -4,30 +4,17 @@ import { homedir } from 'os';
 
 import { getPromptJobStore } from './get-store';
 import { pollDueJobs } from './engine';
-import { getAgent, getAgentSkills, getProjectAgents } from '@/lib/db';
+import { getAgent, getAgentSkills, getProjectAgents, getTeamAgents } from '@/lib/db';
 import { LOCAL_USER } from '@/lib/auth-mode';
 import { loadDbParticipants } from '@/lib/agent-participants';
 import { runCliResponse, buildCliAttempts } from '@/lib/cli-runner';
 import { startScriptedLinearSession } from '@/lib/linear-scripted-session';
-import { getIssueActiveAgents } from '@/lib/linear-run-store';
 import {
-  filterObjectiveLinearIssuesForAction,
   isObjectiveLinearTerminalStatus,
-  listObjectiveLinearIssues,
 } from '@/lib/objective-linear-issues';
 import {
   loadProjectObjectiveContext,
-  persistProjectHealthSnapshot,
-  persistProjectObjectiveWorkspace,
 } from '@/lib/project-objective-context';
-import {
-  normalizeProjectHealthProgress,
-  normalizeProjectHealthStatus,
-  upsertProjectObjective,
-  writeProjectHealthSnapshot,
-  type ProjectHealthSnapshot,
-  type ProjectObjectiveHealth,
-} from '@/lib/project-objectives';
 import { getActivityRepository } from '@/src/objectives/activities/repository';
 import type { ChatProvider } from '@/lib/types';
 import type { LinearIssueSummary } from '@/lib/linear-issues';
@@ -40,22 +27,6 @@ let pumpScheduled = false;
 let pumpRunning = false;
 
 const AGENTS_DIR = join(homedir(), '.agx', 'agents');
-const OBJECTIVE_LINEAR_CONTROLLER_SYSTEM_CONTEXT = [
-  'You are deciding whether a scheduled objective worker should start exactly one Linear work session.',
-  'Return ONLY raw JSON with no markdown fences or commentary.',
-  'Valid responses:',
-  '{"decision":"stop","reason":"short reason","objectiveProgress":42,"objectiveStatus":"at_risk","projectProgress":35,"projectStatus":"at_risk"}',
-  '{"decision":"work","ticketId":"ticket-id-from-list","reason":"short reason","objectiveProgress":42,"objectiveStatus":"at_risk","projectProgress":35,"projectStatus":"at_risk"}',
-  'Percentages must be integers from 0 to 100.',
-  'Statuses must be one of: on_track, at_risk, off_track, done.',
-].join('\n');
-
-const HEALTH_LABELS: Record<ProjectObjectiveHealth, string> = {
-  on_track: 'On track',
-  at_risk: 'At risk',
-  off_track: 'Off track',
-  done: 'Done',
-};
 
 /** Build a short command string for process identification (used by stale-run reaper). */
 function buildHostCommand(provider: ChatProvider, model: string | null): string {
@@ -185,137 +156,6 @@ async function executePrompt(opts: {
   }
 }
 
-function extractFirstJsonObject(raw: string): Record<string, unknown> | null {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return null;
-  }
-
-  const directParse = tryParseJsonObject(trimmed);
-  if (directParse) {
-    return directParse;
-  }
-
-  const start = trimmed.indexOf('{');
-  const end = trimmed.lastIndexOf('}');
-  if (start === -1 || end <= start) {
-    return null;
-  }
-
-  return tryParseJsonObject(trimmed.slice(start, end + 1));
-}
-
-function tryParseJsonObject(raw: string): Record<string, unknown> | null {
-  try {
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
-      ? (parsed as Record<string, unknown>)
-      : null;
-  } catch {
-    return null;
-  }
-}
-
-function formatIssueLine(issue: LinearIssueSummary): string {
-  return [
-    `- id: ${issue.id}`,
-    `  identifier: ${issue.identifier}`,
-    `  title: ${issue.title}`,
-    `  status: ${issue.status}`,
-    `  assignee: ${issue.assignee ?? 'Unassigned'}`,
-    issue.url ? `  url: ${issue.url}` : null,
-  ]
-    .filter((line): line is string => Boolean(line))
-    .join('\n');
-}
-
-function formatObjectiveSummaryLine(input: {
-  title: string;
-  key: string;
-  progress: number;
-  status: ProjectObjectiveHealth;
-}): string {
-  return `- ${input.title} (${input.key}) | ${input.progress}% | ${input.status}`;
-}
-
-function formatHealthSummary(scope: string, progress: number, status: ProjectObjectiveHealth): string {
-  return `${scope}: ${progress}% ${HEALTH_LABELS[status]}`;
-}
-
-function buildObjectiveLinearControllerPrompt(input: {
-  jobPrompt: string;
-  objective: {
-    title: string;
-    key: string;
-    summary: string;
-    progress: number;
-    status: ProjectObjectiveHealth;
-  };
-  projectObjectives: Array<{
-    title: string;
-    key: string;
-    progress: number;
-    status: ProjectObjectiveHealth;
-  }>;
-  allIssues: LinearIssueSummary[];
-  eligibleIssues: LinearIssueSummary[];
-  activeIssueNotes: string[];
-}): string {
-  const sections = [
-    'OBJECTIVE',
-    `- Title: ${input.objective.title}`,
-    `- Label key: ${input.objective.key}`,
-    `- Summary: ${input.objective.summary.trim() || 'No summary provided.'}`,
-    `- Current progress: ${input.objective.progress}%`,
-    `- Current health: ${input.objective.status}`,
-    '',
-    'PROJECT OBJECTIVES',
-    input.projectObjectives.length > 0
-      ? input.projectObjectives.map((objective) => formatObjectiveSummaryLine(objective)).join('\n')
-      : '- No project objectives found.',
-    '',
-    'ALL OBJECTIVE TICKETS',
-    input.allIssues.length > 0
-      ? input.allIssues.map((issue) => formatIssueLine(issue)).join('\n\n')
-      : '- None.',
-    '',
-    'SCHEDULER GUIDANCE',
-    input.jobPrompt.trim() || 'No additional guidance provided.',
-    '',
-    'ELIGIBLE TICKETS',
-    input.eligibleIssues.length > 0
-      ? input.eligibleIssues.map((issue) => formatIssueLine(issue)).join('\n\n')
-      : '- None.',
-  ];
-
-  if (input.activeIssueNotes.length > 0) {
-    sections.push('', 'ALREADY ACTIVE ELSEWHERE', input.activeIssueNotes.join('\n'));
-  }
-
-  sections.push(
-    '',
-    'Choose "work" only when one listed ticket is clearly the right next ticket to start now.',
-    'Choose "stop" when none of the listed tickets should be worked right now.',
-    'If you choose "work", ticketId must exactly match one of the listed ids.',
-  );
-
-  return sections.join('\n');
-}
-
-function normalizeAssessmentProgress(value: unknown): number | null {
-  if (typeof value !== 'number' || !Number.isFinite(value)) {
-    return null;
-  }
-  return normalizeProjectHealthProgress(value);
-}
-
-function normalizeAssessmentStatus(value: unknown): ProjectObjectiveHealth | null {
-  if (typeof value !== 'string' || !value.trim()) {
-    return null;
-  }
-  return normalizeProjectHealthStatus(value);
-}
-
 async function resolveObjectiveWorkerAgent(job: PromptJob): Promise<Participant> {
   const participants = await loadDbParticipants();
 
@@ -328,7 +168,7 @@ async function resolveObjectiveWorkerAgent(job: PromptJob): Promise<Participant>
   }
 
   if (!job.projectId) {
-    throw new Error('Objective Linear worker requires a project context to resolve an agent.');
+    throw new Error('Objective worker requires a project context to resolve an agent.');
   }
 
   const projectAgents = await getProjectAgents(job.projectId);
@@ -339,7 +179,31 @@ async function resolveObjectiveWorkerAgent(job: PromptJob): Promise<Participant>
     }
   }
 
-  throw new Error('No project agent is available to work objective Linear tickets.');
+  throw new Error('No project agent is available to run the objective worker.');
+}
+
+/**
+ * Resolve the agent for a linear worker job.
+ * Priority: team lead (role_key contains "lead") → first agent by routing_order → fallback to agentId/project agents.
+ */
+async function resolveLinearWorkerAgent(job: PromptJob): Promise<Participant> {
+  const participants = await loadDbParticipants();
+
+  if (job.teamId) {
+    const teamAgents = await getTeamAgents(job.teamId);
+    if (teamAgents.length > 0) {
+      // Prefer the team lead (role_key contains "lead")
+      const leadAgent = teamAgents.find((ta) => ta.role_key.includes('lead'));
+      const selectedTeamAgent = leadAgent ?? teamAgents[0];
+      const participant = participants.find((p) => p.id === selectedTeamAgent.agent_id) ?? null;
+      if (participant) {
+        return participant;
+      }
+    }
+  }
+
+  // Fallback to explicit agentId or project agents
+  return resolveObjectiveWorkerAgent(job);
 }
 
 async function appendObjectiveWorkerActivity(input: {
@@ -358,7 +222,47 @@ async function appendObjectiveWorkerActivity(input: {
   });
 }
 
-async function executeObjectiveLinearWorker(opts: {
+export async function logActionReceipt(
+  receipt: import('./types').ActionReceipt,
+  context: { jobId: string; projectId: string; objectiveId: string },
+): Promise<void> {
+  try {
+    const objectiveContext = await loadProjectObjectiveContext(
+      context.projectId,
+      context.objectiveId,
+    );
+    if (!objectiveContext) return;
+
+    const lines: string[] = [
+      `**${receipt.jobName}** — ${receipt.status}`,
+      '',
+      receipt.result,
+    ];
+    if (receipt.reason && !receipt.result.includes(`Reason: ${receipt.reason}`)) {
+      lines.push('', `Reason: ${receipt.reason}`);
+    }
+    if (receipt.linearRunId && !receipt.result.includes(`Linear run: ${receipt.linearRunId}`)) {
+      lines.push('', `Linear run: ${receipt.linearRunId}`);
+    }
+    if (receipt.chatRunId && !receipt.result.includes(`Chat run: ${receipt.chatRunId}`)) {
+      lines.push('', `Chat run: ${receipt.chatRunId}`);
+    }
+
+    await appendObjectiveWorkerActivity({
+      jobId: context.jobId,
+      projectSlug: objectiveContext.project.slug,
+      objectiveKey: objectiveContext.objective.key,
+      body: lines.join('\n'),
+    });
+  } catch {
+    // Activity logging is best-effort
+  }
+}
+
+export async function dispatchObjectiveAction(opts: {
+  action: string;
+  parsed: Record<string, unknown> | null;
+  reason: string;
   job: PromptJob;
   controllerContext: {
     provider: ChatProvider;
@@ -368,195 +272,109 @@ async function executeObjectiveLinearWorker(opts: {
     skills: string | undefined;
   };
   sessionAgent: Participant;
+  objectiveContext: NonNullable<Awaited<ReturnType<typeof loadProjectObjectiveContext>>>;
+  eligibleIssues: LinearIssueSummary[];
+  issues: LinearIssueSummary[];
+  healthSummaries: {
+    objectiveHealthSummary: string | null;
+    projectHealthSummary: string | null;
+    objectiveNote: string;
+    projectNote: string;
+  };
   cliArgs?: string;
   onSpawn?: (pid: number) => void;
-}): Promise<{ output: string; error: string; durationMs: number; status: 'success' | 'failed' }> {
-  const startMs = Date.now();
+  startMs: number;
+}): Promise<import('./types').ActionReceipt> {
+  const { action, parsed, reason, healthSummaries } = opts;
+
+  if (action === 'stop') {
+    const hasNonTerminalIssues = opts.issues.some((issue) => !isObjectiveLinearTerminalStatus(issue.status));
+    const fallbackReason =
+      opts.issues.length === 0
+        ? 'No objective-labeled Linear tickets were found.'
+        : opts.eligibleIssues.length === 0
+          ? hasNonTerminalIssues
+            ? 'All actionable objective tickets already have active sessions.'
+            : 'All objective tickets are already in a terminal state.'
+          : 'The controller decided that no ticket should be started right now.';
+    const stopReason = reason || fallbackReason;
 
-  try {
-    if (!opts.job.projectId || !opts.job.objectiveId) {
-      throw new Error('Objective Linear worker jobs require projectId and objectiveId.');
-    }
+    return {
+      action: 'stop',
+      jobName: opts.job.name,
+      reason: stopReason,
+      result: [
+        'No action taken.',
+        `Reason: ${stopReason}`,
+        healthSummaries.objectiveHealthSummary,
+        healthSummaries.objectiveNote || null,
+        healthSummaries.projectHealthSummary,
+        healthSummaries.projectNote || null,
+      ]
+        .filter((line): line is string => Boolean(line))
+        .join('\n\n'),
+      durationMs: Date.now() - opts.startMs,
+      status: 'success',
+    };
+  }
 
-    const objectiveContext = await loadProjectObjectiveContext(
-      opts.job.projectId,
-      opts.job.objectiveId,
-    );
-    if (!objectiveContext) {
-      throw new Error('Objective context could not be resolved for this scheduled task.');
+  if (action === 'run_prompt') {
+    const promptText = typeof parsed?.prompt === 'string' ? parsed.prompt.trim() : '';
+    if (!promptText) {
+      return {
+        action: 'run_prompt',
+        jobName: opts.job.name,
+        reason,
+        result: 'Controller returned run_prompt but provided no prompt text.',
+        durationMs: Date.now() - opts.startMs,
+        status: 'failed',
+      };
     }
 
-    const [{ issues }, activeIssueAgents] = await Promise.all([
-      listObjectiveLinearIssues({
-        objectiveKey: objectiveContext.objective.key,
-        projectSlug: objectiveContext.project.slug,
-        refresh: true,
-      }),
-      getIssueActiveAgents(opts.job.projectId),
-    ]);
-
-    const objectiveIssueIds = new Set(issues.map((issue) => issue.id));
-    const activeObjectiveAgents = activeIssueAgents.filter((entry) => objectiveIssueIds.has(entry.issueId));
-    const activeIssueNotes = activeObjectiveAgents.map(
-      (entry) => `- ${entry.issueId}: already running with ${entry.agentName}`,
-    );
-    const eligibleIssues = filterObjectiveLinearIssuesForAction(
-      issues,
-      activeObjectiveAgents.map((entry) => entry.issueId),
-    );
-
-    const controllerPrompt = buildObjectiveLinearControllerPrompt({
-      jobPrompt: opts.job.prompt,
-      objective: {
-        title: objectiveContext.objective.title,
-        key: objectiveContext.objective.key,
-        summary: objectiveContext.objective.summary,
-        progress: objectiveContext.objective.progress,
-        status: objectiveContext.objective.status,
-      },
-      projectObjectives: objectiveContext.workspace.objectives.map((objective) => ({
-        title: objective.title,
-        key: objective.key,
-        progress: objective.progress,
-        status: objective.status,
-      })),
-      allIssues: issues,
-      eligibleIssues,
-      activeIssueNotes,
-    });
-    const controllerResult = await executePrompt({
+    const promptResult = await executePrompt({
       ...opts.controllerContext,
-      prompt: controllerPrompt,
-      systemContext: OBJECTIVE_LINEAR_CONTROLLER_SYSTEM_CONTEXT,
+      prompt: promptText,
       cliArgs: opts.cliArgs,
       onSpawn: opts.onSpawn,
     });
 
-    if (controllerResult.status !== 'success') {
-      return {
-        ...controllerResult,
-        output: controllerResult.output || 'Objective controller failed before selecting a ticket.',
-      };
-    }
-
-    const parsed = extractFirstJsonObject(controllerResult.output);
-    const decision = typeof parsed?.decision === 'string' ? parsed.decision.trim().toLowerCase() : '';
-    const reason = typeof parsed?.reason === 'string' ? parsed.reason.trim() : '';
-    const objectiveProgress = normalizeAssessmentProgress(parsed?.objectiveProgress);
-    const objectiveStatus = normalizeAssessmentStatus(parsed?.objectiveStatus);
-    const projectProgress = normalizeAssessmentProgress(parsed?.projectProgress);
-    const projectStatus = normalizeAssessmentStatus(parsed?.projectStatus);
-    const projectNote = typeof parsed?.projectNote === 'string' ? parsed.projectNote.trim() : '';
-    const objectiveNote = typeof parsed?.objectiveNote === 'string' ? parsed.objectiveNote.trim() : '';
-    const nowIso = new Date().toISOString();
-
-    const objectiveHealthSummary =
-      objectiveProgress !== null && objectiveStatus
-        ? formatHealthSummary('Objective health', objectiveProgress, objectiveStatus)
-        : null;
-    const projectHealthSummary =
-      projectProgress !== null && projectStatus
-        ? formatHealthSummary('Project health', projectProgress, projectStatus)
-        : null;
-
-    const objectiveChanged =
-      objectiveProgress !== null &&
-      objectiveStatus !== null &&
-      (
-        objectiveProgress !== objectiveContext.objective.progress ||
-        objectiveStatus !== objectiveContext.objective.status
-      );
-    const nextWorkspace = objectiveChanged
-      ? upsertProjectObjective(objectiveContext.workspace, {
-          ...objectiveContext.objective,
-          progress: objectiveProgress!,
-          status: objectiveStatus!,
-          updatedAt: nowIso,
-        })
-      : objectiveContext.workspace;
-    const projectSnapshot: ProjectHealthSnapshot | null =
-      projectProgress !== null && projectStatus !== null
-        ? {
-            progress: projectProgress,
-            status: projectStatus,
-            updatedAt: nowIso,
-            source: `scheduled-task:${opts.job.id}`,
-            objectiveId: objectiveContext.objective.id,
-            objectiveKey: objectiveContext.objective.key,
-            note: projectNote || undefined,
-          }
-        : null;
-
-    if (objectiveChanged) {
-      await persistProjectObjectiveWorkspace({
-        projectId: objectiveContext.project.id,
-        currentMetadata: objectiveContext.project.metadata,
-        workspace: nextWorkspace,
-        transformMetadata: (metadata) =>
-          projectSnapshot ? writeProjectHealthSnapshot(metadata, projectSnapshot) : metadata,
-      });
-    } else if (projectSnapshot) {
-      await persistProjectHealthSnapshot({
-        projectId: objectiveContext.project.id,
-        currentMetadata: objectiveContext.project.metadata,
-        snapshot: projectSnapshot,
-      });
-    }
-
-    if (decision === 'stop') {
-      const hasNonTerminalIssues = issues.some((issue) => !isObjectiveLinearTerminalStatus(issue.status));
-      const fallbackReason =
-        issues.length === 0
-          ? 'No objective-labeled Linear tickets were found.'
-          : eligibleIssues.length === 0
-            ? hasNonTerminalIssues
-              ? 'All actionable objective tickets already have active sessions.'
-              : 'All objective tickets are already in a terminal state.'
-            : 'The controller decided that no ticket should be started right now.';
-      const stopReason = reason || fallbackReason;
-      await appendObjectiveWorkerActivity({
-        jobId: opts.job.id,
-        projectSlug: objectiveContext.project.slug,
-        objectiveKey: objectiveContext.objective.key,
-        body: [
-          'No actionable objective tickets.',
-          `Reason: ${stopReason}`,
-          objectiveHealthSummary,
-          objectiveNote || null,
-          projectHealthSummary,
-          projectNote || null,
-        ]
-          .filter((line): line is string => Boolean(line))
-          .join('\n\n'),
-      });
-      return {
-        output: [
-          'No actionable objective tickets.',
-          `Reason: ${stopReason}`,
-          objectiveHealthSummary,
-          projectHealthSummary,
-        ]
-          .filter((line): line is string => Boolean(line))
-          .join('\n'),
-        error: '',
-        durationMs: Date.now() - startMs,
-        status: 'success',
-      };
-    }
+    const summary = promptResult.status === 'success'
+      ? (promptResult.output || '').split('\n').filter(Boolean).slice(0, 10).join('\n') || 'Prompt completed.'
+      : `Prompt failed: ${promptResult.error || 'unknown error'}`;
 
-    if (decision !== 'work') {
-      throw new Error(`Objective worker controller returned an invalid decision: ${controllerResult.output}`);
-    }
+    return {
+      action: 'run_prompt',
+      jobName: opts.job.name,
+      reason,
+      result: [
+        summary,
+        healthSummaries.objectiveHealthSummary,
+        healthSummaries.projectHealthSummary,
+      ]
+        .filter((line): line is string => Boolean(line))
+        .join('\n\n'),
+      durationMs: Date.now() - opts.startMs,
+      status: promptResult.status,
+    };
+  }
 
+  if (action === 'work_ticket') {
     const ticketId = typeof parsed?.ticketId === 'string' ? parsed.ticketId.trim() : '';
-    const selectedIssue = eligibleIssues.find((issue) => issue.id === ticketId) ?? null;
+    const selectedIssue = opts.eligibleIssues.find((issue) => issue.id === ticketId) ?? null;
     if (!selectedIssue) {
-      throw new Error(`Objective worker controller selected an unknown ticket: ${ticketId || '(empty)'}`);
+      return {
+        action: 'work_ticket',
+        jobName: opts.job.name,
+        reason,
+        result: `Controller selected an unknown ticket: ${ticketId || '(empty)'}`,
+        durationMs: Date.now() - opts.startMs,
+        status: 'failed',
+      };
     }
 
     const launch = await startScriptedLinearSession({
-      projectId: objectiveContext.project.id,
-      projectSlug: objectiveContext.project.slug,
+      projectId: opts.objectiveContext.project.id,
+      projectSlug: opts.objectiveContext.project.slug,
       issue: {
         id: selectedIssue.id,
         identifier: selectedIssue.identifier,
@@ -570,46 +388,38 @@ async function executeObjectiveLinearWorker(opts: {
     const issueLink = selectedIssue.url
       ? `[${selectedIssue.identifier}](${selectedIssue.url})`
       : selectedIssue.identifier;
-    await appendObjectiveWorkerActivity({
-      jobId: opts.job.id,
-      projectSlug: objectiveContext.project.slug,
-      objectiveKey: objectiveContext.objective.key,
-      body: [
-        `Started work on ${issueLink}: ${selectedIssue.title}`,
-        reason ? `Reason: ${reason}` : null,
-        objectiveHealthSummary,
-        objectiveNote || null,
-        projectHealthSummary,
-        projectNote || null,
-        `Linear run: ${launch.run.id}`,
-      ]
-        .filter((line): line is string => Boolean(line))
-        .join('\n\n'),
-    });
 
     return {
-      output: [
-        `Started work on ${selectedIssue.identifier}: ${selectedIssue.title}`,
+      action: 'work_ticket',
+      jobName: opts.job.name,
+      reason,
+      result: [
+        `Started work on ${issueLink}: ${selectedIssue.title}`,
         reason ? `Reason: ${reason}` : null,
-        objectiveHealthSummary,
-        projectHealthSummary,
+        healthSummaries.objectiveHealthSummary,
+        healthSummaries.objectiveNote || null,
+        healthSummaries.projectHealthSummary,
+        healthSummaries.projectNote || null,
         `Linear run: ${launch.run.id}`,
-        `Chat run: ${launch.chatRunId}`,
       ]
         .filter((line): line is string => Boolean(line))
-        .join('\n'),
-      error: '',
-      durationMs: Date.now() - startMs,
+        .join('\n\n'),
+      linearRunId: launch.run.id,
+      chatRunId: launch.chatRunId,
+      durationMs: Date.now() - opts.startMs,
       status: 'success',
     };
-  } catch (err) {
-    return {
-      output: '',
-      error: err instanceof Error ? err.message : String(err),
-      durationMs: Date.now() - startMs,
-      status: 'failed',
-    };
   }
+
+  // Unknown action
+  return {
+    action: action || 'unknown',
+    jobName: opts.job.name,
+    reason,
+    result: `Controller returned an invalid action: ${action || '(empty)'}`,
+    durationMs: Date.now() - opts.startMs,
+    status: 'failed',
+  };
 }
 
 async function executeJobAction(
@@ -625,10 +435,24 @@ async function executeJobAction(
     onSpawn?: (pid: number) => void;
   } = {},
 ): Promise<{ output: string; error: string; durationMs: number; status: 'success' | 'failed' }> {
-  if (job.executionMode === 'objective_linear_ticket') {
+  if (job.executionMode === 'objective_worker') {
+    const { executeObjectiveWorker } = await import('./objective-worker');
     const sessionAgent = await resolveObjectiveWorkerAgent(job);
     const controllerContext = await resolveJobContextForAgent(job, sessionAgent.id);
-    return executeObjectiveLinearWorker({
+    return executeObjectiveWorker({
+      job,
+      controllerContext,
+      sessionAgent,
+      cliArgs: job.cliArgs,
+      onSpawn: opts.onSpawn,
+    });
+  }
+
+  if (job.executionMode === 'linear_worker') {
+    const { executeLinearWorker } = await import('./linear-worker');
+    const sessionAgent = await resolveLinearWorkerAgent(job);
+    const controllerContext = await resolveJobContextForAgent(job, sessionAgent.id);
+    return executeLinearWorker({
       job,
       controllerContext,
       sessionAgent,
@@ -678,6 +502,19 @@ async function fireConditionGate(job: PromptJob, run: PromptRun) {
       finishedAt: new Date().toISOString(),
     });
     store.updateJob(job.id, { lastOutcome: 'success', lastRunAt: Date.now() });
+    if (job.objectiveId && job.projectId) {
+      await logActionReceipt(
+        {
+          action: 'gated_skip',
+          jobName: job.name,
+          reason: 'condition not met',
+          result: `Gate: ${answer}\n(condition not met — skipped action)`,
+          durationMs: gateResult.durationMs,
+          status: 'success',
+        },
+        { jobId: job.id, projectId: job.projectId, objectiveId: job.objectiveId },
+      );
+    }
     return;
   }
 
@@ -694,6 +531,23 @@ async function fireConditionGate(job: PromptJob, run: PromptRun) {
     finishedAt: new Date().toISOString(),
   });
   store.updateJob(job.id, { lastOutcome: actionResult.status, lastRunAt: Date.now() });
+
+  // Objective-mode jobs already emit a richer receipt inside executeObjectiveLinearWorker.
+  if (job.objectiveId && job.projectId && job.executionMode !== 'objective_worker') {
+    await logActionReceipt(
+      {
+        action: 'prompt',
+        jobName: job.name,
+        reason: 'condition gate passed',
+        result: actionResult.status === 'success'
+          ? (actionResult.output || '').split('\n').filter(Boolean).slice(0, 3).join('\n') || 'Task completed successfully.'
+          : `Task failed: ${actionResult.error || 'unknown error'}`,
+        durationMs: gateResult.durationMs + actionResult.durationMs,
+        status: actionResult.status,
+      },
+      { jobId: job.id, projectId: job.projectId, objectiveId: job.objectiveId },
+    );
+  }
 }
 
 async function fireRun(job: PromptJob, run: PromptRun) {
@@ -723,6 +577,23 @@ async function fireRun(job: PromptJob, run: PromptRun) {
     finishedAt: new Date().toISOString(),
   });
   store.updateJob(job.id, { lastOutcome: result.status, lastRunAt: Date.now() });
+
+  // Objective-mode jobs already emit a richer receipt inside executeObjectiveLinearWorker.
+  if (job.objectiveId && job.projectId && job.executionMode !== 'objective_worker') {
+    await logActionReceipt(
+      {
+        action: 'prompt',
+        jobName: job.name,
+        reason: '',
+        result: result.status === 'success'
+          ? (result.output || '').split('\n').filter(Boolean).slice(0, 3).join('\n') || 'Task completed successfully.'
+          : `Task failed: ${result.error || 'unknown error'}`,
+        durationMs: result.durationMs,
+        status: result.status,
+      },
+      { jobId: job.id, projectId: job.projectId, objectiveId: job.objectiveId },
+    );
+  }
 }
 
 function dispatchRun(job: PromptJob, run: PromptRun) {