@hasna/loops 0.3.56 → 0.3.58

package/dist/daemon/index.js

@@ -461,6 +461,9 @@ function validateTarget(value, label, opts) {
     }
     if (value.model !== undefined)
       assertString(value.model, `${label}.model`);
+    if (value.provider === "opencode" && (typeof value.model !== "string" || value.model.trim() === "")) {
+      throw new Error(`${label}.model is required for provider opencode; pass a provider/model id such as openrouter/google/gemini-2.5-flash`);
+    }
     if (value.variant !== undefined)
       assertString(value.variant, `${label}.variant`);
     if (value.agent !== undefined)
@@ -1257,12 +1260,21 @@ class Store {
     if (!row)
       throw new Error("daemon lease lost");
   }
+  assertNoNestedWorkflowGoal(target, goal) {
+    if (!goal || target.type !== "workflow")
+      return;
+    const workflow = this.getWorkflow(target.workflowId);
+    if (workflow?.goal) {
+      throw new Error(`workflow loop cannot define a loop-level goal when workflow ${workflow.name} already has a top-level goal; remove one goal wrapper`);
+    }
+  }
   createLoop(input, from = new Date) {
     const now = nowIso();
     const target = input.target.type === "workflow" ? input.target : normalizeCreateWorkflowInput({
       name: "loop-target-validation",
       steps: [{ id: "target", target: input.target }]
     }).steps[0].target;
+    this.assertNoNestedWorkflowGoal(target, input.goal);
     const loop = {
       id: genId(),
       name: input.name,
@@ -1434,6 +1446,9 @@ class Store {
       if (this.hasRunningRun(current.id))
         throw new Error(`refusing to retarget running loop: ${current.id}`);
       const workflow = this.requireWorkflow(workflowId);
+      if (current.goal && workflow.goal) {
+        throw new Error(`workflow loop cannot retarget ${current.name} to workflow ${workflow.name} because both define top-level goals`);
+      }
       const target = { ...current.target, workflowId: workflow.id };
       if (opts.workflowTimeoutMs !== undefined)
         target.timeoutMs = opts.workflowTimeoutMs;
@@ -1472,6 +1487,9 @@ class Store {
         throw new Error(`loop is not a workflow loop: ${idOrName}`);
       if (this.hasRunningRun(current.id))
         throw new Error(`refusing to retarget running loop: ${current.id}`);
+      if (current.goal && normalized.goal) {
+        throw new Error(`workflow loop cannot retarget ${current.name} to a workflow that also defines a top-level goal`);
+      }
       const previousWorkflow = this.requireWorkflow(current.target.workflowId);
       const workflow = {
         id: genId(),
@@ -1763,7 +1781,7 @@ class Store {
     if (!sourceDedupeKey)
       throw new Error("cannot refresh workflow invocation without sourceRef.dedupeKey");
     const now = nowIso();
-    const claimableStatuses = ["queued", "deferred", "failed", "dead_letter", "cancelled"];
+    const claimableStatuses = ["queued", "deferred"];
     const statusBindings = Object.fromEntries(claimableStatuses.map((status, index) => [`$status${index}`, status]));
     const placeholders = claimableStatuses.map((_, index) => `$status${index}`).join(",");
     const result = this.db.query(`UPDATE workflow_invocations
@@ -1844,28 +1862,35 @@ class Store {
           project_group=excluded.project_group,
           priority=excluded.priority,
           status=CASE
-            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running')
+            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled')
               THEN workflow_work_items.status
             ELSE excluded.status
           END,
           workflow_id=CASE
-            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running') THEN workflow_work_items.workflow_id
+            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled') THEN workflow_work_items.workflow_id
             ELSE NULL
           END,
           loop_id=CASE
-            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running') THEN workflow_work_items.loop_id
+            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled') THEN workflow_work_items.loop_id
             ELSE NULL
           END,
           workflow_run_id=CASE
-            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running') THEN workflow_work_items.workflow_run_id
+            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled') THEN workflow_work_items.workflow_run_id
             ELSE NULL
           END,
           lease_expires_at=CASE
-            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running') THEN workflow_work_items.lease_expires_at
+            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled') THEN workflow_work_items.lease_expires_at
             ELSE NULL
           END,
           next_attempt_at=excluded.next_attempt_at,
-          last_reason=COALESCE(excluded.last_reason, workflow_work_items.last_reason),
+          last_reason=CASE
+            WHEN workflow_work_items.attempts > 0
+              AND workflow_work_items.status IN ('queued', 'deferred')
+              AND workflow_work_items.last_reason IS NOT NULL
+              AND excluded.last_reason IS NOT NULL
+              THEN workflow_work_items.last_reason || '; ' || excluded.last_reason
+            ELSE COALESCE(excluded.last_reason, workflow_work_items.last_reason)
+          END,
           updated_at=excluded.updated_at`).run({
       $id: id,
       $routeKey: input.routeKey,
@@ -1918,11 +1943,39 @@ class Store {
     const projectGroup = args.projectGroup ? this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders}) AND project_group = ?`).get(...active, args.projectGroup)?.count ?? 0 : undefined;
     return { global, project, ...projectGroup !== undefined ? { projectGroup } : {} };
   }
+  requeueWorkflowWorkItem(id, patch = {}) {
+    const current = this.getWorkflowWorkItem(id);
+    if (!current)
+      throw new Error(`workflow work item not found: ${id}`);
+    const requeueableStatuses = ["succeeded", "failed", "dead_letter", "cancelled"];
+    if (!requeueableStatuses.includes(current.status)) {
+      throw new Error(`workflow work item is not requeueable: ${id} status=${current.status}`);
+    }
+    const now = nowIso();
+    const reason = patch.reason?.trim() || `requeued from ${current.status}`;
+    const placeholders = requeueableStatuses.map(() => "?").join(",");
+    const res = this.db.query(`UPDATE workflow_work_items
+         SET status='queued', workflow_id=NULL, loop_id=NULL, workflow_run_id=NULL,
+          next_attempt_at=NULL, lease_expires_at=NULL, last_reason=?, updated_at=?
+         WHERE id=? AND status IN (${placeholders})`).run(reason, now, id, ...requeueableStatuses);
+    const item = this.getWorkflowWorkItem(id);
+    if (!item)
+      throw new Error(`workflow work item not found after requeue: ${id}`);
+    if (res.changes !== 1)
+      throw new Error(`workflow work item was not requeued: ${id} status=${item.status}`);
+    return item;
+  }
   admitWorkflowWorkItem(id, patch) {
     const now = nowIso();
     const res = this.db.query(`UPDATE workflow_work_items
          SET status='admitted', attempts=attempts + 1, workflow_id=$workflowId, loop_id=$loopId,
-          next_attempt_at=NULL, lease_expires_at=NULL, last_reason=$reason, updated_at=$updated
+          next_attempt_at=NULL,
+          lease_expires_at=NULL,
+          last_reason=CASE
+            WHEN last_reason IS NOT NULL AND $reason IS NOT NULL THEN last_reason || '; ' || $reason
+            ELSE COALESCE($reason, last_reason)
+          END,
+          updated_at=$updated
          WHERE id=$id AND status IN ('queued', 'deferred')`).run({
       $id: id,
       $workflowId: patch.workflowId,
@@ -3464,6 +3517,9 @@ function assertSupportedAgentOptions(target) {
   assertStringOption(target.agent, `${target.provider}.agent`);
   assertStringOption(target.authProfile, `${target.provider}.authProfile`);
   assertStringOption(target.configIsolation, `${target.provider}.configIsolation`);
+  if (target.provider === "opencode" && (target.model === undefined || target.model.trim() === "")) {
+    throw new Error("opencode.model is required; pass a provider/model id such as openrouter/google/gemini-2.5-flash");
+  }
   if (target.configIsolation !== undefined && target.configIsolation !== "safe" && target.configIsolation !== "none") {
     throw new Error(`${target.provider}.configIsolation must be safe or none`);
   }
@@ -4236,6 +4292,78 @@ function sameBlockerKey(values) {
   return values.map((value) => value.trim()).filter(Boolean).join(`
 `) || "goal completion remains unproven";
 }
+function planStatusForGoal(goal) {
+  if (goal.status === "usageLimited")
+    return "blocked";
+  return goal.status;
+}
+function syncReadyFlags(store, goal, nodes, opts) {
+  const withReady = updateReadyFlags(nodes, planStatusForGoal(goal));
+  for (const node of withReady) {
+    const current = nodes.find((entry) => entry.key === node.key);
+    if (current && current.ready !== node.ready) {
+      store.updateGoalPlanNode(goal.goalId, node.key, { ready: node.ready }, { daemonLeaseId: opts.daemonLeaseId });
+    }
+  }
+  return withReady;
+}
+function summarizeLabels(values, limit = 5) {
+  if (values.length <= limit)
+    return values.join(", ");
+  return `${values.slice(0, limit).join(", ")} and ${values.length - limit} more`;
+}
+function noReadyDiagnostic(goal, nodes) {
+  const planStatus = planStatusForGoal(goal);
+  const byKey = new Map(nodes.map((node) => [node.key, node]));
+  const pendingNodes = nodes.filter((node) => node.status === "pending");
+  const incompleteNodes = nodes.filter((node) => node.status !== "complete");
+  const pendingDetails = pendingNodes.map((node) => ({
+    key: node.key,
+    status: node.status,
+    ready: node.ready,
+    tokenBudget: node.tokenBudget,
+    tokensUsed: node.tokensUsed,
+    budgetExhausted: nodeBudgetExhausted(node),
+    unmetDependencies: node.dependsOn.map((dependency) => ({ key: dependency, status: byKey.get(dependency)?.status ?? "missing" })).filter((dependency) => dependency.status !== "complete")
+  }));
+  const incompleteDetails = incompleteNodes.map((node) => ({
+    key: node.key,
+    status: node.status,
+    ready: node.ready
+  }));
+  let owner = "goal-plan";
+  let cause = "goal plan has no ready nodes";
+  if (planStatus !== "active") {
+    owner = "goal";
+    cause = `goal status is ${goal.status}`;
+  } else if (pendingNodes.length === 0) {
+    owner = "goal-plan";
+    cause = `goal plan has no pending runnable nodes; incomplete nodes: ${summarizeLabels(incompleteDetails.map((node) => `${node.key}:${node.status}`))}`;
+  } else if (pendingDetails.every((node) => node.budgetExhausted)) {
+    owner = "goal-plan-node";
+    cause = `all pending nodes are budget-exhausted: ${summarizeLabels(pendingDetails.map((node) => node.key))}`;
+  } else {
+    const missingDependencies = pendingDetails.flatMap((node) => node.unmetDependencies.filter((dependency) => dependency.status === "missing").map((dependency) => `${node.key}->${dependency.key}`));
+    if (missingDependencies.length > 0) {
+      owner = "goal-plan";
+      cause = `pending nodes reference missing dependencies: ${summarizeLabels(missingDependencies)}`;
+    } else if (pendingDetails.every((node) => node.unmetDependencies.length > 0 || node.budgetExhausted)) {
+      owner = "goal-plan-node";
+      const waiting = pendingDetails.filter((node) => node.unmetDependencies.length > 0).map((node) => `${node.key} waits on ${node.unmetDependencies.map((dependency) => `${dependency.key}:${dependency.status}`).join(",")}`);
+      const exhausted = pendingDetails.filter((node) => node.budgetExhausted).map((node) => `${node.key} budget exhausted`);
+      cause = `pending nodes are blocked by prerequisites: ${summarizeLabels([...waiting, ...exhausted])}`;
+    }
+  }
+  const blocker = `${cause}; owner=${owner}`;
+  return {
+    owner,
+    blocker,
+    planStatus,
+    rollup: rollupSummary(nodes),
+    pendingNodes: pendingDetails,
+    incompleteNodes: incompleteDetails
+  };
+}
 function metadataFor(goal, node, context) {
   return {
     loopId: context?.loopId,
@@ -4296,13 +4424,14 @@ async function planGoal(store, goal, spec, model, opts) {
   }, { daemonLeaseId: opts.daemonLeaseId });
   return store.createGoalPlanNodes(goal.goalId, rawNodes, { daemonLeaseId: opts.daemonLeaseId });
 }
-function stdoutFor(goal, nodes, evidence, validation) {
+function stdoutFor(goal, nodes, evidence, validation, diagnostics) {
   return JSON.stringify({
     goal,
     rollup: rollupSummary(nodes),
     nodes,
     evidence,
-    validation
+    validation,
+    diagnostics
   }, null, 2);
 }
 async function runGoal(store, input, opts = {}) {
@@ -4335,6 +4464,7 @@ async function runGoal(store, input, opts = {}) {
   let validation;
   let lastBlocker = "";
   let repeatedBlockerCount = 0;
+  let lastDiagnostic;
   if (budgetExhausted(goal)) {
     goal = store.updateGoalStatus(goal.goalId, "budgetLimited", { daemonLeaseId: opts.daemonLeaseId });
     return resultFromGoal(goal, "failed", stdoutFor(goal, nodes, evidence), "goal token budget exhausted after planning", startedAt);
@@ -4345,13 +4475,13 @@ async function runGoal(store, input, opts = {}) {
       return resultFromGoal(goal, "failed", stdoutFor(goal, nodes, evidence), "goal cancelled", startedAt);
     }
     goal = store.requireGoal(goal.goalId);
-    nodes = store.listGoalPlanNodes(goal.goalId);
+    nodes = syncReadyFlags(store, goal, store.listGoalPlanNodes(goal.goalId), opts);
     if (budgetExhausted(goal)) {
       goal = store.updateGoalStatus(goal.goalId, "budgetLimited", { daemonLeaseId: opts.daemonLeaseId });
       return resultFromGoal(goal, "failed", stdoutFor(goal, nodes, evidence), "goal token budget exhausted", startedAt);
     }
     const readyKeys = readyNodeKeys({
-      status: goal.status === "active" ? "active" : goal.status === "budgetLimited" ? "budgetLimited" : "blocked",
+      status: planStatusForGoal(goal),
       nodes
     });
     if (readyKeys.length > 0) {
@@ -4450,7 +4580,9 @@ ${result.stderr}`);
       }
       continue;
     }
-    const blocker = "no ready goal nodes and goal plan is incomplete";
+    const diagnostic = noReadyDiagnostic(goal, nodes);
+    lastDiagnostic = diagnostic;
+    const blocker = diagnostic.blocker;
     if (blocker === lastBlocker)
       repeatedBlockerCount += 1;
     else {
@@ -4462,15 +4594,16 @@ ${result.stderr}`);
       turn,
       phase: "status",
       status: repeatedBlockerCount >= 3 ? "blocked" : "active",
-      evidence: { blocker }
+      evidence: diagnostic
     }, { daemonLeaseId: opts.daemonLeaseId });
     if (repeatedBlockerCount >= 3) {
       goal = store.updateGoalStatus(goal.goalId, "blocked", { daemonLeaseId: opts.daemonLeaseId });
-      return resultFromGoal(goal, "failed", stdoutFor(goal, nodes, evidence, validation), blocker, startedAt);
+      return resultFromGoal(goal, "failed", stdoutFor(goal, nodes, evidence, validation, diagnostic), blocker, startedAt);
     }
   }
   goal = store.updateGoalStatus(goal.goalId, "usageLimited", { daemonLeaseId: opts.daemonLeaseId });
-  return resultFromGoal(goal, "failed", stdoutFor(goal, store.listGoalPlanNodes(goal.goalId), evidence, validation), "goal max turns exhausted", startedAt);
+  const exhaustedError = lastDiagnostic?.blocker ?? (lastBlocker ? `${lastBlocker}; max turns exhausted` : "goal max turns exhausted");
+  return resultFromGoal(goal, "failed", stdoutFor(goal, store.listGoalPlanNodes(goal.goalId), evidence, validation, lastDiagnostic), exhaustedError, startedAt);
 }
 
 // src/lib/workflow-runner.ts
@@ -4499,6 +4632,7 @@ async function executeWorkflow(store, workflow, opts = {}) {
     const workflowWithoutGoal = { ...workflow, goal: undefined };
     return runGoal(store, workflow.goal, {
       ...opts,
+      model: opts.goalModel,
       context: {
         loopId: opts.loop?.id,
         loopName: opts.loop?.name,
@@ -4591,6 +4725,7 @@ async function executeWorkflow(store, workflow, opts = {}) {
       if (step.goal) {
         result = await runGoal(store, step.goal, {
           ...opts,
+          model: opts.goalModel,
           target: targetWithStepAccount(step),
           signal: controller.signal,
           context: {
@@ -4732,6 +4867,7 @@ async function executeLoopTarget(store, loop, run, opts = {}) {
     if (loop.goal) {
       return runGoal(store, loop.goal, {
         ...opts,
+        model: opts.goalModel,
         target: loop.target,
         context: {
           loopId: loop.id,
@@ -4753,8 +4889,10 @@ async function executeLoopTarget(store, loop, run, opts = {}) {
     }
   }
   if (loop.goal) {
+    const workflowForLoopGoal = workflow.goal ? { ...workflow, goal: undefined } : workflow;
     return runGoal(store, loop.goal, {
       ...opts,
+      model: opts.goalModel,
       context: {
         loopId: loop.id,
         loopName: loop.name,
@@ -4763,7 +4901,7 @@ async function executeLoopTarget(store, loop, run, opts = {}) {
         workflowId: workflow.id,
         workflowName: workflow.name
       },
-      executeNode: async (node) => executeWorkflow(store, workflow, {
+      executeNode: async (node) => executeWorkflow(store, workflowForLoopGoal, {
         ...opts,
         loop,
         loopRun: run,
@@ -5493,14 +5631,15 @@ function enableStartup(result) {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.3.56",
+  version: "0.3.58",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
   types: "dist/index.d.ts",
   bin: {
     loops: "dist/cli/index.js",
-    "loops-daemon": "dist/daemon/index.js"
+    "loops-daemon": "dist/daemon/index.js",
+    "loops-mcp": "dist/mcp/index.js"
   },
   exports: {
     ".": {
@@ -5511,6 +5650,10 @@ var package_default = {
       types: "./dist/sdk/index.d.ts",
       import: "./dist/sdk/index.js"
     },
+    "./mcp": {
+      types: "./dist/mcp/index.d.ts",
+      import: "./dist/mcp/index.js"
+    },
     "./storage": {
       types: "./dist/lib/store.d.ts",
       import: "./dist/lib/store.js"
@@ -5523,7 +5666,7 @@ var package_default = {
     "LICENSE"
   ],
   scripts: {
-    build: "rm -rf dist && bun build src/cli/index.ts src/daemon/index.ts src/index.ts src/sdk/index.ts src/lib/store.ts --outdir dist --target bun --packages external && chmod +x dist/cli/index.js dist/daemon/index.js && tsc -p tsconfig.build.json --emitDeclarationOnly --outDir dist",
+    build: "rm -rf dist && bun build src/cli/index.ts src/daemon/index.ts src/mcp/index.ts src/index.ts src/sdk/index.ts src/lib/store.ts --outdir dist --target bun --packages external && chmod +x dist/cli/index.js dist/daemon/index.js dist/mcp/index.js && tsc -p tsconfig.build.json --emitDeclarationOnly --outDir dist",
     "build:bin": "bun build src/cli/index.ts --compile --outfile dist/loops",
     typecheck: "tsc --noEmit",
     test: "bun test",
@@ -5559,6 +5702,7 @@ var package_default = {
   dependencies: {
     "@hasna/events": "^0.1.9",
     "@hasna/machines": "0.0.49",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@openrouter/ai-sdk-provider": "2.9.1",
     ai: "6.0.204",
     commander: "^13.1.0",

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export * from "./types.js";
 export { LoopsClient, loops, openAutomationsRuntimeBinding } from "./sdk/index.js";
 export type { LoopsClientOptions } from "./sdk/index.js";
+export { createLoopsMcpServer, listToolsForCli, LOOPS_MCP_TOOLS } from "./mcp/index.js";
+export type { LoopsMcpToolMetadata } from "./mcp/index.js";
 export { Store } from "./lib/store.js";
 export { parseDuration, parseCron, nextCronRun, initialNextRun, computeNextAfter } from "./lib/schedule.js";
 export { executeLoop, executeTarget, preflightTarget } from "./lib/executor.js";