@mndrk/agx 2.0.47 → 2.0.49

package/cloud-runtime/standalone/src/graph/internal-function-dispatcher.ts

@@ -1,6 +1,18 @@
 import type { FunctionDispatchResult } from "./function-executor";
 import type { ExecutionGraph, FunctionNode, WorkNode } from "./types";
-import { getConfiguredBoardBaseUrl } from "@/lib/app-config";
+import { LOCAL_USER } from "@/lib/auth-mode";
+import { loadDbParticipants } from "@/lib/agent-participants";
+import { resolveProjectContext } from "@/lib/chat/project-context";
+import { writeDebugLog } from "@/lib/debug-log";
+import { ensureOrchestratorRuntime } from "@/lib/orchestrator/runtime";
+import type { ChatRunJobData, ChatRunPayload } from "@/lib/orchestrator/chat-types";
+import { getQueue, QUEUE_NAMES } from "@/lib/queue/boss";
+import type { GroupMessage } from "@/lib/types";
+
+const ACTIVE_PROCESS_STATUSES = new Set(["running", "working"]);
+const RECENT_STEER_HISTORY_LIMIT = 20;
+const STEER_DUPLICATE_WINDOW_MS = 15 * 60 * 1000;
+const SHIP_MODE_MAX_ROUNDS = 10;
 
 function getRootMessageId(node: FunctionNode, graph: ExecutionGraph): string {
   const fromArgs = typeof node.args?.rootMessageId === "string" ? node.args.rootMessageId.trim() : "";
@@ -30,27 +42,86 @@ function getSteerOutput(
   };
 }
 
-function getBoardBaseUrl(): string {
-  return getConfiguredBoardBaseUrl();
+function normalizeSteerText(content: string): string {
+  return content.replace(/\s+/g, " ").trim();
+}
+
+function getSpeakerLabel(message: GroupMessage, participantNames: Record<string, string>): string {
+  if (message.role === "user") return "User";
+  if (!message.participantId) return "Assistant";
+  return participantNames[message.participantId] || message.participantId;
+}
+
+function buildRecentHistory(
+  history: GroupMessage[],
+  rootMessageId: string,
+  participantNames: Record<string, string>
+): Array<{ id: string; name: string; content: string }> {
+  return history
+    .filter((message) => message.id === rootMessageId || message.rootMessageId === rootMessageId)
+    .slice(-RECENT_STEER_HISTORY_LIMIT)
+    .map((message) => ({
+      id: message.id,
+      name: getSpeakerLabel(message, participantNames),
+      content: message.content,
+    }));
+}
+
+function hasRecentDuplicateSteer(
+  history: GroupMessage[],
+  rootMessageId: string,
+  candidate: string,
+  participantId: string | null
+): boolean {
+  const normalizedCandidate = normalizeSteerText(candidate);
+  if (!normalizedCandidate) return false;
+  const cutoff = Date.now() - STEER_DUPLICATE_WINDOW_MS;
+
+  return history
+    .filter((message) => message.id === rootMessageId || message.rootMessageId === rootMessageId)
+    .some((message) => {
+      if (message.role !== "assistant") return false;
+      if (message.timestamp < cutoff) return false;
+      if (participantId && message.participantId !== participantId) return false;
+      return normalizeSteerText(message.content) === normalizedCandidate;
+    });
 }
 
-async function getDefaultAgentForThread(threadId: string): Promise<string | null> {
+async function getThreadProjectContext(threadId: string): Promise<{
+  projectSlug: string | null;
+  projectAgentIds: string[];
+}> {
   try {
     const { getSQLiteDb } = await import("@/lib/sqlite-query-adapter");
     const db = getSQLiteDb();
     const projectRow = db
-      .prepare("SELECT project_id FROM project_threads WHERE thread_id = ? ORDER BY created_at ASC LIMIT 1")
-      .get(threadId) as { project_id: string } | undefined;
-    if (!projectRow?.project_id) return null;
+      .prepare(
+        `SELECT pt.project_id AS project_id, p.slug AS project_slug
+         FROM project_threads pt
+         JOIN projects p ON p.id = pt.project_id
+         WHERE pt.thread_id = ?
+         ORDER BY pt.created_at ASC
+         LIMIT 1`
+      )
+      .get(threadId) as { project_id: string; project_slug: string | null } | undefined;
+    if (!projectRow?.project_id) {
+      return { projectSlug: null, projectAgentIds: [] };
+    }
 
-    const agentRow = db
+    const agentRows = db
       .prepare(
-        "SELECT agent_id FROM project_agents WHERE project_id = ? ORDER BY routing_order ASC, created_at ASC LIMIT 1",
+        "SELECT agent_id FROM project_agents WHERE project_id = ? ORDER BY routing_order ASC, created_at ASC",
       )
-      .get(projectRow.project_id) as { agent_id: string } | undefined;
-    return agentRow?.agent_id ?? null;
+      .all(projectRow.project_id) as Array<{ agent_id: string }>;
+
+    return {
+      projectSlug: projectRow.project_slug?.trim() || null,
+      projectAgentIds: agentRows
+        .map((row) => row.agent_id?.trim())
+        .filter((agentId): agentId is string => Boolean(agentId)),
+    };
   } catch {
-    return null;
+    return { projectSlug: null, projectAgentIds: [] };
   }
 }
 
@@ -76,7 +147,7 @@ async function dispatchThreadStatus(node: FunctionNode, graph: ExecutionGraph):
   });
 
   const activeProcessCount = snapshot.processes.filter(
-    (process: { status: string }) => process.status === "working",
+    (process: { status: string }) => ACTIVE_PROCESS_STATUSES.has(process.status),
   ).length;
 
   return {
@@ -101,7 +172,18 @@ async function dispatchShipModeAct(node: FunctionNode, graph: ExecutionGraph): P
     return { status: "failure", message: "Unable to read steer node output" };
   }
 
-  const { getMessageThread, saveMessages, updateMessageStatus } = await import("@/lib/history-store");
+  if (!normalizeSteerText(steer.message)) {
+    return { status: "failure", message: "Ship mode produced an empty steer message" };
+  }
+
+  const {
+    createChatRun,
+    getThreadStatusSnapshot,
+    getMessageThread,
+    loadHistory,
+    saveMessages,
+    updateMessageStatus,
+  } = await import("@/lib/history-store");
   const { deactivateSchedulesByRootMessageId } = await import("./store");
   const threadRef = await getMessageThread(rootMessageId);
   if (!threadRef) {
@@ -112,6 +194,23 @@ async function dispatchShipModeAct(node: FunctionNode, graph: ExecutionGraph): P
   }
 
   if (steer.isDone) {
+    const snapshot = await getThreadStatusSnapshot({
+      threadId: threadRef.threadId,
+      rootMessageId,
+    });
+    const activeProcessCount = snapshot.processes.filter((process: { status: string }) =>
+      ACTIVE_PROCESS_STATUSES.has(process.status)
+    ).length;
+    if (activeProcessCount > 0) {
+      return {
+        status: "success",
+        output: {
+          done: false,
+          action: "completion_deferred_active_work",
+          activeProcessCount,
+        },
+      };
+    }
     deactivateSchedulesByRootMessageId(rootMessageId);
     await updateMessageStatus(threadRef.threadId, rootMessageId, "in-review", null);
     return {
@@ -120,7 +219,25 @@ async function dispatchShipModeAct(node: FunctionNode, graph: ExecutionGraph): P
     };
   }
 
-  const defaultAgent = await getDefaultAgentForThread(threadRef.threadId);
+  const participantLibrary = await loadDbParticipants();
+  const participantNames = Object.fromEntries(
+    participantLibrary.map((participant) => [participant.id, participant.name])
+  );
+  const { projectSlug, projectAgentIds } = await getThreadProjectContext(threadRef.threadId);
+  const threadHistory = await loadHistory(threadRef.threadId);
+  const defaultAgent = projectAgentIds[0] ?? participantLibrary[0]?.id ?? null;
+
+  if (hasRecentDuplicateSteer(threadHistory, rootMessageId, steer.message, defaultAgent)) {
+    return {
+      status: "success",
+      output: {
+        done: false,
+        action: "duplicate_next_steps_skipped",
+        sender: defaultAgent,
+      },
+    };
+  }
+
   const messageId = crypto.randomUUID();
   await saveMessages(threadRef.threadId, [
     {
@@ -135,13 +252,81 @@ async function dispatchShipModeAct(node: FunctionNode, graph: ExecutionGraph): P
     },
   ]);
 
+  const orderedParticipantIds = (projectAgentIds.length > 0
+    ? projectAgentIds
+    : participantLibrary.map((participant) => participant.id))
+    .filter((participantId, index, allIds) => participantId && allIds.indexOf(participantId) === index);
+  const responderIds = orderedParticipantIds.filter((participantId) => participantId !== defaultAgent);
+  const runParticipantIds = (responderIds.length > 0 ? responderIds : orderedParticipantIds).filter((participantId) =>
+    participantLibrary.some((participant) => participant.id === participantId)
+  );
+
+  if (runParticipantIds.length === 0) {
+    return {
+      status: "success",
+      output: {
+        done: false,
+        action: "sent_next_steps_only",
+        sender: defaultAgent,
+        messageId,
+      },
+    };
+  }
+
+  const runParticipants = participantLibrary.filter((participant) => runParticipantIds.includes(participant.id));
+  const projectContext = projectSlug
+    ? await resolveProjectContext(projectSlug, [], runParticipants)
+    : undefined;
+  const chatRunId = crypto.randomUUID();
+  const chatRunPayload: ChatRunPayload = {
+    threadId: threadRef.threadId,
+    prompt: steer.message,
+    projectContext,
+    mentionedIds: [],
+    initialParallelIds: [],
+    maxRounds: SHIP_MODE_MAX_ROUNDS,
+    recentHistory: buildRecentHistory(threadHistory, rootMessageId, participantNames),
+    currentUserMessageId: messageId,
+    rootMessageId,
+    participantIds: runParticipantIds,
+  };
+
+  await createChatRun({
+    id: chatRunId,
+    threadId: threadRef.threadId,
+    rootMessageId,
+    userId: LOCAL_USER.id,
+    projectSlug: projectSlug ?? null,
+    maxSteps: SHIP_MODE_MAX_ROUNDS,
+    activeParticipantIds: runParticipantIds,
+    payload: chatRunPayload as unknown as Record<string, unknown>,
+  });
+
+  await ensureOrchestratorRuntime();
+  const queue = await getQueue();
+  await queue.send<ChatRunJobData>(QUEUE_NAMES.CHAT_RUN_PROCESS, {
+    chatRunId,
+    userId: LOCAL_USER.id,
+    signal: "start",
+  });
+
+  writeDebugLog("ship_mode.steer.enqueued", {
+    rootMessageId,
+    threadId: threadRef.threadId,
+    chatRunId,
+    authorId: defaultAgent,
+    participantIds: runParticipantIds,
+    projectSlug: projectSlug ?? null,
+  });
+
   return {
     status: "success",
     output: {
       done: false,
-      action: "sent_next_steps",
+      action: "sent_next_steps_and_started_chat_run",
       sender: defaultAgent,
       messageId,
+      chatRunId,
     },
   };
 }

package/cloud-runtime/standalone/src/graph/work-dispatcher.ts

@@ -15,19 +15,16 @@ import type { WorkNode, ExecutionGraph } from './types';
 import type { WorkDispatchResult } from './executor';
 import type { ChatProvider } from '@/lib/types';
 
-const STEER_SYSTEM_PROMPT = `You are a progress assessor. Review the conversation state below and determine:
-1. Is the work DONE? (all objectives met, code written, tests passing)
-2. If not done, what should the team do next?
-
-You MUST respond with ONLY a JSON object, no markdown fences, no extra text:
+const ACTIVE_PROCESS_STATUSES = new Set(['running', 'working']);
+const DEFAULT_STEER_DIRECTIVE = `Review the thread, assess whether the work is complete enough to move into review, and if not, produce one concise steering message that combines:
+1. what has been accomplished vs. what remains
+2. the concrete next steps needed to move toward shipping`;
+const STEER_OUTPUT_CONTRACT = `You MUST respond with ONLY a JSON object, no markdown fences, no extra text:
 {"isDone": true/false, "message": "your assessment"}
 
-If done, message should confirm what was accomplished.
-If not done, message must be exactly one message that combines:
-- a brief assessment of what is done vs. not done
-- the concrete next steps for the team
-
-Do not produce separate status and instruction messages.`;
+Set isDone=true only when the thread is genuinely ready to stop ship mode and move into review.
+If isDone=false, message must be a single concise steering note with both status and next steps.
+The message must not be empty.`;
 
 /**
  * Read agx config to get the default provider name.
@@ -55,6 +52,59 @@ function resolveProvider(raw: string): ChatProvider {
   }
 }
 
+async function getSteeringAgentConfig(threadId: string): Promise<{ provider: ChatProvider; model: string | null }> {
+  try {
+    const [{ getSQLiteDb }, { loadDbParticipants }] = await Promise.all([
+      import('@/lib/sqlite-query-adapter'),
+      import('@/lib/agent-participants'),
+    ]);
+    const sqlite = getSQLiteDb();
+    const projectRow = sqlite
+      .prepare(
+        `SELECT pt.project_id AS project_id
+         FROM project_threads pt
+         WHERE pt.thread_id = ?
+         ORDER BY pt.created_at ASC
+         LIMIT 1`
+      )
+      .get(threadId) as { project_id: string } | undefined;
+    if (!projectRow?.project_id) {
+      return { provider: resolveProvider(getDefaultProvider()), model: null };
+    }
+
+    const agentRow = sqlite
+      .prepare(
+        `SELECT agent_id
+         FROM project_agents
+         WHERE project_id = ?
+         ORDER BY routing_order ASC, created_at ASC
+         LIMIT 1`
+      )
+      .get(projectRow.project_id) as { agent_id: string } | undefined;
+    if (!agentRow?.agent_id) {
+      return { provider: resolveProvider(getDefaultProvider()), model: null };
+    }
+
+    const participants = await loadDbParticipants();
+    const agent = participants.find((participant) => participant.id === agentRow.agent_id);
+    if (!agent) {
+      return { provider: resolveProvider(getDefaultProvider()), model: null };
+    }
+
+    return {
+      provider: resolveProvider(agent.provider),
+      model: agent.model,
+    };
+  } catch {
+    return { provider: resolveProvider(getDefaultProvider()), model: null };
+  }
+}
+
+function buildSteerSystemPrompt(node: WorkNode): string {
+  const steerDirective = node.description?.trim() || DEFAULT_STEER_DIRECTIVE;
+  return `${steerDirective}\n\n${STEER_OUTPUT_CONTRACT}`;
+}
+
 /**
  * Create a dispatchWork implementation for schedule-driven graphs.
  *
@@ -97,15 +147,30 @@ export function createDispatchWork(): (
       });
 
       const activeProcessCount = snapshot.processes.filter(
-        (p: { status: string }) => p.status === 'working',
+        (p: { status: string }) => ACTIVE_PROCESS_STATUSES.has(p.status),
       ).length;
+      const rootStatus = snapshot.rootMessage?.threadStatus ?? 'active';
+      const processSummary = snapshot.processes
+        .slice(0, 8)
+        .map((process: {
+          agent: string;
+          status: string;
+          responseTo?: string;
+          responseContent?: string | null;
+        }) => {
+          const details = [`${process.agent}: ${process.status}`];
+          if (process.responseTo) details.push(`replying to "${process.responseTo.slice(0, 140)}"`);
+          if (process.responseContent) details.push(`latest response "${process.responseContent.slice(0, 140)}"`);
+          return `- ${details.join(' | ')}`;
+        })
+        .join('\n');
 
       // Build a summary of recent messages for context
       const recentMessages = (snapshot.messages ?? [])
-        .slice(-10)
+        .slice(-15)
         .map((m: { role?: string; content?: string; participantId?: string | null }) => {
           const sender = m.participantId ?? m.role ?? '?';
-          const text = (m.content ?? '').slice(0, 300);
+          const text = (m.content ?? '').slice(0, 600);
           return `[${sender}]: ${text}`;
         })
         .join('\n');
@@ -115,27 +180,37 @@ export function createDispatchWork(): (
       // 2. Build assessment prompt
       const assessPrompt = [
         '--- THREAD STATE ---',
+        `Root request: ${snapshot.rootMessage?.content ?? '(missing root message)'}`,
+        `Thread status: ${rootStatus}`,
         `Active agents: ${activeProcessCount}`,
         `Total messages: ${snapshot.messages?.length ?? 0}`,
+        snapshot.lastUpdatedAt ? `Last updated at: ${new Date(snapshot.lastUpdatedAt).toISOString()}` : null,
+        '',
+        'Current process state:',
+        processSummary || '- none',
         '',
         'Recent messages:',
-        recentMessages,
+        recentMessages || '- none',
         '--- END THREAD STATE ---',
         '',
         'Assess the progress and respond with the JSON object.',
-      ].join('\n');
+      ]
+        .filter(Boolean)
+        .join('\n');
 
       // 3. Call provider directly via runCliResponse (same path as chat endpoint)
       const { runCliResponse } = await import('@/lib/cli-runner');
-      const provider = resolveProvider(getDefaultProvider());
-      console.log(`[work-dispatch] Calling ${provider} via runCliResponse (prompt length: ${assessPrompt.length})...`);
+      const steeringAgent = await getSteeringAgentConfig(threadRef.threadId);
+      console.log(
+        `[work-dispatch] Calling ${steeringAgent.provider} via runCliResponse (prompt length: ${assessPrompt.length})...`
+      );
 
       let fullResponse = '';
       await runCliResponse({
-        provider,
-        model: null,
+        provider: steeringAgent.provider,
+        model: steeringAgent.model,
         prompt: assessPrompt,
-        systemContext: STEER_SYSTEM_PROMPT,
+        systemContext: buildSteerSystemPrompt(node),
         onDelta: (chunk: string) => {
           fullResponse += chunk;
         },
@@ -148,11 +223,18 @@ export function createDispatchWork(): (
 
       // 4. Parse structured output
       const parsed = parseSteerResponse(fullResponse.trim());
+      if (!parsed.ok) {
+        return {
+          status: 'failure' as const,
+          transient: false,
+          message: parsed.error,
+        };
+      }
       console.log(`[work-dispatch] Parsed result:`, parsed);
 
       return {
         status: 'success' as const,
-        output: parsed,
+        output: parsed.value,
       };
     } catch (err) {
       console.error(`[work-dispatch] Steer dispatch failed:`, err);
@@ -167,26 +249,37 @@ export function createDispatchWork(): (
 
 /**
  * Parse the steer agent's response into { isDone, message }.
- * Tries JSON parse first, falls back to heuristic detection.
  */
-function parseSteerResponse(raw: string): { isDone: boolean; message: string } {
-  // Try to extract JSON from the response
+function parseSteerResponse(
+  raw: string
+):
+  | { ok: true; value: { isDone: boolean; message: string } }
+  | { ok: false; error: string } {
   const jsonMatch = raw.match(/\{[\s\S]*?"isDone"\s*:\s*(true|false)[\s\S]*?\}/);
   if (jsonMatch) {
     try {
       const parsed = JSON.parse(jsonMatch[0]);
+      const message = String(parsed.message ?? '').trim();
+      if (!message) {
+        return { ok: false, error: 'Ship mode response JSON did not include a non-empty message.' };
+      }
       return {
-        isDone: Boolean(parsed.isDone),
-        message: String(parsed.message ?? ''),
+        ok: true,
+        value: {
+          isDone: Boolean(parsed.isDone),
+          message,
+        },
       };
-    } catch { /* fall through */ }
-  }
-
-  // Fallback: check for [done] marker
-  if (raw.includes('[done]')) {
-    return { isDone: true, message: raw };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
   }
 
-  // Default: not done, use raw output as message
-  return { isDone: false, message: raw };
+  return {
+    ok: false,
+    error: 'Ship mode response was not valid JSON with isDone/message fields.',
+  };
 }

package/cloud-runtime/standalone/state/automations/.state/c4300b01-1203-40fe-b3a9-b9fb9ec0c5cc.json

@@ -0,0 +1,8 @@
+{
+  "scheduleHash": "218b10daaa347ad14c3a8fbaabee0cff119839d6f5b6c5c3aaf7ed2eac4484f1",
+  "nextRunAt": 1775664900000,
+  "lastRunAt": 1775661402987,
+  "lastOutcome": "success",
+  "lastError": null,
+  "updatedAt": "2026-04-08T15:16:42.988Z"
+}

package/cloud-runtime/standalone/state/automations/active/c4300b01-1203-40fe-b3a9-b9fb9ec0c5cc.md

@@ -0,0 +1,15 @@
+---
+id: c4300b01-1203-40fe-b3a9-b9fb9ec0c5cc
+name: 'Agx Agent: Work On Linear Tickets'
+projectId: f354bbf2-cfed-473f-890c-e592209313da
+state: active
+trigger:
+  type: scheduled
+  cadence: 15 * * * *
+  cronExpr: 15 * * * *
+target:
+  type: prompt_job
+  provider: claude
+createdAt: '2026-04-08T09:50:53.793Z'
+---
+Execute `/Users/mendrika/Projects/Agents/agx-game-vault/agx-game-vault/scheduled-tasks/work-linear-tickets.md`

package/cloud-runtime/standalone/state/linearRunScripts.test.ts

@@ -0,0 +1,99 @@
+import {
+  getLinearRunScriptsStorageKey,
+  loadLinearRunScripts,
+  persistLinearRunScripts,
+} from "./linearRunScripts";
+
+type LocalStorageMap = Record<string, string>;
+
+function withFakeLocalStorage<T>(callback: (storage: LocalStorageMap) => T): T {
+  const originalWindow = globalThis.window;
+  const storage: LocalStorageMap = {};
+  const fakeLocalStorage = {
+    getItem(key: string) {
+      return storage[key] ?? null;
+    },
+    setItem(key: string, value: string) {
+      storage[key] = value;
+    },
+    removeItem(key: string) {
+      delete storage[key];
+    },
+  };
+  globalThis.window = { localStorage: fakeLocalStorage } as unknown as Window;
+
+  try {
+    return callback(storage);
+  } finally {
+    globalThis.window = originalWindow;
+  }
+}
+
+describe("linearRunScripts", () => {
+  test("persists and restores scripts per project slug", () => {
+    withFakeLocalStorage((storage) => {
+      const key = getLinearRunScriptsStorageKey("agx-cloud");
+      expect(loadLinearRunScripts("agx-cloud")).toEqual({
+        activeScriptId: null,
+        scripts: [],
+      });
+
+      persistLinearRunScripts("agx-cloud", {
+        activeScriptId: "script-1",
+        scripts: [
+          {
+            id: "script-1",
+            name: "Investigation",
+            prompt: "Read {{ticket.identifier}} first.",
+            createdAt: "2026-04-08T01:00:00.000Z",
+            updatedAt: "2026-04-08T02:00:00.000Z",
+          },
+        ],
+      });
+
+      expect(storage[key]).toContain("Investigation");
+      expect(loadLinearRunScripts("agx-cloud")).toEqual({
+        activeScriptId: "script-1",
+        scripts: [
+          {
+            id: "script-1",
+            name: "Investigation",
+            prompt: "Read {{ticket.identifier}} first.",
+            createdAt: "2026-04-08T01:00:00.000Z",
+            updatedAt: "2026-04-08T02:00:00.000Z",
+          },
+        ],
+      });
+    });
+  });
+
+  test("clears invalid active script ids while preserving valid scripts", () => {
+    withFakeLocalStorage((storage) => {
+      storage[getLinearRunScriptsStorageKey("agx-cloud")] = JSON.stringify({
+        activeScriptId: "missing-script",
+        scripts: [
+          {
+            id: "script-1",
+            name: "Implementation",
+            prompt: "Implement carefully.",
+            createdAt: "2026-04-08T01:00:00.000Z",
+            updatedAt: "2026-04-08T02:00:00.000Z",
+          },
+        ],
+      });
+
+      expect(loadLinearRunScripts("agx-cloud")).toEqual({
+        activeScriptId: null,
+        scripts: [
+          {
+            id: "script-1",
+            name: "Implementation",
+            prompt: "Implement carefully.",
+            createdAt: "2026-04-08T01:00:00.000Z",
+            updatedAt: "2026-04-08T02:00:00.000Z",
+          },
+        ],
+      });
+    });
+  });
+});