@mndrk/agx 2.0.19 → 2.0.21

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

@@ -0,0 +1,194 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { GraphStore } from '@/src/graph/store';
+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 type { ExecutionGraph, ConditionalNode, FunctionNode } from '@/src/graph/types';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+/**
+ * GET /api/schedules/debug?rootMessageId=<id>&run=1
+ *
+ * Step through a schedule tick with clear input → processing → output for each node.
+ * Loops until all nodes are terminal (like the real executor).
+ * Add &run=1 to actually execute (live curl, agent steer).
+ */
+export async function GET(request: NextRequest) {
+  const rootMessageId = request.nextUrl.searchParams.get('rootMessageId');
+  const shouldRun = request.nextUrl.searchParams.get('run') === '1';
+
+  if (!rootMessageId) {
+    return NextResponse.json({ error: 'rootMessageId required' }, { status: 400 });
+  }
+
+  const store = new GraphStore();
+  const graph = store.getGraph(rootMessageId);
+
+  if (!graph) {
+    return NextResponse.json({ error: 'Graph not found' }, { status: 404 });
+  }
+
+  // ── Workflow overview ─────────────────────────────────────────────────
+  const workflow = {
+    id: graph.id,
+    schedule: {
+      state: graph.schedule?.state,
+      intervalMs: graph.schedule?.intervalMs,
+      runCount: graph.schedule?.runCount,
+      tickInProgress: graph.schedule?.tickInProgress,
+      lastTickAt: graph.schedule?.lastTickAt
+        ? new Date(graph.schedule.lastTickAt).toISOString()
+        : null,
+    },
+    pipeline: graph.edges.map((e) => {
+      const from = graph.nodes[e.from];
+      const to = graph.nodes[e.to];
+      return `[${e.from}] (${from?.type}:${from?.status}) ─${e.type}→ [${e.to}] (${to?.type}:${to?.status})`;
+    }),
+    nodes: Object.fromEntries(
+      Object.entries(graph.nodes).map(([id, n]) => {
+        const info: Record<string, unknown> = { type: n.type, status: n.status };
+        if (n.type === 'function') {
+          const fn = n as FunctionNode;
+          info.kind = fn.kind;
+          info.command = fn.command;
+        }
+        if (n.type === 'conditional') {
+          const cn = n as ConditionalNode;
+          info.expression = cn.condition.expression;
+          info.inputFrom = cn.condition.inputFrom;
+          if ('evaluatedTo' in cn) info.evaluatedTo = cn.evaluatedTo;
+        }
+        if ('output' in n && n.output) info.output = n.output;
+        if ('deps' in n) info.deps = n.deps;
+        return [id, info];
+      })
+    ),
+  };
+
+  // ── Tick check ────────────────────────────────────────────────────────
+  const tickResult = scheduleTickIfDue(graph);
+  const tickCheck = {
+    tickFired: tickResult.tickFired,
+    ...(!tickResult.tickFired && 'skipReason' in tickResult
+      ? { skipReason: (tickResult as any).skipReason }
+      : {}),
+  };
+
+  if (!tickResult.tickFired) {
+    return NextResponse.json({ workflow, tickCheck, nodes: [] });
+  }
+
+  // ── Loop through scheduler passes until tick completes ────────────────
+  const nodes: Record<string, unknown>[] = [];
+  let currentGraph: ExecutionGraph = tickResult.graph;
+  const dispatchFunction = createDispatchFunction();
+  const MAX_LOOPS = 10;
+
+  for (let loop = 0; loop < MAX_LOOPS; loop++) {
+    const pass = schedulerTick(currentGraph);
+    currentGraph = pass.graph; // apply conditional evaluations
+
+    const hasWork =
+      pass.functionToRun.length > 0 ||
+      pass.workToRun.length > 0 ||
+      pass.control.conditionalNodeIds.length > 0;
+
+    if (!hasWork) break;
+
+    // Log conditionals evaluated this pass
+    for (const nodeId of pass.control.conditionalNodeIds) {
+      const node = currentGraph.nodes[nodeId];
+      if (!node || node.type !== 'conditional') continue;
+      const cn = node as ConditionalNode;
+      const sourceNode = currentGraph.nodes[cn.condition.inputFrom];
+      const sourceOutput = sourceNode && 'output' in sourceNode ? sourceNode.output : null;
+
+      nodes.push({
+        node: nodeId,
+        type: 'conditional',
+        input: {
+          expression: cn.condition.expression,
+          inputFrom: cn.condition.inputFrom,
+          sourceOutput,
+        },
+        processing: `evaluated "${cn.condition.expression}"`,
+        output: {
+          status: cn.status,
+          evaluatedTo: 'evaluatedTo' in cn ? (cn as any).evaluatedTo : null,
+          thenBranch: cn.thenBranch,
+          elseBranch: cn.elseBranch,
+        },
+      });
+    }
+
+    // Execute function nodes
+    for (const nodeId of pass.functionToRun) {
+      const node = currentGraph.nodes[nodeId];
+      if (!node || node.type !== 'function') continue;
+      const fn = node as FunctionNode;
+
+      const entry: Record<string, unknown> = {
+        node: nodeId,
+        type: 'function',
+        kind: fn.kind,
+        input: {
+          command: fn.command,
+          timeoutMs: fn.timeoutMs ?? 30000,
+        },
+        processing: shouldRun ? 'executing...' : 'skipped (add &run=1)',
+      };
+
+      if (shouldRun) {
+        const startMs = Date.now();
+        try {
+          const execResult = await executeNode(currentGraph, nodeId, { dispatchFunction });
+          currentGraph = execResult.graph;
+          const resultNode = currentGraph.nodes[nodeId];
+          entry.processing = `executed in ${Date.now() - startMs}ms`;
+          entry.output = {
+            status: resultNode?.status,
+            data: resultNode && 'output' in resultNode ? resultNode.output : null,
+            errors: resultNode && 'errors' in resultNode ? (resultNode as any).errors : null,
+          };
+        } catch (err) {
+          entry.processing = `failed after ${Date.now() - startMs}ms`;
+          entry.output = { status: 'error', error: err instanceof Error ? err.message : String(err) };
+        }
+      } else {
+        entry.output = '(not executed)';
+      }
+
+      nodes.push(entry);
+    }
+
+    // Log work nodes (not executed by debug endpoint)
+    for (const nodeId of pass.workToRun) {
+      const node = currentGraph.nodes[nodeId];
+      nodes.push({
+        node: nodeId,
+        type: 'work',
+        input: node,
+        processing: 'ready to dispatch (not executed in debug)',
+        output: { status: node?.status },
+      });
+    }
+
+    if (isScheduleTickComplete(currentGraph)) break;
+  }
+
+  // ── Completion check ──────────────────────────────────────────────────
+  const tickComplete = isScheduleTickComplete(currentGraph);
+  const completion = {
+    complete: tickComplete,
+    resetNodes: graph.schedule?.resetNodeIds.map((id) => ({
+      id,
+      status: currentGraph.nodes[id]?.status,
+    })),
+  };
+
+  return NextResponse.json({ workflow, tickCheck, nodes, completion });
+}

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

@@ -0,0 +1,83 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { pollSchedules, executeScheduleTick } from '@/src/graph/schedule-runner';
+import { createDispatchFunction } from '@/src/graph/function-executor';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+/**
+ * POST /api/schedules/poll
+ *
+ * Poll all graphs with active schedules and execute due ticks.
+ * This endpoint can be called by an external scheduler/cron job.
+ *
+ * Request body (optional):
+ * - taskId: If provided, poll only that specific task's schedule
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const dispatchFunction = createDispatchFunction();
+
+    if (body.taskId) {
+      // Poll a specific task
+      const result = await executeScheduleTick(body.taskId, { dispatchFunction });
+
+      return NextResponse.json({
+        success: result.fired,
+        taskId: body.taskId,
+        error: result.error?.message ?? null,
+      });
+    }
+
+    // Poll all active schedules
+    const result = await pollSchedules({ dispatchFunction });
+
+    return NextResponse.json({
+      success: true,
+      tickedGraphIds: result.tickedGraphIds,
+      skippedGraphIds: result.skippedGraphIds,
+      errorCount: result.errors.length,
+      errors: result.errors.length > 0
+        ? result.errors.map((e) => ({ graphId: e.graphId, message: e.error.message }))
+        : undefined,
+    });
+  } catch (error) {
+    console.error('Schedule poll error:', error);
+    return NextResponse.json(
+      { error: 'Failed to poll schedules', message: error instanceof Error ? error.message : String(error) },
+      { status: 500 },
+    );
+  }
+}
+
+/**
+ * GET /api/schedules/poll
+ *
+ * List all graphs with active schedules (for debugging/monitoring).
+ */
+export async function GET() {
+  try {
+    const { getGraphsWithActiveSchedules } = await import('@/src/graph/schedule-runner');
+    const schedules = getGraphsWithActiveSchedules();
+
+    return NextResponse.json({
+      count: schedules.length,
+      schedules: schedules.map((s) => ({
+        taskId: s.taskId,
+        graphId: s.graphId,
+        state: s.schedule.state,
+        intervalMs: s.schedule.intervalMs,
+        runCount: s.schedule.runCount,
+        lastTickAt: s.schedule.lastTickAt,
+        tickInProgress: s.schedule.tickInProgress,
+      })),
+    });
+  } catch (error) {
+    console.error('Failed to list schedules:', error);
+    return NextResponse.json(
+      { error: 'Failed to list schedules' },
+      { status: 500 },
+    );
+  }
+}

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

@@ -0,0 +1,260 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import {
+  createGraph,
+  getGraph,
+  getActiveScheduleForRootMessageId,
+  getActiveScheduleRootMessageIds,
+  deactivateSchedulesByRootMessageId,
+} from "@/src/graph/store";
+import { activateGraphSchedule } from "@/src/graph/scheduler";
+import { createThreadMonitorSchedule } from "@/src/graph/schedule";
+import type { ExecutionGraph, FunctionNode, ConditionalNode, WorkNode } from "@/src/graph/types";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const DEFAULT_INTERVAL_MS = 15_000;
+
+const ActivateSchema = z.object({
+  action: z.literal("activate"),
+  rootMessageId: z.string().trim().min(1),
+  intervalMs: z.number().int().positive().optional(),
+});
+
+const StopSchema = z.object({
+  action: z.literal("stop"),
+  rootMessageId: z.string().trim().min(1),
+});
+
+const RequestSchema = z.discriminatedUnion("action", [ActivateSchema, StopSchema]);
+
+/**
+ * Build a minimal thread-monitor graph for the given rootMessageId.
+ * Shape: [function: pull-status] → [conditional: idle-check]
+ * 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.`;
+
+function buildThreadMonitorGraph(
+  rootMessageId: string,
+  intervalMs: number,
+): ExecutionGraph {
+  const now = new Date().toISOString();
+  const graphId = `sched-${rootMessageId}`;
+  const taskId = rootMessageId;
+
+  const pullStatusNode: FunctionNode = {
+    type: "function",
+    status: "pending",
+    deps: [],
+    kind: "bash",
+    title: "Pull thread status",
+    command: `curl -s "http://localhost:41741/api/history/status?format=compact&rootMessageId=${rootMessageId}"`,
+  };
+
+  const idleCheckNode: ConditionalNode = {
+    type: "conditional",
+    status: "pending",
+    deps: ["pull-status"],
+    condition: {
+      expression: "input.activeProcessCount === 0",
+      inputFrom: "pull-status",
+    },
+    thenBranch: ["steer"],
+    elseBranch: [],
+  };
+
+  const steerNode: WorkNode = {
+    type: "work",
+    status: "pending",
+    deps: ["idle-check"],
+    title: "Steer toward completion",
+    description: STEER_PROMPT,
+    attempts: 0,
+    maxAttempts: 2,
+    retryPolicy: { backoffMs: 5_000, onExhaust: "fail" },
+  };
+
+  // act: reads steer node output and branches on isDone
+  const actNode: FunctionNode = {
+    type: "function",
+    status: "pending",
+    deps: ["steer"],
+    kind: "bash",
+    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(" && "),
+    timeoutMs: 300_000, // 5 min — agents need time
+  };
+
+  const resetNodeIds = ["pull-status", "idle-check", "steer", "act"];
+
+  const graph: ExecutionGraph = {
+    id: graphId,
+    taskId,
+    graphVersion: 1,
+    mode: "SIMPLE",
+    nodes: {
+      "pull-status": pullStatusNode,
+      "idle-check": idleCheckNode,
+      "steer": steerNode,
+      "act": actNode,
+    },
+    edges: [
+      { from: "pull-status", to: "idle-check", type: "hard" },
+      { from: "idle-check", to: "steer", type: "hard" },
+      { from: "steer", to: "act", type: "hard", condition: "always" },
+    ],
+    policy: {
+      replanBudgetRemaining: 0,
+      replanBudgetInitial: 0,
+      verifyBudgetRemaining: 0,
+      verifyBudgetInitial: 0,
+      maxConcurrentAutoChecks: 0,
+      immutableRequiredGates: false,
+      maxConcurrent: 1,
+      priorityMode: "fifo",
+      nodeTimeoutMs: 300_000, // 5 min — steer work node + act need time
+      graphTimeoutMs: 0, // no graph-level timeout for recurring schedules
+    },
+    doneCriteria: {
+      allRequiredGatesPassed: true,
+      noRunnableOrPendingWork: true,
+    },
+    schedule: {
+      ...createThreadMonitorSchedule(resetNodeIds, intervalMs),
+      rootMessageId,
+    },
+    versionHistory: [],
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  return graph;
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const rawBody = await request.json().catch(() => ({}));
+    const parsed = RequestSchema.safeParse(rawBody);
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: "Invalid request", issues: parsed.error.issues },
+        { status: 400 },
+      );
+    }
+
+    const body = parsed.data;
+
+    if (body.action === "stop") {
+      const count = deactivateSchedulesByRootMessageId(body.rootMessageId);
+      return NextResponse.json({ success: true, deactivated: count });
+    }
+
+    // action === "activate"
+    const intervalMs = body.intervalMs ?? DEFAULT_INTERVAL_MS;
+
+    // Check if there's already an active schedule for this rootMessageId
+    const existing = getActiveScheduleForRootMessageId(body.rootMessageId);
+    if (existing) {
+      const graph = getGraph(existing.taskId);
+      return NextResponse.json({
+        success: true,
+        alreadyActive: true,
+        taskId: existing.taskId,
+        graphId: existing.graphId,
+        schedule: graph?.schedule ?? null,
+      });
+    }
+
+    // Check if graph exists but schedule is stopped — reactivate it
+    const existingGraph = getGraph(body.rootMessageId);
+    if (existingGraph) {
+      const reactivated = activateGraphSchedule(existingGraph, {
+        intervalMs,
+        resetNodeIds: existingGraph.schedule?.resetNodeIds ?? ["pull-status", "idle-check"],
+        rootMessageId: body.rootMessageId,
+        nowIso: new Date().toISOString(),
+      });
+      // Persist
+      const { updateGraphStructure } = await import("@/src/graph/store");
+      updateGraphStructure(
+        reactivated.id,
+        {
+          mode: reactivated.mode,
+          nodes: reactivated.nodes,
+          edges: reactivated.edges,
+          policy: reactivated.policy,
+          doneCriteria: reactivated.doneCriteria,
+          schedule: reactivated.schedule,
+        },
+        existingGraph.graphVersion,
+      );
+      const fresh = getGraph(body.rootMessageId);
+      return NextResponse.json({
+        success: true,
+        reactivated: true,
+        taskId: body.rootMessageId,
+        graphId: fresh?.id ?? reactivated.id,
+        schedule: fresh?.schedule ?? reactivated.schedule,
+      });
+    }
+
+    // Create new thread-monitor graph
+    const graph = buildThreadMonitorGraph(body.rootMessageId, intervalMs);
+    createGraph(graph, { skipTaskBinding: true });
+
+    return NextResponse.json({
+      success: true,
+      created: true,
+      taskId: graph.taskId,
+      graphId: graph.id,
+      schedule: graph.schedule,
+    });
+  } catch (error) {
+    console.error("Schedule API error:", error);
+    return NextResponse.json(
+      { error: "Failed to manage schedule", message: error instanceof Error ? error.message : String(error) },
+      { status: 500 },
+    );
+  }
+}
+
+/**
+ * GET /api/schedules?rootMessageId=<id>
+ * Returns the schedule status for a given rootMessageId.
+ */
+export async function GET(request: NextRequest) {
+  const rootMessageId = request.nextUrl.searchParams.get("rootMessageId");
+  if (!rootMessageId) {
+    // Return all active schedule root message IDs
+    const ids = getActiveScheduleRootMessageIds();
+    return NextResponse.json({ activeRootMessageIds: ids });
+  }
+
+  const active = getActiveScheduleForRootMessageId(rootMessageId);
+  if (!active) {
+    return NextResponse.json({ active: false });
+  }
+
+  const graph = getGraph(active.taskId);
+  return NextResponse.json({
+    active: true,
+    taskId: active.taskId,
+    graphId: active.graphId,
+    schedule: graph?.schedule ?? null,
+  });
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/tasks/[id]/graph/replan/route.ts

@@ -32,7 +32,7 @@ const ReplanResponseSchema = z.object({
 });
 
 function buildNodeFromPartial(nodeId: string, partial: Record<string, unknown>): GraphNode {
-  const type = partial.type === "gate" || partial.type === "fork" || partial.type === "join" || partial.type === "conditional"
+  const type = partial.type === "gate" || partial.type === "fork" || partial.type === "join" || partial.type === "conditional" || partial.type === "function"
     ? partial.type
     : "work";
   const deps = Array.isArray(partial.deps)
@@ -104,6 +104,33 @@ function buildNodeFromPartial(nodeId: string, partial: Record<string, unknown>):
     };
   }
 
+  if (type === "function") {
+    return {
+      type: "function",
+      status: status as Extract<NodeStatus, "pending" | "running" | "done" | "failed" | "skipped">,
+      deps,
+      kind: partial.kind === "mcp" ? "mcp" : "bash",
+      title: typeof partial.title === "string" && partial.title.trim().length > 0 ? partial.title : nodeId,
+      description: typeof partial.description === "string" && partial.description.trim().length > 0
+        ? partial.description
+        : undefined,
+      command: typeof partial.command === "string" && partial.command.trim().length > 0
+        ? partial.command
+        : nodeId,
+      ...(
+        partial.args && typeof partial.args === "object" && !Array.isArray(partial.args)
+          ? { args: partial.args as Record<string, unknown> }
+          : {}
+      ),
+      ...(typeof partial.timeoutMs === "number" ? { timeoutMs: partial.timeoutMs } : {}),
+      ...(
+        partial.output && typeof partial.output === "object" && !Array.isArray(partial.output)
+          ? { output: partial.output as Record<string, unknown> }
+          : {}
+      ),
+    };
+  }
+
   return {
     type: "conditional",
     status: status as Extract<NodeStatus, "pending" | "running" | "done" | "failed" | "skipped">,

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/tasks/[id]/graph/restart/route.ts

@@ -63,6 +63,10 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
           resetNode.attempts = 0;
           resetNode.output = undefined;
         }
+
+        if (resetNode.type === 'function') {
+          resetNode.output = undefined;
+        }
         
         // Reset gate verification
         if (resetNode.type === 'gate') {

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/tasks/[id]/graph/route.ts

@@ -159,6 +159,34 @@ function buildNodeFromPartial(nodeId: string, partial: NonNullable<CreateGraphRe
     };
   }
 
+  if (nodeType === "function") {
+    return {
+      type: "function",
+      status: status as Extract<NodeStatus, "pending" | "running" | "done" | "failed" | "skipped">,
+      deps,
+      kind: partial.kind === "mcp" ? "mcp" : "bash",
+      title: normalizeOptionalString(partial.title) ?? nodeId,
+      description: normalizeOptionalString(partial.description) ?? undefined,
+      command: normalizeOptionalString(partial.command) ?? nodeId,
+      ...(
+        partial.args
+        && typeof partial.args === "object"
+        && !Array.isArray(partial.args)
+          ? { args: partial.args as Record<string, unknown> }
+          : {}
+      ),
+      ...(typeof partial.timeoutMs === "number" ? { timeoutMs: partial.timeoutMs } : {}),
+      ...(partial.metrics ? { metrics: partial.metrics } : {}),
+      ...(partial.output ? { output: partial.output } : {}),
+      ...(partial.startedAt ? { startedAt: partial.startedAt } : {}),
+      ...(partial.completedAt ? { completedAt: partial.completedAt } : {}),
+      ...(partial.estimateMinutes !== undefined ? { estimateMinutes: partial.estimateMinutes } : {}),
+      ...(partial.actualMinutes !== undefined ? { actualMinutes: partial.actualMinutes } : {}),
+      ...(partial.stage ? { stage: partial.stage } : {}),
+      ...(partial.lane ? { lane: partial.lane } : {}),
+    };
+  }
+
   if (nodeType === "root") {
     return {
       type: "root",
@@ -272,6 +300,7 @@ function buildGraphFromCreateRequest(taskId: string, input: CreateGraphRequest):
       completionSinkNodeIds,
       ...(input.doneCriteria ?? {}),
     },
+    ...(input.schedule ? { schedule: input.schedule } : {}),
     versionHistory: [],
     runtimeEvents: [],
     createdAt: now,
@@ -693,6 +722,7 @@ async function handleDaemonGraphPatch(
   const edges = (sourceGraph.edges ?? existingGraph.edges) as Edge[];
   const policy = (sourceGraph.policy ?? existingGraph.policy) as ExecutionGraph["policy"];
   const doneCriteria = (sourceGraph.doneCriteria ?? existingGraph.doneCriteria) as ExecutionGraph["doneCriteria"];
+  const schedule = (sourceGraph.schedule ?? existingGraph.schedule) as ExecutionGraph["schedule"];
   const mode = (sourceGraph.mode ?? existingGraph.mode) as ExecutionGraph["mode"];
 
   const ifMatchVersion = (body.ifMatchGraphVersion ??
@@ -702,7 +732,7 @@ async function handleDaemonGraphPatch(
   try {
     await updateGraphStructure(
       existingGraph.id,
-      { mode, nodes, edges, policy, doneCriteria },
+      { mode, nodes, edges, policy, doneCriteria, schedule },
       ifMatchVersion,
     );