@mndrk/agx 2.0.48 → 2.0.49

package/cloud-runtime/standalone/app/api/chat/route.ts

@@ -1,18 +1,18 @@
 import { NextRequest } from "next/server";
-import { type StreamProjectContext, type StreamProjectDetail } from "@/lib/stream-multiplexer";
 import {
   mergeComposerRouting,
   normalizeComposerRouting,
   orderParticipantIds,
 } from "@/lib/chat/composer-routing";
+import {
+  findProjectMentionSlugs,
+  normalizeProjectSlug,
+  resolveProjectContext,
+} from "@/lib/chat/project-context";
 import { loadDbParticipants } from "@/lib/agent-participants";
 import { createChatRun, loadHistory, saveMessages, sweepStaleWorkingReactions } from "@/lib/history-store";
 import { finalizeAttachments } from "@/lib/attachment-store";
 import { getSQLiteDb } from "@/lib/sqlite-query-adapter";
-import { db } from "@/lib/db-instance";
-import { buildExecutionProvenance, getProjectSkills, getProjectVariables, getProjectMemory } from "@/lib/db";
-import { listResolvedRepoKnowledge } from "@/lib/repo-knowledge";
-import { getKnowledgeNote } from "@/lib/knowledge-notes";
 import { LOCAL_USER } from "@/lib/auth-mode";
 import { deactivateSchedulesByRootMessageId } from "@/src/graph/store";
 import type { GroupMessage, Participant } from "@/lib/types";
@@ -42,7 +42,6 @@ interface ChatRequestBody {
 const MAX_HISTORY_CHARS = 200_000;
 const SUMMARY_MARKER = "<!-- thread-summary -->";
 const CHAT_MENTION_PATTERN = /@([A-Za-z0-9_-]+)/g;
-const PROJECT_MENTION_PATTERN = /@~project:([a-z0-9][a-z0-9-]*)/gi;
 
 type ParticipantNameMap = Record<string, { name: string }>;
 
@@ -278,163 +277,6 @@ function toActiveParticipantIds(input: unknown): string[] {
   return ids;
 }
 
-function normalizeProjectSlug(input: unknown): string {
-  if (typeof input !== "string") return "";
-  return input.trim().toLowerCase();
-}
-
-function findProjectMentionSlugs(prompt: string): string[] {
-  const slugs = new Set<string>();
-  for (const match of prompt.matchAll(PROJECT_MENTION_PATTERN)) {
-    const slug = normalizeProjectSlug(match[1]);
-    if (slug) slugs.add(slug);
-  }
-  return Array.from(slugs);
-}
-
-function toStreamProjectDetail(project: {
-  id: string;
-  slug: string;
-  name: string;
-  description?: string | null;
-  ci_cd_info?: string | null;
-  workflow_id?: string | null;
-  repos?: Array<{ name: string; path?: string | null; notes?: string | null }>;
-}): StreamProjectDetail {
-  return {
-    id: project.id,
-    slug: project.slug,
-    name: project.name,
-    description: project.description ?? null,
-    ciCdInfo: project.ci_cd_info ?? null,
-    workflowId: project.workflow_id ?? null,
-    repos: (project.repos ?? []).map((repo) => ({
-      name: repo.name,
-      path: repo.path ?? null,
-      notes: repo.notes ?? null,
-    })),
-  };
-}
-
-async function resolveProjectContext(
-  scopedProjectSlug: string,
-  mentionedProjectSlugs: string[],
-  participants: Participant[] = []
-): Promise<StreamProjectContext | undefined> {
-  const slugsToFetch = new Set<string>();
-  if (scopedProjectSlug) slugsToFetch.add(scopedProjectSlug);
-  for (const slug of mentionedProjectSlugs) {
-    if (slug) slugsToFetch.add(slug);
-  }
-  if (slugsToFetch.size === 0) return undefined;
-
-  const rows = await Promise.all(
-    Array.from(slugsToFetch).map(async (slug) => {
-      try {
-        const project = await db.getProjectWithRepos(slug, LOCAL_USER.id);
-        return [slug, project] as const;
-      } catch (error) {
-        console.warn("Failed to load project context", { slug, error });
-        return [slug, null] as const;
-      }
-    })
-  );
-
-  const bySlug = new Map<string, NonNullable<(typeof rows)[number][1]>>();
-  for (const [slug, row] of rows) {
-    if (row) bySlug.set(slug, row);
-  }
-
-  const activeProject = scopedProjectSlug ? bySlug.get(scopedProjectSlug) : undefined;
-  const mentionedProjects = mentionedProjectSlugs
-    .map((slug) => bySlug.get(slug))
-    .filter((project): project is NonNullable<typeof project> => Boolean(project))
-    .map((project) => toStreamProjectDetail(project));
-
-  if (!activeProject && mentionedProjects.length === 0) {
-    return undefined;
-  }
-
-  // Load project-level resources for the active project (skills, variables, memory)
-  let skills: Array<{ file: string; condition?: string }> | undefined;
-  let variables: Array<{ key: string; value: string }> | undefined;
-  let memory: Array<{ content: string; source?: string }> | undefined;
-  let repoKnowledge: StreamProjectContext["repoKnowledge"];
-  let provenanceByAgentId: StreamProjectContext["provenanceByAgentId"];
-
-  if (activeProject) {
-    try {
-      const [projectSkills, projectVars, projectMem] = await Promise.all([
-        getProjectSkills(activeProject.id),
-        getProjectVariables(activeProject.id),
-        getProjectMemory(activeProject.id, "human"),
-      ]);
-      const projectSystemNote = getKnowledgeNote("project", activeProject.id);
-      if (projectSkills.length > 0) {
-        skills = projectSkills.map((s) => ({ file: s.file, ...(s.condition ? { condition: s.condition } : {}) }));
-      }
-      if (projectVars.length > 0) {
-        variables = projectVars.map((v) => ({ key: v.key, value: v.value }));
-      }
-      if (projectMem.length > 0) {
-        memory = projectMem.map((m) => ({ content: m.content, ...(m.source ? { source: m.source } : {}) }));
-      }
-      if (projectSystemNote?.content) {
-        memory = [
-          ...(memory ?? []),
-          { content: projectSystemNote.content, source: "system-note" },
-        ];
-      }
-      const resolvedRepoKnowledge = listResolvedRepoKnowledge(activeProject.repos ?? []).map((entry) => ({
-        repoName: entry.repoName,
-        path: entry.path ?? null,
-        content:
-          entry.producer === "system"
-            ? `[System-generated] ${entry.content}`
-            : entry.content,
-      }));
-      if (resolvedRepoKnowledge.length > 0) {
-        repoKnowledge = resolvedRepoKnowledge;
-      }
-      if (participants.length > 0) {
-        const sqlite = getSQLiteDb();
-        provenanceByAgentId = {};
-        for (const participant of participants) {
-          const agentMemoryEntries = sqlite
-            .prepare(
-              "SELECT id, content FROM agent_memory WHERE agent_id = ? ORDER BY created_at DESC LIMIT 20"
-            )
-            .all(participant.id) as Array<{ id: string; content: string }>;
-          provenanceByAgentId[participant.id] = await buildExecutionProvenance(
-            participant.id,
-            activeProject.id,
-            participant.skills ?? [],
-            agentMemoryEntries
-          );
-        }
-      }
-    } catch (e) {
-      console.warn("Failed to load project resources", { projectId: activeProject.id, error: e });
-    }
-  }
-
-  return {
-    activeProject: activeProject
-      ? {
-          id: activeProject.id,
-          slug: activeProject.slug,
-          name: activeProject.name,
-        }
-      : undefined,
-    mentionedProjects: mentionedProjects.length > 0 ? mentionedProjects : undefined,
-    skills,
-    variables,
-    memory,
-    repoKnowledge,
-    provenanceByAgentId,
-  };
-}
-
 export async function POST(request: NextRequest) {
   const body = (await request.json().catch(() => ({}))) as ChatRequestBody;
   const prompt =

package/cloud-runtime/standalone/app/api/schedules/route.ts

@@ -15,6 +15,7 @@ export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
 const DEFAULT_INTERVAL_MS = 15_000;
+const DEFAULT_MAX_CONSECUTIVE_FAILURES = 3;
 
 const ActivateSchema = z.object({
   action: z.literal("activate"),
@@ -35,12 +36,13 @@ const RequestSchema = z.discriminatedUnion("action", [ActivateSchema, StopSchema
  * The work node (verify-and-route) is downstream of the conditional in the real
  * graph but for v1 the cron just checks if agents are idle — the MC handles nudging.
  */
-const STEER_PROMPT = `Review the conversation so far and produce exactly one message that does both of these things together:
+const STEER_PROMPT = `Review the conversation so far and determine whether the thread is actually ready to move into review.
+If it is not ready, produce exactly one message that does both of these things together:
 1. Briefly assess what has been accomplished and what remains.
 2. Give the team the concrete next steps needed to move toward shipping.
 
 Do not split status and instructions into separate responses. Keep it to one concise message.
-If everything is done, say exactly "[done]" so the system knows to stop.`;
+Only mark the work complete when it is truly ready to stop ship mode and move into review.`;
 
 function buildThreadMonitorGraph(
   rootMessageId: string,
@@ -131,6 +133,9 @@ function buildThreadMonitorGraph(
     },
     schedule: {
       ...createThreadMonitorSchedule(resetNodeIds, intervalMs),
+      name: "Ship mode",
+      description: "Automatically steers an idle thread toward completion.",
+      maxConsecutiveFailures: DEFAULT_MAX_CONSECUTIVE_FAILURES,
       rootMessageId,
     },
     versionHistory: [],
@@ -181,6 +186,10 @@ export async function POST(request: NextRequest) {
       const reactivated = activateGraphSchedule(existingGraph, {
         intervalMs,
         resetNodeIds: existingGraph.schedule?.resetNodeIds ?? ["pull-status", "idle-check"],
+        name: existingGraph.schedule?.name ?? "Ship mode",
+        description: existingGraph.schedule?.description ?? "Automatically steers an idle thread toward completion.",
+        maxConsecutiveFailures:
+          existingGraph.schedule?.maxConsecutiveFailures ?? DEFAULT_MAX_CONSECUTIVE_FAILURES,
         rootMessageId: body.rootMessageId,
         nowIso: new Date().toISOString(),
       });

package/cloud-runtime/standalone/components/chat-ui/ChatContainer.tsx

@@ -423,8 +423,6 @@ export function ChatContainer({
           if (cancelled || !data.activeRootMessageIds) return;
           setAutoModeThreads((prev) => {
             const next = new Set(data.activeRootMessageIds as string[]);
-            // Preserve any locally-toggled entries not yet on server
-            for (const id of prev) next.add(id);
             if (next.size === prev.size && [...next].every((id) => prev.has(id))) return prev;
             return next;
           });
@@ -1214,16 +1212,6 @@ export function ChatContainer({
         return;
       }
 
-      // User message turns off autonomous mode
-      if (autoMode && openThreadId) {
-        setAutoModeThreads((prev) => { const next = new Set(prev); next.delete(openThreadId); return next; });
-        fetch("/api/schedules", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ action: "stop", rootMessageId: openThreadId }),
-        }).catch((err) => console.error("Failed to deactivate schedule:", err));
-      }
-
       let threadId = activeThreadId;
       if (!threadId) {
         const created = await createThread();
@@ -1281,7 +1269,6 @@ export function ChatContainer({
     },
     [
       activeThreadId,
-      autoMode,
       pendingAutoMode,
       createThread,
       handleSearchCommand,

package/cloud-runtime/standalone/lib/chat/project-context.ts

@@ -0,0 +1,169 @@
+import { type StreamProjectContext, type StreamProjectDetail } from "@/lib/stream-multiplexer";
+import { getSQLiteDb } from "@/lib/sqlite-query-adapter";
+import { db } from "@/lib/db-instance";
+import { buildExecutionProvenance, getProjectSkills, getProjectVariables, getProjectMemory } from "@/lib/db";
+import { listResolvedRepoKnowledge } from "@/lib/repo-knowledge";
+import { getKnowledgeNote } from "@/lib/knowledge-notes";
+import { LOCAL_USER } from "@/lib/auth-mode";
+import type { Participant } from "@/lib/types";
+
+const PROJECT_MENTION_PATTERN = /@~project:([a-z0-9][a-z0-9-]*)/gi;
+
+export function normalizeProjectSlug(input: unknown): string {
+  if (typeof input !== "string") return "";
+  return input.trim().toLowerCase();
+}
+
+export function findProjectMentionSlugs(prompt: string): string[] {
+  const slugs = new Set<string>();
+  for (const match of prompt.matchAll(PROJECT_MENTION_PATTERN)) {
+    const slug = normalizeProjectSlug(match[1]);
+    if (slug) slugs.add(slug);
+  }
+  return Array.from(slugs);
+}
+
+function toStreamProjectDetail(project: {
+  id: string;
+  slug: string;
+  name: string;
+  description?: string | null;
+  ci_cd_info?: string | null;
+  workflow_id?: string | null;
+  repos?: Array<{ name: string; path?: string | null; notes?: string | null }>;
+}): StreamProjectDetail {
+  return {
+    id: project.id,
+    slug: project.slug,
+    name: project.name,
+    description: project.description ?? null,
+    ciCdInfo: project.ci_cd_info ?? null,
+    workflowId: project.workflow_id ?? null,
+    repos: (project.repos ?? []).map((repo) => ({
+      name: repo.name,
+      path: repo.path ?? null,
+      notes: repo.notes ?? null,
+    })),
+  };
+}
+
+export async function resolveProjectContext(
+  scopedProjectSlug: string,
+  mentionedProjectSlugs: string[],
+  participants: Participant[] = []
+): Promise<StreamProjectContext | undefined> {
+  const slugsToFetch = new Set<string>();
+  if (scopedProjectSlug) slugsToFetch.add(scopedProjectSlug);
+  for (const slug of mentionedProjectSlugs) {
+    if (slug) slugsToFetch.add(slug);
+  }
+  if (slugsToFetch.size === 0) return undefined;
+
+  const rows = await Promise.all(
+    Array.from(slugsToFetch).map(async (slug) => {
+      try {
+        const project = await db.getProjectWithRepos(slug, LOCAL_USER.id);
+        return [slug, project] as const;
+      } catch (error) {
+        console.warn("Failed to load project context", { slug, error });
+        return [slug, null] as const;
+      }
+    })
+  );
+
+  const bySlug = new Map<string, NonNullable<(typeof rows)[number][1]>>();
+  for (const [slug, row] of rows) {
+    if (row) bySlug.set(slug, row);
+  }
+
+  const activeProject = scopedProjectSlug ? bySlug.get(scopedProjectSlug) : undefined;
+  const mentionedProjects = mentionedProjectSlugs
+    .map((slug) => bySlug.get(slug))
+    .filter((project): project is NonNullable<typeof project> => Boolean(project))
+    .map((project) => toStreamProjectDetail(project));
+
+  if (!activeProject && mentionedProjects.length === 0) {
+    return undefined;
+  }
+
+  let skills: Array<{ file: string; condition?: string }> | undefined;
+  let variables: Array<{ key: string; value: string }> | undefined;
+  let memory: Array<{ content: string; source?: string }> | undefined;
+  let repoKnowledge: StreamProjectContext["repoKnowledge"];
+  let provenanceByAgentId: StreamProjectContext["provenanceByAgentId"];
+
+  if (activeProject) {
+    try {
+      const [projectSkills, projectVars, projectMem] = await Promise.all([
+        getProjectSkills(activeProject.id),
+        getProjectVariables(activeProject.id),
+        getProjectMemory(activeProject.id, "human"),
+      ]);
+      const projectSystemNote = getKnowledgeNote("project", activeProject.id);
+      if (projectSkills.length > 0) {
+        skills = projectSkills.map((skill) => ({
+          file: skill.file,
+          ...(skill.condition ? { condition: skill.condition } : {}),
+        }));
+      }
+      if (projectVars.length > 0) {
+        variables = projectVars.map((variable) => ({ key: variable.key, value: variable.value }));
+      }
+      if (projectMem.length > 0) {
+        memory = projectMem.map((entry) => ({
+          content: entry.content,
+          ...(entry.source ? { source: entry.source } : {}),
+        }));
+      }
+      if (projectSystemNote?.content) {
+        memory = [
+          ...(memory ?? []),
+          { content: projectSystemNote.content, source: "system-note" },
+        ];
+      }
+      const resolvedRepoKnowledge = listResolvedRepoKnowledge(activeProject.repos ?? []).map((entry) => ({
+        repoName: entry.repoName,
+        path: entry.path ?? null,
+        content: entry.producer === "system" ? `[System-generated] ${entry.content}` : entry.content,
+      }));
+      if (resolvedRepoKnowledge.length > 0) {
+        repoKnowledge = resolvedRepoKnowledge;
+      }
+      if (participants.length > 0) {
+        const sqlite = getSQLiteDb();
+        provenanceByAgentId = {};
+        for (const participant of participants) {
+          const agentMemoryEntries = sqlite
+            .prepare(
+              "SELECT id, content FROM agent_memory WHERE agent_id = ? ORDER BY created_at DESC LIMIT 20"
+            )
+            .all(participant.id) as Array<{ id: string; content: string }>;
+          provenanceByAgentId[participant.id] = await buildExecutionProvenance(
+            participant.id,
+            activeProject.id,
+            participant.skills ?? [],
+            agentMemoryEntries
+          );
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to load project resources", { projectId: activeProject.id, error });
+    }
+  }
+
+  return {
+    activeProject: activeProject
+      ? {
+          id: activeProject.id,
+          slug: activeProject.slug,
+          name: activeProject.name,
+        }
+      : undefined,
+    mentionedProjects: mentionedProjects.length > 0 ? mentionedProjects : undefined,
+    skills,
+    variables,
+    memory,
+    repoKnowledge,
+    provenanceByAgentId,
+  };
+}

package/cloud-runtime/standalone/lib/orchestrator/runtime.ts

@@ -1,6 +1,7 @@
 import { getQueue, QUEUE_NAMES } from "@/lib/queue/boss";
 import { taskProcessor } from "@/lib/orchestrator/processor";
 import { chatProcessor } from "@/lib/orchestrator/chat-processor";
+import { ensureScheduleRuntime } from "@/lib/orchestrator/schedule-runtime";
 import { writeDebugLog } from "@/lib/debug-log";
 
 let bootstrapPromise: Promise<void> | null = null;
@@ -13,6 +14,7 @@ export async function ensureOrchestratorRuntime(): Promise<void> {
     const queue = await getQueue();
     await queue.work(QUEUE_NAMES.TASK_PROCESS, taskProcessor, { batchSize: 5 });
     await queue.work(QUEUE_NAMES.CHAT_RUN_PROCESS, chatProcessor, { batchSize: 2 });
+    await ensureScheduleRuntime();
     writeDebugLog("orchestrator.bootstrap.ready", {
       queues: [QUEUE_NAMES.TASK_PROCESS, QUEUE_NAMES.CHAT_RUN_PROCESS],
     });

package/cloud-runtime/standalone/lib/orchestrator/schedule-runtime.ts

@@ -0,0 +1,76 @@
+import { writeDebugLog } from "@/lib/debug-log";
+import { createDispatchFunction } from "@/src/graph/function-executor";
+import { pollSchedules } from "@/src/graph/schedule-runner";
+import { createDispatchWork } from "@/src/graph/work-dispatcher";
+
+const DEFAULT_SCHEDULE_POLL_INTERVAL_MS = 5_000;
+
+let pollIntervalHandle: NodeJS.Timeout | null = null;
+let pollInFlight: Promise<void> | null = null;
+
+function isSchedulePollingEnabled(): boolean {
+  return process.env.AGX_DISABLE_SCHEDULE_POLLING !== "1";
+}
+
+function getSchedulePollIntervalMs(): number {
+  const raw = Number(process.env.AGX_SCHEDULE_POLL_INTERVAL_MS);
+  if (!Number.isFinite(raw)) return DEFAULT_SCHEDULE_POLL_INTERVAL_MS;
+  return Math.max(1_000, raw);
+}
+
+async function pollSchedulesOnce(): Promise<void> {
+  if (pollInFlight) {
+    return pollInFlight;
+  }
+
+  pollInFlight = (async () => {
+    const result = await pollSchedules({
+      dispatchFunction: createDispatchFunction(),
+      dispatchWork: createDispatchWork(),
+    });
+
+    if (result.errors.length > 0) {
+      writeDebugLog("schedule_runtime.poll.error", {
+        errorCount: result.errors.length,
+        graphIds: result.errors.map((entry) => entry.graphId),
+      });
+    }
+  })()
+    .catch((error) => {
+      writeDebugLog("schedule_runtime.poll.exception", { error });
+      console.error("[schedule-runtime] Poll failed:", error);
+    })
+    .finally(() => {
+      pollInFlight = null;
+    });
+
+  return pollInFlight;
+}
+
+export async function ensureScheduleRuntime(): Promise<void> {
+  if (!isSchedulePollingEnabled() || pollIntervalHandle) {
+    return;
+  }
+
+  const intervalMs = getSchedulePollIntervalMs();
+  writeDebugLog("schedule_runtime.start", { intervalMs });
+
+  pollIntervalHandle = setInterval(() => {
+    void pollSchedulesOnce();
+  }, intervalMs);
+  if (typeof pollIntervalHandle.unref === "function") {
+    pollIntervalHandle.unref();
+  }
+
+  await pollSchedulesOnce();
+}
+
+export async function stopScheduleRuntime(): Promise<void> {
+  if (pollIntervalHandle) {
+    clearInterval(pollIntervalHandle);
+    pollIntervalHandle = null;
+  }
+  if (pollInFlight) {
+    await pollInFlight;
+  }
+}