@mndrk/agx 2.0.26 → 2.0.33

package/cloud-runtime/standalone/app/api/chat-runs/[id]/signal/route.ts

@@ -0,0 +1,32 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getQueue, QUEUE_NAMES } from "@/lib/queue/boss";
+import { LOCAL_USER } from "@/lib/auth-mode";
+import type { ChatRunJobData } from "@/lib/orchestrator/chat-types";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = await request.json().catch(() => ({}));
+  const signal = typeof body?.signal === "string" ? body.signal.trim() : "";
+
+  if (signal !== "cancel") {
+    return NextResponse.json({ error: "Unsupported signal" }, { status: 400 });
+  }
+
+  const queue = await getQueue();
+  const jobId = await queue.send<ChatRunJobData>(QUEUE_NAMES.CHAT_RUN_PROCESS, {
+    chatRunId: id,
+    userId: LOCAL_USER.id,
+    signal: "cancel",
+    payload: {
+      reason: typeof body?.reason === "string" ? body.reason.trim() : undefined,
+    },
+  });
+
+  return NextResponse.json({ ok: true, jobId });
+}

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

@@ -0,0 +1,37 @@
+import { NextRequest, NextResponse } from "next/server";
+import { listChatRuns } from "@/lib/history-store";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(request: NextRequest) {
+  const threadId = request.nextUrl.searchParams.get("threadId");
+  const statusParam = request.nextUrl.searchParams.get("status");
+  const limitParam = request.nextUrl.searchParams.get("limit");
+  const limit = limitParam ? Number.parseInt(limitParam, 10) : undefined;
+
+  const runs = await listChatRuns({
+    threadId,
+    status:
+      statusParam === "active" ||
+      statusParam === "queued" ||
+      statusParam === "running" ||
+      statusParam === "awaiting_user" ||
+      statusParam === "blocked" ||
+      statusParam === "completed" ||
+      statusParam === "failed" ||
+      statusParam === "cancelled"
+        ? statusParam
+        : undefined,
+    limit,
+  });
+
+  return NextResponse.json(
+    runs.map((run) => ({
+      chatRunId: run.id,
+      threadId: run.threadId,
+      rootMessageId: run.rootMessageId,
+      status: run.status,
+    }))
+  );
+}

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

@@ -3,6 +3,7 @@ import {
   loadHistory,
   clearHistory,
   clearRootThread,
+  deleteMessage,
   saveMessages,
   sweepStaleWorkingReactions,
 } from "@/lib/history-store";
@@ -61,6 +62,11 @@ export async function DELETE(request: NextRequest) {
     return Response.json({ error: "threadId is required" }, { status: 400 });
   }
   const rootMessageId = request.nextUrl.searchParams.get("rootMessageId")?.trim() ?? "";
+  const messageId = request.nextUrl.searchParams.get("messageId")?.trim() ?? "";
+  if (messageId) {
+    await deleteMessage(threadId, messageId);
+    return Response.json({ ok: true });
+  }
   if (rootMessageId) {
     await clearRootThread(threadId, rootMessageId);
     return Response.json({ ok: true });

package/cloud-runtime/standalone/app/api/knowledge-notes/route.ts

@@ -0,0 +1,53 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getKnowledgeNote, upsertKnowledgeNote, type KnowledgeNoteScope } from "@/lib/knowledge-notes";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+/** GET /api/knowledge-notes?scope=project&subjectId=xxx */
+export async function GET(request: NextRequest) {
+  try {
+    const url = new URL(request.url);
+    const scope = url.searchParams.get("scope") as KnowledgeNoteScope | null;
+    const subjectId = url.searchParams.get("subjectId");
+
+    if (!scope || !subjectId) {
+      return NextResponse.json({ error: "scope and subjectId are required" }, { status: 400 });
+    }
+
+    const note = getKnowledgeNote(scope, subjectId);
+    return NextResponse.json({ note });
+  } catch (error) {
+    console.error("Error fetching knowledge note:", error);
+    return NextResponse.json({ error: "Failed to fetch knowledge note" }, { status: 500 });
+  }
+}
+
+/** PUT /api/knowledge-notes — update a knowledge note's content */
+export async function PUT(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const scope = body.scope as KnowledgeNoteScope | undefined;
+    const subjectId = typeof body.subjectId === "string" ? body.subjectId.trim() : "";
+    const content = typeof body.content === "string" ? body.content : "";
+
+    if (!scope || !subjectId) {
+      return NextResponse.json({ error: "scope and subjectId are required" }, { status: 400 });
+    }
+
+    const { note, changed } = upsertKnowledgeNote({
+      scope,
+      subjectId,
+      content,
+      changeSummary: "Manual edit",
+      sourceType: "task_completion",
+      sourceId: "manual-edit",
+      metadata: { manual_edit: true },
+    });
+
+    return NextResponse.json({ note, changed });
+  } catch (error) {
+    console.error("Error updating knowledge note:", error);
+    return NextResponse.json({ error: "Failed to update knowledge note" }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/app/api/projects/[id]/memory/route.ts

@@ -1,5 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 import { getProjectMemory, addProjectMemory, deleteProjectMemory } from "@/lib/db";
+import { getKnowledgeNote } from "@/lib/knowledge-notes";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
@@ -15,6 +16,22 @@ export async function GET(request: NextRequest, context: RouteContext) {
       rawProducer === "human" || rawProducer === "system"
         ? rawProducer
         : undefined;
+    if (producer === "system") {
+      const note = getKnowledgeNote("project", projectId);
+      const memory = note
+        ? [{
+          id: note.id,
+          project_id: projectId,
+          content: note.content,
+          source: note.changeSummary ?? "system-note",
+          producer: "system" as const,
+          created_at: note.updatedAt,
+          updated_at: note.updatedAt,
+        }]
+        : [];
+      return NextResponse.json({ memory });
+    }
+
     const memory = await getProjectMemory(projectId, producer);
     return NextResponse.json({ memory });
   } catch (error) {

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

@@ -1,15 +1,6 @@
 import { NextResponse } from "next/server";
 import { spawnSync } from "child_process";
-
-type ProviderId = "claude" | "gemini" | "ollama" | "codex" | "zai";
-
-const PROVIDERS: Array<{ id: ProviderId; label: string; bin: string }> = [
-  { id: "gemini", label: "Gemini", bin: "gemini" },
-  { id: "claude", label: "Claude", bin: "claude" },
-  { id: "ollama", label: "Ollama", bin: "ollama" },
-  { id: "codex", label: "Codex", bin: "codex" },
-  { id: "zai", label: "Z.AI", bin: "claude" },
-];
+import { PROVIDER_CLIS } from "@/lib/provider-clis";
 
 function commandExists(bin: string): boolean {
   try {
@@ -27,11 +18,16 @@ function commandExists(bin: string): boolean {
 // GET /api/providers
 // Returns providers available on the machine (derived from installed CLIs).
 export async function GET() {
-  const available = PROVIDERS.filter((p) => commandExists(p.bin)).map((p) => ({
+  const available = PROVIDER_CLIS.filter((p) => commandExists(p.bin)).map((p) => ({
     id: p.id,
     label: p.label,
   }));
 
-  return NextResponse.json({ providers: available });
+  return NextResponse.json({
+    providers: available,
+    supportedProviders: PROVIDER_CLIS.map((provider) => ({
+      id: provider.id,
+      label: provider.label,
+    })),
+  });
 }
-

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

@@ -4,6 +4,7 @@ import { scheduleTickIfDue, isScheduleTickComplete } from '@/src/graph/schedule'
 import { schedulerTick } from '@/src/graph/scheduler';
 import { executeNode } from '@/src/graph/executor';
 import { createDispatchFunction } from '@/src/graph/function-executor';
+import { createDispatchWork } from '@/src/graph/work-dispatcher';
 import type { ExecutionGraph, ConditionalNode, FunctionNode } from '@/src/graph/types';
 
 export const runtime = 'nodejs';
@@ -86,6 +87,7 @@ export async function GET(request: NextRequest) {
   const nodes: Record<string, unknown>[] = [];
   let currentGraph: ExecutionGraph = tickResult.graph;
   const dispatchFunction = createDispatchFunction();
+  const dispatchWork = createDispatchWork();
   const MAX_LOOPS = 10;
 
   for (let loop = 0; loop < MAX_LOOPS; loop++) {
@@ -168,13 +170,31 @@ export async function GET(request: NextRequest) {
     // Log work nodes (not executed by debug endpoint)
     for (const nodeId of pass.workToRun) {
       const node = currentGraph.nodes[nodeId];
-      nodes.push({
+      const entry: Record<string, unknown> = {
         node: nodeId,
         type: 'work',
         input: node,
-        processing: 'ready to dispatch (not executed in debug)',
+        processing: shouldRun ? 'executing...' : 'ready to dispatch (add &run=1)',
         output: { status: node?.status },
-      });
+      };
+
+      if (shouldRun && node?.type === 'work') {
+        const startMs = Date.now();
+        try {
+          const execResult = await executeNode(currentGraph, nodeId, { dispatchFunction, dispatchWork });
+          currentGraph = execResult.graph;
+          entry.processing = `executed in ${Date.now() - startMs}ms`;
+          entry.output = {
+            status: currentGraph.nodes[nodeId]?.status,
+            data: 'output' in currentGraph.nodes[nodeId] ? currentGraph.nodes[nodeId].output : null,
+          };
+        } catch (err) {
+          entry.processing = `failed after ${Date.now() - startMs}ms`;
+          entry.output = { status: 'error', error: err instanceof Error ? err.message : String(err) };
+        }
+      }
+
+      nodes.push(entry);
     }
 
     if (isScheduleTickComplete(currentGraph)) break;

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

@@ -1,6 +1,7 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { pollSchedules, executeScheduleTick } from '@/src/graph/schedule-runner';
 import { createDispatchFunction } from '@/src/graph/function-executor';
+import { createDispatchWork } from '@/src/graph/work-dispatcher';
 
 export const runtime = 'nodejs';
 export const dynamic = 'force-dynamic';
@@ -18,10 +19,11 @@ export async function POST(request: NextRequest) {
   try {
     const body = await request.json().catch(() => ({}));
     const dispatchFunction = createDispatchFunction();
+    const dispatchWork = createDispatchWork();
 
     if (body.taskId) {
       // Poll a specific task
-      const result = await executeScheduleTick(body.taskId, { dispatchFunction });
+      const result = await executeScheduleTick(body.taskId, { dispatchFunction, dispatchWork });
 
       return NextResponse.json({
         success: result.fired,
@@ -31,7 +33,7 @@ export async function POST(request: NextRequest) {
     }
 
     // Poll all active schedules
-    const result = await pollSchedules({ dispatchFunction });
+    const result = await pollSchedules({ dispatchFunction, dispatchWork });
 
     return NextResponse.json({
       success: true,
@@ -80,4 +82,4 @@ export async function GET() {
       { status: 500 },
     );
   }
-}
+}

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

@@ -35,7 +35,12 @@ 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. Verify what's been accomplished and what remains. If work is incomplete, give the team clear next-step instructions to move toward shipping. If everything is done, say exactly "[done]" so the system knows to stop. Be concise — focus on what's next, not recaps.`;
+const STEER_PROMPT = `Review the conversation so far and 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.`;
 
 function buildThreadMonitorGraph(
   rootMessageId: string,
@@ -49,9 +54,10 @@ function buildThreadMonitorGraph(
     type: "function",
     status: "pending",
     deps: [],
-    kind: "bash",
+    kind: "internal",
     title: "Pull thread status",
-    command: `curl -s "http://localhost:41741/api/history/status?format=compact&rootMessageId=${rootMessageId}"`,
+    command: "thread-status",
+    args: { rootMessageId },
   };
 
   const idleCheckNode: ConditionalNode = {
@@ -82,21 +88,10 @@ function buildThreadMonitorGraph(
     type: "function",
     status: "pending",
     deps: ["steer"],
-    kind: "bash",
+    kind: "internal",
     title: "Act on steer result",
-    command: [
-      `STEER_JSON=$(curl -s "http://localhost:41741/api/graphs/sched-${rootMessageId}/nodes/steer")`,
-      `IS_DONE=$(echo "$STEER_JSON" | jq -r '.output.isDone // false')`,
-      `MESSAGE=$(echo "$STEER_JSON" | jq -r '.output.message // empty')`,
-      `if [ "$IS_DONE" = "true" ]; then`
-        + ` curl -s -X POST "http://localhost:41741/api/schedules" -H "Content-Type: application/json" -d '{"action":"stop","rootMessageId":"${rootMessageId}"}';`
-        + ` curl -s -X PATCH "http://localhost:41741/api/threads" -H "Content-Type: application/json" -d '{"rootMessageId":"${rootMessageId}","status":"in-review"}';`
-        + ` echo '{"done":true,"action":"stopped_and_in_review"}';`
-        + ` else`
-        + ` agx chat send "$MESSAGE" --thread ${rootMessageId} --role agent --max-rounds 10;`
-        + ` echo '{"done":false,"action":"sent_next_steps"}';`
-        + ` fi`,
-    ].join(" && "),
+    command: "ship-mode-act",
+    args: { rootMessageId, steerNodeId: "steer" },
     timeoutMs: 300_000, // 5 min — agents need time
   };
 

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

@@ -1,6 +1,7 @@
 import { NextResponse } from "next/server";
 import { spawnSync } from "child_process";
 import { MAX_WORKERS, WRITE_QPS_CEILING } from "@/lib/limits";
+import { PROVIDER_CLIS } from "@/lib/provider-clis";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
@@ -61,11 +62,11 @@ export async function GET() {
   // 3. CLI providers
   const cliTools = [
     { id: "agx", bin: "agx", label: "Installed" },
-    { id: "claude", bin: "claude", label: "Installed" },
-    { id: "ollama", bin: "ollama", label: "Installed" },
-    { id: "gemini", bin: "gemini", label: "Installed" },
-    { id: "codex", bin: "codex", label: "Installed" },
-    { id: "zai", bin: "claude", label: "Via Claude CLI + Z.AI API key" },
+    ...PROVIDER_CLIS.map((provider) => ({
+      id: provider.id,
+      bin: provider.bin,
+      label: provider.statusLabel ?? "Installed",
+    })),
   ] as const;
   for (const tool of cliTools) {
     const exists = commandExists(tool.bin);

package/cloud-runtime/standalone/app/api/threads/knowledge/route.ts

@@ -0,0 +1,91 @@
+import { NextRequest } from "next/server";
+import { getMessageThread, loadHistory } from "@/lib/history-store";
+import { extractKnowledgeFromThread } from "@/lib/thread-knowledge";
+import {
+  completeThreadKnowledgeRun,
+  failThreadKnowledgeRun,
+  getLatestThreadKnowledgeRun,
+  startThreadKnowledgeRun,
+  type ThreadKnowledgeScope,
+} from "@/lib/thread-knowledge-runs";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const VALID_SCOPES = new Set<ThreadKnowledgeScope>(["repo", "project"]);
+
+export async function GET(request: NextRequest) {
+  const rootMessageId = request.nextUrl.searchParams.get("rootMessageId")?.trim() || "";
+  if (!rootMessageId) {
+    return Response.json({ error: "rootMessageId is required" }, { status: 400 });
+  }
+
+  const run = getLatestThreadKnowledgeRun(rootMessageId);
+  return Response.json({ ok: true, run });
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const rootMessageId = typeof body?.rootMessageId === "string" ? body.rootMessageId.trim() : "";
+    const scopes = Array.isArray(body?.scopes)
+      ? body.scopes
+        .map((scope: unknown) => (typeof scope === "string" ? scope.trim() : ""))
+        .filter((scope: string): scope is ThreadKnowledgeScope => VALID_SCOPES.has(scope as ThreadKnowledgeScope))
+      : [];
+
+    if (!rootMessageId || scopes.length === 0) {
+      return Response.json({ error: "rootMessageId and at least one valid scope are required" }, { status: 400 });
+    }
+
+    const thread = await getMessageThread(rootMessageId);
+    if (!thread) {
+      return Response.json({ error: "Thread not found" }, { status: 404 });
+    }
+
+    const history = await loadHistory(thread.threadId);
+    const root = history.find((message) => message.id === rootMessageId);
+    if (!root) {
+      return Response.json({ error: "Root message not found" }, { status: 404 });
+    }
+
+    const { run, reused } = startThreadKnowledgeRun({
+      threadId: thread.threadId,
+      rootMessageId,
+      scopes,
+    });
+
+    if (!reused) {
+      void extractKnowledgeFromThread({
+        threadId: thread.threadId,
+        rootMessageId,
+        status: root.threadStatus ?? "active",
+        outcomeNote: root.outcomeNote ?? null,
+        scopes,
+      })
+        .then((result) => {
+          completeThreadKnowledgeRun({
+            runId: run.id,
+            repoInsertedCount: result.repoInsertedCount,
+            projectInsertedCount: result.projectInsertedCount,
+          });
+        })
+        .catch((error) => {
+          console.warn("[threads/knowledge] Manual thread knowledge extraction failed:", error);
+          failThreadKnowledgeRun(run.id, error instanceof Error ? error.message : "Manual thread knowledge extraction failed");
+        });
+    }
+
+    return Response.json({
+      ok: true,
+      accepted: true,
+      reused,
+      rootMessageId,
+      scopes,
+      run,
+    });
+  } catch (error) {
+    console.error("Error starting manual thread knowledge extraction:", error);
+    return Response.json({ error: "Failed to start manual knowledge extraction" }, { status: 500 });
+  }
+}

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

@@ -1,6 +1,7 @@
 import { NextRequest } from "next/server";
-import { listRootMessages, getWorkspaceNames, updateMessageStatus, getMessageThread, getProjectThreadIds } from "@/lib/history-store";
+import { listRootMessages, getWorkspaceNames, updateMessageStatus, getMessageThread, getProjectThreadIds, loadHistory } from "@/lib/history-store";
 import type { ThreadStatus } from "@/lib/storage";
+import { extractKnowledgeFromThreadTransition } from "@/lib/thread-knowledge";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
@@ -112,8 +113,24 @@ export async function PATCH(request: NextRequest) {
       return Response.json({ error: "Thread not found" }, { status: 404 });
     }
 
+    const history = await loadHistory(thread.threadId);
+    const root = history.find((message) => message.id === rootMessageId);
+    const previousStatus = root?.threadStatus ?? "active";
+
     await updateMessageStatus(thread.threadId, rootMessageId, status, outcomeNote ?? null);
 
+    if (previousStatus !== status) {
+      extractKnowledgeFromThreadTransition({
+        threadId: thread.threadId,
+        rootMessageId,
+        fromStatus: previousStatus,
+        toStatus: status,
+        outcomeNote: outcomeNote ?? null,
+      }).catch((error) => {
+        console.warn("[threads/PATCH] Thread knowledge extraction failed:", error);
+      });
+    }
+
     return Response.json({ ok: true, rootMessageId, status, outcomeNote: outcomeNote ?? null });
   } catch (error) {
     console.error("Error updating thread status:", error);

package/cloud-runtime/standalone/app/globals.css

@@ -387,7 +387,7 @@ select:focus-visible {
    Card Styles
    ======================================== */
 .surface-card {
-  @apply bg-white border border-gray-200 hover:bg-gray-50 hover:border-gray-300 hover:shadow-sm dark:shadow-none dark:bg-gray-900/40 dark:border-gray-800 rounded-2xl dark:hover:bg-gray-900/60 dark:hover:border-gray-700 transition-all duration-200;
+  @apply relative bg-[var(--app-shell-surface)] border border-[var(--app-shell-border)] hover:bg-[var(--app-shell-subtle)] hover:border-[var(--app-shell-border-strong)] rounded-2xl transition-all duration-200;
 }
 
 .card {
@@ -2752,6 +2752,3 @@ select:focus-visible {
 /* ========================================
    Surface Card (Prototype Style)
    ======================================== */
-.surface-card {
-  @apply relative bg-white border border-gray-200 hover:bg-gray-50 hover:border-gray-300 shadow-sm dark:shadow-none dark:bg-gray-900/40 dark:border-gray-800 rounded-2xl dark:hover:bg-gray-900/60 dark:hover:border-gray-700 transition-all duration-200;
-}

package/cloud-runtime/standalone/app/projects/[slug]/graph/[taskId]/page.tsx

@@ -162,27 +162,6 @@ export default function FullscreenGraphPage({ params }: { params: Promise<PagePa
           </div>
           <p className="text-sm text-[var(--muted-foreground)]">No execution graph exists for this task.</p>
           <div className="mt-4 flex gap-2 justify-center">
-            <button
-              onClick={async () => {
-                try {
-                  const res = await fetch(`/api/tasks/${taskId}/graph`, {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({ migration: true }),
-                  });
-                  if (!res.ok) {
-                    const data = await res.json().catch(() => ({}));
-                    throw new Error(data?.error || `Migration failed (${res.status})`);
-                  }
-                  await handleRefetch();
-                } catch (err) {
-                  console.error("Failed to migrate task to v2:", err);
-                }
-              }}
-              className="btn btn-primary"
-            >
-              Migrate to v2
-            </button>
             <button
               onClick={() => router.push(`/projects/${slug}/tasks/${taskId}`)}
               className="btn btn-secondary"