@mndrk/agx 2.4.4 → 2.4.5

package/cloud-runtime/standalone/apps/local/src/graph/schedule-runner.ts

@@ -1,3 +1,4 @@
+import { logger } from '@/lib/logger';
 import { getSQLiteDb } from '@/lib/sqlite-query-adapter';
 import {
   automationRecordToGraphSchedule,
@@ -108,7 +109,7 @@ export async function pollSchedules(
   };
 
   const activeSchedules = getGraphsWithActiveSchedules();
-  console.log(`[schedules:poll] found ${activeSchedules.length} active schedule(s)`);
+  logger.info(`[schedules:poll] found ${activeSchedules.length} active schedule(s)`);
 
   for (const { taskId } of activeSchedules) {
     try {
@@ -121,12 +122,12 @@ export async function pollSchedules(
       // Check if tick is due
       const tickResult = scheduleTickIfDue(graph);
       if (!tickResult.tickFired) {
-        console.log(`[schedules:poll] ${taskId} skipped (${tickResult.skipReason ?? 'unknown'})`);
+        logger.info(`[schedules:poll] ${taskId} skipped (${tickResult.skipReason ?? 'unknown'})`);
         result.skippedGraphIds.push(taskId);
         continue;
       }
 
-      console.log(`[schedules:poll] ${taskId} tick fired — resetting nodes`);
+      logger.info(`[schedules:poll] ${taskId} tick fired — resetting nodes`);
 
       // Tick fired - persist the updated graph with nodes reset
       store.updateGraphStructure(tickResult.graph.id, {
@@ -136,7 +137,7 @@ export async function pollSchedules(
 
       // Run the scheduler tick to get runnable nodes
       const schedulerResult = schedulerTick(tickResult.graph, context);
-      console.log(`[schedules:poll] ${taskId} scheduler: fn=${schedulerResult.functionToRun.length} work=${schedulerResult.workToRun.length}`);
+      logger.info(`[schedules:poll] ${taskId} scheduler: fn=${schedulerResult.functionToRun.length} work=${schedulerResult.workToRun.length}`);
 
       // Execute function nodes
       let currentGraph = schedulerResult.graph;
@@ -145,13 +146,13 @@ export async function pollSchedules(
         if (!node || node.type !== 'function') continue;
 
         try {
-          console.log(`[schedules:poll] ${taskId} executing function node "${nodeId}"`);
+          logger.info(`[schedules:poll] ${taskId} executing function node "${nodeId}"`);
           const execResult = await executeNode(currentGraph, nodeId, context);
           const resultNode = execResult.graph.nodes[nodeId];
-          console.log(`[schedules:poll] ${taskId} function "${nodeId}" → ${resultNode?.status}`, resultNode && 'output' in resultNode ? JSON.stringify((resultNode as any).output)?.slice(0, 200) : '');
+          logger.info(`[schedules:poll] ${taskId} function "${nodeId}" → ${resultNode?.status}`, resultNode && 'output' in resultNode ? { output: JSON.stringify((resultNode as any).output)?.slice(0, 200) } : undefined);
           currentGraph = execResult.graph;
         } catch (err) {
-          console.error(`[schedules:poll] ${taskId} function "${nodeId}" error:`, err);
+          logger.error(`[schedules:poll] ${taskId} function "${nodeId}" error`, logger.formatError(err));
           result.errors.push({
             graphId: taskId,
             error: err instanceof Error ? err : new Error(String(err)),
@@ -166,7 +167,7 @@ export async function pollSchedules(
 
       // Second pass: re-run scheduler to find work nodes now unblocked by function/conditional results
       const postFunctionResult = schedulerTick(currentGraph, context);
-      console.log(`[schedules:poll] ${taskId} post-fn scheduler: cond=${postFunctionResult.control.conditionalNodeIds.length} work=${postFunctionResult.workToRun.length}`);
+      logger.info(`[schedules:poll] ${taskId} post-fn scheduler: cond=${postFunctionResult.control.conditionalNodeIds.length} work=${postFunctionResult.workToRun.length}`);
       currentGraph = postFunctionResult.graph;
 
       // Auto-dispatch work nodes in scheduled runs
@@ -199,7 +200,7 @@ export async function pollSchedules(
         });
 
         const postWorkResult = schedulerTick(currentGraph, context);
-        console.log(`[schedules:poll] ${taskId} post-work scheduler: fn=${postWorkResult.functionToRun.length} cond=${postWorkResult.control.conditionalNodeIds.length}`);
+        logger.info(`[schedules:poll] ${taskId} post-work scheduler: fn=${postWorkResult.functionToRun.length} cond=${postWorkResult.control.conditionalNodeIds.length}`);
         currentGraph = postWorkResult.graph;
 
         for (const nodeId of postWorkResult.functionToRun) {
@@ -207,11 +208,11 @@ export async function pollSchedules(
           if (!node || node.type !== 'function') continue;
 
           try {
-            console.log(`[schedules:poll] ${taskId} executing post-work function "${nodeId}"`);
+            logger.info(`[schedules:poll] ${taskId} executing post-work function "${nodeId}"`);
             const execResult = await executeNode(currentGraph, nodeId, context);
             currentGraph = execResult.graph;
           } catch (err) {
-            console.error(`[schedules:poll] ${taskId} post-work function "${nodeId}" error:`, err);
+            logger.error(`[schedules:poll] ${taskId} post-work function "${nodeId}" error`, logger.formatError(err));
             result.errors.push({
               graphId: taskId,
               error: err instanceof Error ? err : new Error(String(err)),
@@ -227,9 +228,9 @@ export async function pollSchedules(
 
       // Check if tick is complete
       const nodeStates = Object.entries(currentGraph.nodes).map(([id, n]) => `${id}:${n.status}`).join(', ');
-      console.log(`[schedules:poll] ${taskId} node states: ${nodeStates}`);
+      logger.info(`[schedules:poll] ${taskId} node states: ${nodeStates}`);
       const tickComplete = isScheduleTickComplete(currentGraph);
-      console.log(`[schedules:poll] ${taskId} tick complete? ${tickComplete}`);
+      logger.info(`[schedules:poll] ${taskId} tick complete? ${tickComplete}`);
       if (tickComplete) {
         const completed = completeScheduleTick(currentGraph);
 
@@ -258,7 +259,7 @@ export async function pollSchedules(
         // Re-read DB schedule state to respect mid-tick changes (e.g. act node stopped it)
         const dbGraph = store.getGraph(taskId);
         if (dbGraph?.schedule?.state === 'stopped') {
-          console.log(`[schedules:poll] ${taskId} schedule was stopped mid-tick, preserving stopped state`);
+          logger.info(`[schedules:poll] ${taskId} schedule was stopped mid-tick, preserving stopped state`);
           completed.schedule = {
             ...completed.schedule,
             state: 'stopped',
@@ -274,14 +275,14 @@ export async function pollSchedules(
 
       result.tickedGraphIds.push(taskId);
     } catch (err) {
-      console.error(`[schedules:poll] ${taskId} caught error:`, err);
+      logger.error(`[schedules:poll] ${taskId} caught error`, logger.formatError(err));
       result.errors.push({
         graphId: taskId,
         error: err instanceof Error ? err : new Error(String(err)),
       });
       try {
         store.releaseScheduleTick(taskId);
-        console.log(`[schedules:poll] ${taskId} released concurrency slot after error`);
+        logger.info(`[schedules:poll] ${taskId} released concurrency slot after error`);
       } catch { /* best effort */ }
     }
   }
@@ -336,10 +337,10 @@ export async function executeScheduleTick(
   while (true) {
     loopCount++;
     const nodesBefore = Object.entries(currentGraph.nodes).map(([id, n]) => `${id}:${n.status}`).join(', ');
-    console.log(`[schedules:tick] loop ${loopCount} nodes before: ${nodesBefore}`);
+    logger.info(`[schedules:tick] loop ${loopCount} nodes before: ${nodesBefore}`);
 
     const schedulerResult = schedulerTick(currentGraph, context);
-    console.log(`[schedules:tick] loop ${loopCount} fn=${schedulerResult.functionToRun.length} work=${schedulerResult.workToRun.length} cond=${schedulerResult.control.conditionalNodeIds.length}`);
+    logger.info(`[schedules:tick] loop ${loopCount} fn=${schedulerResult.functionToRun.length} work=${schedulerResult.workToRun.length} cond=${schedulerResult.control.conditionalNodeIds.length}`);
 
     // Execute all runnable function nodes
     for (const nodeId of schedulerResult.functionToRun) {
@@ -348,13 +349,13 @@ export async function executeScheduleTick(
 
       const execResult = await executeNode(currentGraph, nodeId, context);
       currentGraph = execResult.graph;
-      console.log(`[schedules:tick] fn "${nodeId}" → ${currentGraph.nodes[nodeId]?.status}`);
+      logger.info(`[schedules:tick] fn "${nodeId}" → ${currentGraph.nodes[nodeId]?.status}`);
     }
 
     // Conditionals are evaluated in schedulerTick — update currentGraph
     if (schedulerResult.control.conditionalNodeIds.length > 0) {
       currentGraph = schedulerResult.graph;
-      console.log(`[schedules:tick] applied conditional results: ${schedulerResult.control.conditionalNodeIds.join(', ')}`);
+      logger.info(`[schedules:tick] applied conditional results: ${schedulerResult.control.conditionalNodeIds.join(', ')}`);
     }
 
     // Execute work nodes (if any runnable)
@@ -364,11 +365,11 @@ export async function executeScheduleTick(
     }
 
     const nodesAfter = Object.entries(currentGraph.nodes).map(([id, n]) => `${id}:${n.status}`).join(', ');
-    console.log(`[schedules:tick] loop ${loopCount} nodes after: ${nodesAfter}`);
+    logger.info(`[schedules:tick] loop ${loopCount} nodes after: ${nodesAfter}`);
 
     // If tick is complete, break
     if (isScheduleTickComplete(currentGraph)) {
-      console.log(`[schedules:tick] tick complete after loop ${loopCount}`);
+      logger.info(`[schedules:tick] tick complete after loop ${loopCount}`);
       break;
     }
 

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

@@ -7,6 +7,7 @@
  * 3. Parses structured output: { isDone: boolean, message: string }
  */
 
+import { logger } from '@/lib/logger';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
@@ -165,7 +166,7 @@ export function createDispatchWork(): (
       };
     }
 
-    console.log(
+    logger.info(
       `[work-dispatch] Dispatching steer node "${node.title}" for graph ${graph.id} (root: ${rootMessageId})`,
     );
 
@@ -217,7 +218,7 @@ export function createDispatchWork(): (
         })
         .join('\n');
 
-      console.log(`[work-dispatch] Thread: active=${activeProcessCount}, msgs=${snapshot.messages?.length ?? 0}`);
+      logger.info(`[work-dispatch] Thread: active=${activeProcessCount}, msgs=${snapshot.messages?.length ?? 0}`);
 
       // 2. Build assessment prompt
       const assessPrompt = [
@@ -243,7 +244,7 @@ export function createDispatchWork(): (
       // 3. Call provider directly via runCliResponse (same path as chat endpoint)
       const { runCliResponse } = await import('@/lib/cli-runner');
       const steeringAgent = await getSteeringAgentConfig(threadRef.threadId, graph.taskId);
-      console.log(
+      logger.info(
         `[work-dispatch] Calling ${steeringAgent.provider} via runCliResponse (prompt length: ${assessPrompt.length})...`
       );
 
@@ -257,11 +258,11 @@ export function createDispatchWork(): (
           fullResponse += chunk;
         },
         onLog: (stream, line) => {
-          console.log(`[work-dispatch] [${stream}] ${line}`);
+          logger.info(`[work-dispatch] [${stream}] ${line}`);
         },
       });
 
-      console.log(`[work-dispatch] Raw response: ${fullResponse.slice(0, 500)}`);
+      logger.info(`[work-dispatch] Raw response: ${fullResponse.slice(0, 500)}`);
 
       // 4. Parse structured output
       const parsed = parseSteerResponse(fullResponse.trim());
@@ -272,7 +273,7 @@ export function createDispatchWork(): (
           message: parsed.error,
         };
       }
-      console.log(`[work-dispatch] Parsed result:`, parsed);
+      logger.info(`[work-dispatch] Parsed result: ${JSON.stringify(parsed)}`);
 
       return {
         status: 'success' as const,

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

@@ -1,3 +1,4 @@
+import { logger } from '@/lib/logger';
 import type { PromptJob, PromptRun } from './types';
 import type { PromptJobStore } from './store';
 import { computeNextRun, parseCadence } from './cron';
@@ -11,7 +12,7 @@ export async function pollDueJobs(store: PromptJobStore, now: number = Date.now(
   // Reap runs stuck in 'running' for > 30 minutes so overlap-skip doesn't block forever
   const reaped = await store.reapStaleRuns();
   if (reaped > 0) {
-    console.log(`[prompt-jobs] reaped ${reaped} stale run(s)`);
+    logger.info(`[prompt-jobs] reaped ${reaped} stale run(s)`);
   }
 
   // Heal active jobs with null nextRunAt

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

@@ -162,6 +162,16 @@ interface PromptJobListFilter {
   includeObjectiveJobs?: boolean;
 }
 
+export class PromptJobDeleteError extends Error {
+  constructor(
+    message: string,
+    public readonly status: number,
+  ) {
+    super(message);
+    this.name = "PromptJobDeleteError";
+  }
+}
+
 function rowToJob(row: PromptJobRow): PromptJob {
   const executionMode: PromptJobExecutionMode =
     row.execution_mode === "objective_linear_ticket" || row.execution_mode === "objective_worker"
@@ -444,7 +454,14 @@ export class PromptJobStore {
   deleteJob(id: string): void {
     const job = this.getJob(id);
     if (job?.builtIn) {
-      throw new Error('Cannot delete built-in job. Use pause instead.');
+      throw new PromptJobDeleteError("Cannot delete built-in job. Use pause instead.", 400);
+    }
+
+    if (this.hasRunningRun(id)) {
+      throw new PromptJobDeleteError(
+        "Cannot delete a scheduled task while a run is queued or running. Cancel the active run first.",
+        409,
+      );
     }
 
     if (isAutomationFrontmatterEnabled()) {

package/cloud-runtime/standalone/apps/local/state/trackerItemsCache.ts

@@ -0,0 +1,79 @@
+import type { TrackerItem } from "@/lib/tracker/types";
+
+const DB_NAME = "agx-tracker-cache";
+const STORE = "items";
+const VERSION = 1;
+
+export interface CachedItemsPage {
+  items: TrackerItem[];
+  endCursor: string | null;
+  hasNextPage: boolean;
+  savedAt: number;
+}
+
+let dbPromise: Promise<IDBDatabase | null> | null = null;
+
+function openDb(): Promise<IDBDatabase | null> {
+  if (typeof indexedDB === "undefined") return Promise.resolve(null);
+  if (dbPromise) return dbPromise;
+  dbPromise = new Promise((resolve) => {
+    const req = indexedDB.open(DB_NAME, VERSION);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(STORE)) db.createObjectStore(STORE);
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => resolve(null);
+  });
+  return dbPromise;
+}
+
+export async function readCachedItems(key: string): Promise<CachedItemsPage | null> {
+  const db = await openDb();
+  if (!db) return null;
+  return new Promise((resolve) => {
+    try {
+      const tx = db.transaction(STORE, "readonly");
+      const req = tx.objectStore(STORE).get(key);
+      req.onsuccess = () => resolve((req.result as CachedItemsPage) ?? null);
+      req.onerror = () => resolve(null);
+    } catch {
+      resolve(null);
+    }
+  });
+}
+
+export async function writeCachedItems(key: string, value: CachedItemsPage): Promise<void> {
+  const db = await openDb();
+  if (!db) return;
+  return new Promise((resolve) => {
+    try {
+      const tx = db.transaction(STORE, "readwrite");
+      tx.objectStore(STORE).put(value, key);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => resolve();
+      tx.onabort = () => resolve();
+    } catch {
+      resolve();
+    }
+  });
+}
+
+export function buildCacheKey(
+  trackerType: string,
+  projectId: string,
+  filters: Record<string, unknown>
+): string {
+  const normalized: Record<string, unknown> = {};
+  for (const k of Object.keys(filters).sort()) {
+    const v = filters[k];
+    if (v === undefined || v === null || v === "" || v === false) continue;
+    if (Array.isArray(v)) {
+      if (!v.length) continue;
+      normalized[k] = [...v].map(String).sort();
+    } else {
+      normalized[k] = v;
+    }
+  }
+  return `${trackerType}:${projectId}:${JSON.stringify(normalized)}`;
+}