@mndrk/agx 1.4.64 → 2.0.0-next.0

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/worker/index.js

@@ -18538,6 +18538,10 @@ var QueryBuilder = class {
     this.filters.push({ op: "in", column, value: values || [] });
     return this;
   }
+  contains(column, value) {
+    this.filters.push({ op: "contains", column, value });
+    return this;
+  }
   or(expression) {
     this.filters.push({ op: "or", expression });
     return this;
@@ -18621,6 +18625,9 @@ var QueryBuilder = class {
           params.push(toSqlValue(f.value));
           parts.push(`${f.column} IS NOT DISTINCT FROM $${params.length}`);
         }
+      } else if (f.op === "contains") {
+        params.push((f.value || []).map(toSqlValue));
+        parts.push(`${f.column} @> $${params.length}`);
       } else if (f.op === "in") {
         if (!f.value || f.value.length === 0) {
           parts.push("1=0");
@@ -19090,6 +19097,9 @@ function extractTitle(markdown) {
   const match = body.match(/^#\s+(.+)$/m);
   return match ? match[1] : void 0;
 }
+function normalizeDescriptionBody(markdownBody) {
+  return String(markdownBody || "").replace(/^#\s+.+(\r?\n|$)/, "").trim();
+}
 async function ensureTaskDependencyState(task, userId) {
   const deps = Array.isArray(task.depends_on) ? task.depends_on : [];
   if (!deps.length) return;
@@ -19145,7 +19155,7 @@ async function updateTask(id, content, userId, options) {
   const dependsOnForUpdate = options?.dependsOn !== void 0 ? dependsFromOptions : dependsFromFrontmatter;
   const updatePayload = {
     content,
-    description: body,
+    description: normalizeDescriptionBody(body),
     title,
     status: frontmatter.status,
     stage: frontmatter.stage,
@@ -19192,7 +19202,6 @@ async function updateTask(id, content, userId, options) {
   }).eq("id", id).select().single();
   if (error && error.code === "42703") {
     const {
-      description,
       swarm_models,
       swarm: swarm2,
       workflow_id,
@@ -19238,6 +19247,35 @@ async function updateTask(id, content, userId, options) {
   }
   return taskRecord;
 }
+var DEFAULT_WORKFLOW_NODE_SEED = [
+  {
+    id: "00000000-0000-0000-0001-000000000001",
+    name: "INTAKE",
+    label: "Intake",
+    prompt: "New task. Triage, scope, and prepare for work.",
+    position: 0,
+    node_type: "step"
+  },
+  {
+    id: "00000000-0000-0000-0001-000000000002",
+    name: "PROGRESS",
+    label: "Progress",
+    prompt: "Task is actively being worked on.",
+    position: 1,
+    node_type: "step"
+  },
+  {
+    id: "00000000-0000-0000-0001-000000000003",
+    name: "DONE",
+    label: "Done",
+    prompt: "Task completed.",
+    position: 2,
+    node_type: "terminal"
+  }
+];
+var DEFAULT_WORKFLOW_NODE_SEED_BY_ID = new Map(
+  DEFAULT_WORKFLOW_NODE_SEED.map((node) => [node.id, node])
+);
 async function getWorkflowNodes(workflowId) {
   const db = createAdminDbClient();
   const { data, error } = await db.from("workflow_nodes").select("*").eq("workflow_id", workflowId).order("position", { ascending: true });
@@ -19265,9 +19303,9 @@ async function getWorkflowTransitionsFromNode(workflowId, fromNodeId) {
   }
   return data || [];
 }
-async function addTaskLog(taskId, content, logType) {
+async function addTaskLog(taskId, content, logType, nodeId) {
   const db = createAdminDbClient();
-  const { data, error } = await db.from("task_logs").insert({ task_id: taskId, content, log_type: logType }).select().single();
+  const { data, error } = await db.from("task_logs").insert({ task_id: taskId, content, log_type: logType, ...nodeId ? { node_id: nodeId } : {} }).select().single();
   if (error) throw error;
   return data;
 }
@@ -19280,11 +19318,9 @@ async function addTaskComment(taskId, content, authorType, authorId) {
 
 // ../agx-cloud/lib/orchestration/stage-machine.ts
 var DEFAULT_STAGE_SEQUENCE = [
-  "ideation",
-  "planning",
-  "execution",
-  "verification",
-  "done"
+  "INTAKE",
+  "PROGRESS",
+  "DONE"
 ];
 var STANDARD_STAGE_SEQUENCES = [DEFAULT_STAGE_SEQUENCE];
 function normalizeTicketType(value) {
@@ -19307,9 +19343,9 @@ function getTicketType(frontmatter, markdownBody) {
 }
 function getNextStage(currentStage, ticketType) {
   if (ticketType === "spike") {
-    if (currentStage === "ideation") return "planning";
-    if (currentStage === "done") return null;
-    return "done";
+    if (currentStage === "INTAKE") return "PROGRESS";
+    if (currentStage === "DONE") return null;
+    return "DONE";
   }
   for (const sequence of STANDARD_STAGE_SEQUENCES) {
     const index = sequence.indexOf(currentStage);
@@ -19338,7 +19374,7 @@ function resolveStageTransition({
       };
     }
     return {
-      nextStage: "done",
+      nextStage: "DONE",
       nextStatus: "completed",
       retryCount: 0,
       error: null,
@@ -19354,14 +19390,14 @@ function resolveStageTransition({
       appendLog: { content: "Blocked: additional input required.", logType: "system" }
     };
   }
-  if (currentStage === "verification") {
+  if (currentStage === "PROGRESS") {
     return {
-      nextStage: ticketType === "spike" ? "planning" : "execution",
+      nextStage: "PROGRESS",
       nextStatus: "queued",
       retryCount: 0,
       error: null,
       appendLog: {
-        content: ticketType === "spike" ? "Verification failed. Moving back to planning for spike revisions." : "Verification failed. Moving back to execution for revisions.",
+        content: "Stage not done. Retrying in PROGRESS.",
         logType: "system"
       }
     };
@@ -19407,6 +19443,16 @@ async function resolveWorkflowTransition({
   retryCount,
   maxRetries = 3
 }) {
+  if (String(currentNodeName).trim().toLowerCase() === "done") {
+    return {
+      nextNodeName: "done",
+      nextStatus: "completed",
+      retryCount: 0,
+      error: null,
+      appendLog: { content: "Task completed at done", logType: "checkpoint" },
+      nodeConfig: null
+    };
+  }
   const currentNode = await getWorkflowNodeByName(workflowId, currentNodeName);
   if (!currentNode) {
     return {
@@ -19506,6 +19552,35 @@ ${body}`;
 
 // ../agx-cloud/lib/dependency-manager.ts
 var READY_STATUS = "completed";
+function normalizeDependsOnInput2(input) {
+  if (!input) return [];
+  if (Array.isArray(input)) {
+    return Array.from(new Set(input.map((entry) => String(entry || "").trim()).filter(Boolean)));
+  }
+  if (typeof input === "string") {
+    const trimmed = input.trim();
+    if (!trimmed) return [];
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed)) {
+        return Array.from(new Set(parsed.map((entry) => String(entry || "").trim()).filter(Boolean)));
+      }
+    } catch {
+    }
+    return Array.from(new Set(trimmed.split(",").map((entry) => entry.trim()).filter(Boolean)));
+  }
+  return [];
+}
+function extractDependsOn(record) {
+  if (!record) return [];
+  const direct = normalizeDependsOnInput2(record.depends_on);
+  if (direct.length) return direct;
+  if (typeof record.content === "string") {
+    const { frontmatter } = parseFrontmatter(record.content || "");
+    return normalizeDependsOnInput2(frontmatter.depends_on);
+  }
+  return [];
+}
 function describeDependency2(dep) {
   return dep.title || dep.slug || dep.id || "(unknown)";
 }
@@ -19554,7 +19629,7 @@ function formatMissingDependencies(missing) {
   return message;
 }
 async function getMissingDependencies(task, userId) {
-  const dependsOn = Array.isArray(task.depends_on) ? task.depends_on : [];
+  const dependsOn = extractDependsOn(task);
   if (!dependsOn.length) return [];
   const records = await fetchTasksByIds(dependsOn, userId);
   return records.filter((dep) => (dep.status || "") !== READY_STATUS);
@@ -19622,10 +19697,19 @@ async function triggerDependentTasks(taskId, userId) {
   if (userId) {
     query = query.eq("user_id", userId);
   }
-  const { data } = await query;
-  if (!Array.isArray(data) || !data.length) return;
+  const { data, error } = await query;
+  let dependentIds = Array.isArray(data) ? data.map((row) => row?.id).filter(Boolean) : [];
+  if (error && error.code === "42703") {
+    let fallbackQuery = db.from("tasks").select("id, content");
+    if (userId) {
+      fallbackQuery = fallbackQuery.eq("user_id", userId);
+    }
+    const { data: fallbackTasks } = await fallbackQuery;
+    dependentIds = (Array.isArray(fallbackTasks) ? fallbackTasks : []).filter((row) => extractDependsOn(row).includes(taskId)).map((row) => row?.id).filter(Boolean);
+  }
+  if (!dependentIds.length) return;
   await Promise.all(
-    data.map((row) => row?.id).filter(Boolean).map((dependentId) => attemptStartTask(dependentId, resolvedUserId))
+    dependentIds.map((dependentId) => attemptStartTask(dependentId, resolvedUserId))
   );
 }
 

package/lib/cli/chat/index.js

@@ -0,0 +1,203 @@
+/* eslint-disable no-console */
+'use strict';
+
+const readline = require('readline');
+const execa = require('execa');
+const { c } = require('../../ui/colors');
+const { createCloudClient } = require('../../cloud/client');
+const { loadConfig, prompt: cliPrompt } = require('../configStore');
+const { detectProviders } = require('../providers');
+const { truncateForComment } = require('../../ui/text');
+const { randomId } = require('../util');
+
+class ChatSession {
+  constructor(options = {}) {
+    this.provider = options.provider || null;
+    this.model = options.model || null;
+    this.taskId = options.taskId || null;
+    this.cloudClient = createCloudClient({ configDir: options.configDir });
+    this.history = [];
+    this.rl = null;
+  }
+
+  async init() {
+    const config = loadConfig();
+    const providers = detectProviders();
+
+    if (!this.provider || !providers[this.provider]) {
+      // Use configured default, then fall back to detection
+      if (config?.defaultProvider && providers[config.defaultProvider]) this.provider = config.defaultProvider;
+      else if (providers.claude) this.provider = 'claude';
+      else if (providers.gemini) this.provider = 'gemini';
+      else if (providers.ollama) this.provider = 'ollama';
+      else if (providers.codex) this.provider = 'codex';
+      else {
+        console.log(`${c.red}No AI provider found.${c.reset}`);
+        return false;
+      }
+    }
+
+    if (!this.taskId) {
+      // Create a new task for this chat session
+      await this.createChatTask();
+    } else {
+      // Load existing task context
+      await this.loadTaskContext();
+    }
+
+    return true;
+  }
+
+  async createChatTask() {
+    const title = `Chat Session ${new Date().toLocaleTimeString()}`;
+    console.log(`${c.dim}Creating chat session...${c.reset}`);
+    
+    try {
+      const { task } = await this.cloudClient.request('POST', '/api/tasks', {
+        content: `---\nstatus: in_progress\nstage: chat\nengine: ${this.provider}\ntype: chat\n---\n\n# ${title}\n\nInteractive chat session started via CLI.\n`
+      });
+      this.taskId = task.id;
+      console.log(`${c.green}✓${c.reset} Session started (${task.id.slice(0, 8)})`);
+    } catch (err) {
+      console.log(`${c.red}Failed to create session:${c.reset} ${err.message}`);
+      throw err;
+    }
+  }
+
+  async loadTaskContext() {
+    // Load history from comments
+    try {
+      const { comments } = await this.cloudClient.request('GET', `/api/tasks/${this.taskId}/comments`);
+      if (comments && comments.length) {
+        // Replay history
+        for (const comment of comments) {
+           const author = comment.author_type === 'user' ? 'You' : 'Agent';
+           const color = author === 'You' ? c.cyan : c.green;
+           console.log(`
+${color}${author}:${c.reset} ${comment.content}`);
+        }
+      }
+    } catch (err) {
+      // Ignore
+    }
+  }
+
+  async start() {
+    console.log(`
+${c.bold}Chat with ${this.provider}${c.reset}`);
+    console.log(`${c.dim}Type 'exit' or 'quit' to end session.${c.reset}\n`);
+
+    return new Promise((resolve) => {
+      this.rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: `${c.cyan}You:${c.reset} `
+      });
+
+      this.rl.prompt();
+
+      this.rl.on('line', async (line) => {
+        const input = line.trim();
+        if (!input) {
+          this.rl.prompt();
+          return;
+        }
+
+        if (['exit', 'quit', '/exit', '/quit'].includes(input.toLowerCase())) {
+          this.rl.close();
+          return;
+        }
+
+        // Save user message
+        await this.postComment(input, 'user');
+
+        // Run agent
+        process.stdout.write(`${c.green}Agent:${c.reset} `);
+        const response = await this.runAgent(input);
+        
+        // Save agent response
+        if (response) {
+          await this.postComment(response, 'assistant');
+          console.log(''); // Newline after response
+        }
+
+        this.rl.prompt();
+      });
+
+      this.rl.on('close', () => {
+        console.log(`
+${c.dim}Session ended.${c.reset}`);
+        resolve();
+      });
+    });
+  }
+
+  async postComment(content, authorType = 'user') {
+    try {
+      await this.cloudClient.request('POST', `/api/tasks/${this.taskId}/comments`, {
+        content: truncateForComment(content),
+        author_type: authorType
+      });
+    } catch (err) {
+      // Silent fail on history save
+    }
+  }
+
+  async runAgent(input) {
+    // We invoke `agx <provider>` with the task context.
+    // The task context includes previous comments, so the agent sees history.
+    // We pass the *current* input as the prompt as well, to ensure immediate attention.
+    
+    // Construct command
+    // We use the same arguments structure as runCli uses for providers
+    const args = [this.provider, '--cloud-task', this.taskId, '-p', input, '-y'];
+    if (this.model) {
+      args.push('--model', this.model);
+    }
+
+    try {
+      // Spawn agx (self) to handle the provider call with context loading
+      // This reuses all the prompt building logic in runCli.js
+      const child = execa(process.argv[0], [process.argv[1], ...args], {
+        env: { ...process.env, AGX_CLI_CHAT_MODE: '1' },
+        reject: false
+      });
+
+      let output = '';
+      
+      if (child.stdout) {
+        child.stdout.on('data', (d) => {
+          const chunk = d.toString();
+          output += chunk;
+          process.stdout.write(chunk);
+        });
+      }
+      
+      if (child.stderr) {
+         // Log stderr but maybe not to user unless debug?
+         // child.stderr.pipe(process.stderr);
+      }
+
+      const res = await child;
+      
+      if (res.exitCode !== 0) {
+        console.log(`${c.red} (Error: Agent exited with code ${res.exitCode})${c.reset}`);
+        return null;
+      }
+
+      return output;
+    } catch (err) {
+      console.log(`${c.red} (Error running agent: ${err.message})${c.reset}`);
+      return null;
+    }
+  }
+}
+
+async function startChat(options) {
+  const session = new ChatSession(options);
+  if (await session.init()) {
+    await session.start();
+  }
+}
+
+module.exports = { startChat, ChatSession };

package/lib/cli/cloud/aggregate.js

@@ -42,6 +42,8 @@ function createCloudAggregateHelpers(env) {
     });
     artifacts?.recordPrompt(`Aggregator Prompt (${aggregatorProvider}${aggregatorModel ? `/${aggregatorModel}` : ''})`, aggregatePrompt);
 
+    // WARNING: keep `-y` in this aggregator invocation shape.
+    // This is intentionally lock-tested in cloud command-path tests.
     const aggregateArgs = [aggregatorProvider, '-y', '--prompt', aggregatePrompt, '--print'];
     if (aggregatorModel) {
       aggregateArgs.push('--model', aggregatorModel);
@@ -103,6 +105,8 @@ function createCloudAggregateHelpers(env) {
     });
     artifacts?.recordPrompt(`Swarm Aggregator Prompt (${aggregatorProvider}${aggregatorModel ? `/${aggregatorModel}` : ''})`, aggregatePrompt);
 
+    // WARNING: keep `-y` in this aggregator invocation shape.
+    // This is intentionally lock-tested in cloud command-path tests.
     const aggregateArgs = [aggregatorProvider, '-y', '--prompt', aggregatePrompt, '--print'];
     if (aggregatorModel) {
       aggregateArgs.push('--model', aggregatorModel);

package/lib/cli/cloud/command.js

@@ -43,6 +43,9 @@ function createCloudCommandHelpers(env) {
     }
   }
 
+  // WARNING: Behavior in this function is intentionally lock-tested.
+  // Do not alter command argument wiring (including pass-through flags like `-y`)
+  // without updating the companion tests and completing a safety review.
   function runAgxCommand(args, timeoutMs, label, handlers = {}) {
     return new Promise((resolve, reject) => {
       let stdout = '';