@ai-setting/roy-agent-core 1.6.17 → 1.6.19

package/dist/shared/@ai-setting/{roy-agent-core-r0t34bbh.js → roy-agent-core-c7e3htaq.js}

@@ -92,7 +92,101 @@ var TreeTasksToolSchema = z.object({
 init_env_context();
 init_logger();
 import { execSync } from "child_process";
-var logger = createLogger("task:tools:create");
+
+// src/env/task/task-child-context.ts
+init_logger();
+var logger = createLogger("task-child-context");
+var STRIPPED_KEYS = ["commit", "token", "secret", "password", "api_key"];
+function stripSensitiveKeys(obj) {
+  if (obj === null || obj === undefined)
+    return obj;
+  if (Array.isArray(obj))
+    return obj.map(stripSensitiveKeys);
+  if (typeof obj !== "object")
+    return obj;
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const lower = k.toLowerCase();
+    if (STRIPPED_KEYS.some((s) => lower.includes(s)))
+      continue;
+    out[k] = stripSensitiveKeys(v);
+  }
+  return out;
+}
+function inheritChildContext(args) {
+  const { parent, overrides = {} } = args;
+  const contextInherit = overrides.contextInherit !== false;
+  const inheritTags = overrides.inheritTags === true;
+  const project_path = overrides.projectPath ?? parent.projectPath ?? "unknown";
+  let parentCtx = {};
+  if (parent.contextJson && parent.contextJson.trim().length > 0) {
+    try {
+      const parsed = JSON.parse(parent.contextJson);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        parentCtx = parsed;
+      }
+    } catch (err) {
+      logger.debug(`[task-child-context] parent #${parent.taskId} context is malformed JSON; ` + `continuing with empty inherited context (${err instanceof Error ? err.message : String(err)})`);
+      parentCtx = {};
+    }
+  }
+  const childCtx = {};
+  if (contextInherit) {
+    if (parentCtx.worktree_path !== undefined && overrides.worktreePath === undefined) {
+      childCtx.worktree_path = parentCtx.worktree_path;
+    }
+    if (parentCtx.branch !== undefined && overrides.branch === undefined) {
+      childCtx.branch = parentCtx.branch;
+    }
+    if (parentCtx.parent_branch !== undefined) {
+      childCtx.parent_branch = parentCtx.parent_branch;
+    }
+    if (parentCtx.type !== undefined) {
+      childCtx.type = parentCtx.type;
+    }
+    if (parentCtx.prior_context && typeof parentCtx.prior_context === "object") {
+      const pc = parentCtx.prior_context;
+      const safe = {};
+      for (const [k, v] of Object.entries(pc)) {
+        if (k.toLowerCase() === "commit")
+          continue;
+        safe[k] = v;
+      }
+      if (Object.keys(safe).length > 0) {
+        childCtx.prior_context = safe;
+      }
+    }
+    const reserved = new Set([
+      "worktree_path",
+      "branch",
+      "parent_branch",
+      "type",
+      "prior_context",
+      "created_at"
+    ]);
+    for (const [k, v] of Object.entries(parentCtx)) {
+      if (reserved.has(k))
+        continue;
+      childCtx[k] = v;
+    }
+  }
+  if (overrides.worktreePath !== undefined)
+    childCtx.worktree_path = overrides.worktreePath;
+  if (overrides.branch !== undefined)
+    childCtx.branch = overrides.branch;
+  const createdAt = overrides.createdAt ?? new Date().toISOString();
+  childCtx.created_at = createdAt;
+  childCtx.child_of = parent.taskId;
+  const sanitized = stripSensitiveKeys(childCtx);
+  return {
+    project_path,
+    context: JSON.stringify(sanitized),
+    inheritedTags: inheritTags ? parent.tags ?? [] : []
+  };
+}
+
+// src/env/task/tools/create-tool.ts
+var logger2 = createLogger("task:tools:create");
 function detectWorktree() {
   try {
     const toplevel = execSync("git rev-parse --show-toplevel", {
@@ -242,9 +336,53 @@ function createTaskTool(taskComponent) {
       const sessionId = ctx.session_id || "unknown";
       const detectedWorktree = detectWorktree();
       let enrichedContext = params.context;
+      let inheritedProjectPath = params.project_path && params.project_path.trim() !== "" ? params.project_path : undefined;
+      let inheritedTags = params.tags;
+      let inheritedContext;
+      if (params.parent_task_id !== undefined && params.parent_task_id !== null) {
+        try {
+          const parent = await taskComponent.getTask(params.parent_task_id);
+          if (parent) {
+            const inherited = inheritChildContext({
+              parent: {
+                taskId: parent.id,
+                projectPath: parent.project_path,
+                contextJson: parent.context ?? "",
+                tags: parent.tags
+              },
+              overrides: {
+                projectPath: inheritedProjectPath,
+                branch: undefined,
+                worktreePath: undefined,
+                inheritTags: params.tags === undefined,
+                contextInherit: true
+              }
+            });
+            if (inheritedProjectPath === undefined) {
+              inheritedProjectPath = inherited.project_path;
+            }
+            if (params.tags === undefined)
+              inheritedTags = inherited.inheritedTags;
+            inheritedContext = inherited.context;
+          }
+        } catch (err) {
+          logger2.debug(`[task_create] failed to pre-load parent #${params.parent_task_id} for context inheritance: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
       try {
         const ctxObj = params.context ? JSON.parse(params.context) : {};
         const obj = typeof ctxObj === "object" && ctxObj !== null && !Array.isArray(ctxObj) ? ctxObj : {};
+        if (inheritedContext) {
+          try {
+            const inheritedObj = JSON.parse(inheritedContext);
+            if (inheritedObj && typeof inheritedObj === "object" && !Array.isArray(inheritedObj)) {
+              for (const [k, v] of Object.entries(inheritedObj)) {
+                if (obj[k] === undefined)
+                  obj[k] = v;
+              }
+            }
+          } catch {}
+        }
         if (!obj.created_at) {
           obj.created_at = new Date().toISOString();
         }
@@ -264,13 +402,13 @@ function createTaskTool(taskComponent) {
           type: params.type || "normal",
           goals_and_expected_deliverables: params.goals_and_expected_deliverables,
           due_date: params.due_date,
-          tags: params.tags,
+          tags: inheritedTags,
           sessionId,
-          project_path: params.project_path,
+          project_path: inheritedProjectPath ?? params.project_path,
           context: enrichedContext
         });
         setCurrentTaskId(task.id);
-        logger.info(`[createTask] Trace: Task #${task.id} created, currentTaskId=${task.id} set in EnvContext`);
+        logger2.info(`[createTask] Trace: Task #${task.id} created, currentTaskId=${task.id} set in EnvContext`);
         return {
           success: true,
           output: `Task created successfully: #${task.id} - ${task.title}`,
@@ -550,7 +688,7 @@ function batchDeleteTaskTool(taskComponent) {
 // src/env/task/tools/update-tool.ts
 init_env_context();
 init_logger();
-var logger2 = createLogger("tool:update-task");
+var logger3 = createLogger("tool:update-task");
 async function detectCycle(taskComponent, taskId, newParentId) {
   const visited = new Set;
   let currentId = newParentId;
@@ -624,7 +762,7 @@ function updateTaskTool(taskComponent) {
           });
         }
         setCurrentTaskId(task.id);
-        logger2.info(`[updateTask] Trace: Task #${task.id} updated, currentTaskId=${task.id} set in EnvContext`);
+        logger3.info(`[updateTask] Trace: Task #${task.id} updated, currentTaskId=${task.id} set in EnvContext`);
         return {
           success: true,
           output: `Task updated: #${task.id} - ${task.title}`,
@@ -678,7 +816,7 @@ function deleteTaskTool(taskComponent) {
 // src/env/task/tools/complete-tool.ts
 init_env_context();
 init_logger();
-var logger3 = createLogger("task:tools:complete");
+var logger4 = createLogger("task:tools:complete");
 function completeTaskTool(taskComponent) {
   return {
     name: "task_complete",
@@ -715,7 +853,7 @@ function completeTaskTool(taskComponent) {
           };
         }
         setCurrentTaskId(undefined);
-        logger3.info(`[completeTask] Trace: Task #${params.task_id} completed, currentTaskId cleared from EnvContext`);
+        logger4.info(`[completeTask] Trace: Task #${params.task_id} completed, currentTaskId cleared from EnvContext`);
         return {
           success: true,
           output: `Task completed: #${task.id} - ${task.title}`,

package/dist/shared/@ai-setting/{roy-agent-core-yr3fp8tv.js → roy-agent-core-f1cjs6c4.js}

@@ -2322,7 +2322,7 @@ var init_engine = __esm(() => {
         scheduler.markFailed(nodeId);
       }
     }
-    async checkLoopGuardWithSnapshot(sessionState, templateResolver, reEntryId, _snapshotPreviousOutput) {
+    async checkLoopGuardWithSnapshot(sessionState, templateResolver, reEntryId, snapshotPreviousOutput) {
       const guard = sessionState.dagManager.getLoopGuard(reEntryId);
       if (!guard) {
         return { trip: false, counterKey: "", nextCount: 0 };
@@ -2330,19 +2330,42 @@ var init_engine = __esm(() => {
       const counterKey = `_loop_guard_consecutive_${reEntryId}`;
       const previousCount = sessionState.loopGuardCounters.get(reEntryId) ?? 0;
       const previousValue = templateResolver.resolveValue(guard.previous_signal);
-      const cwd = guard.cwd ?? sessionState.config.workflowInput?.project_path ?? process.cwd();
+      const resolvedCwdRaw = templateResolver.resolveValue(guard.cwd);
+      const resolvedCwd = typeof resolvedCwdRaw === "string" && resolvedCwdRaw.length > 0 ? resolvedCwdRaw : undefined;
+      const resolvedCommandRaw = templateResolver.resolveValue(guard.current_signal_command);
+      const resolvedCommand = typeof resolvedCommandRaw === "string" && resolvedCommandRaw.length > 0 ? resolvedCommandRaw : guard.current_signal_command;
+      const cwd = resolvedCwd ?? sessionState.config.workflowInput?.project_path ?? process.cwd();
       let currentValue;
       try {
-        const { stdout } = await execFileAsync("/bin/sh", ["-c", guard.current_signal_command], {
+        const { stdout } = await execFileAsync("/bin/sh", ["-c", resolvedCommand], {
           cwd,
           timeout: 1e4
         });
         currentValue = stdout.trim();
       } catch (err) {
-        logger3.warn(`[WorkflowEngine] loop_guard command failed for ${reEntryId}: ${err instanceof Error ? err.message : String(err)}. Allowing re-entry.`);
-        return { trip: false, counterKey, nextCount: 0 };
+        const errMessage = err instanceof Error ? err.message : String(err);
+        logger3.error(`[WorkflowEngine] loop_guard command failed for ${reEntryId}: ${errMessage}. Counting as no-progress.`);
+        const nextCount2 = previousCount + 1;
+        const maxAllowed2 = guard.max_consecutive_no_progress;
+        if (nextCount2 >= maxAllowed2) {
+          const failMessage = guard.fail_message ?? `loop_guard command failed for ${reEntryId} after ${nextCount2} consecutive re-entries: ${errMessage}`;
+          return { trip: true, failMessage, counterKey, nextCount: nextCount2 };
+        }
+        sessionState.loopGuardCounters.set(reEntryId, nextCount2);
+        return { trip: false, counterKey, nextCount: nextCount2 };
       }
       if (previousValue === undefined) {
+        const snapshotHasContent = snapshotPreviousOutput !== undefined && snapshotPreviousOutput !== null && typeof snapshotPreviousOutput === "object" && Object.keys(snapshotPreviousOutput).length > 0;
+        if (snapshotHasContent) {
+          const nextCount2 = previousCount + 1;
+          const maxAllowed2 = guard.max_consecutive_no_progress;
+          if (nextCount2 >= maxAllowed2) {
+            const failMessage = guard.fail_message ?? `loop_guard previous_signal path unresolved for ${reEntryId} after ${nextCount2} consecutive re-entries: ${guard.previous_signal}`;
+            return { trip: true, failMessage, counterKey, nextCount: nextCount2 };
+          }
+          sessionState.loopGuardCounters.set(reEntryId, nextCount2);
+          return { trip: false, counterKey, nextCount: nextCount2 };
+        }
         return { trip: false, counterKey, nextCount: 0 };
       }
       const isUnchanged = JSON.stringify(previousValue) === JSON.stringify(currentValue);

package/dist/shared/@ai-setting/{roy-agent-core-4z7dzcgb.js → roy-agent-core-kkt2ndpf.js}

@@ -648,6 +648,128 @@ function buildErrorReturn(args) {
     }
   };
 }
+var MAX_ERROR_MESSAGE_CHARS = 1500;
+var ERROR_CLASSIFICATION_PREFIX = "[ErrorType=";
+function classifyError(error) {
+  if (error instanceof Error) {
+    const rawName = typeof error.name === "string" && error.name.trim() ? error.name.trim() : "Error";
+    const safeName = rawName.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 80);
+    if (!error.message)
+      return `${ERROR_CLASSIFICATION_PREFIX}${safeName}:EmptyMessage]`;
+    return `${ERROR_CLASSIFICATION_PREFIX}${safeName}]`;
+  }
+  if (error === null)
+    return `${ERROR_CLASSIFICATION_PREFIX}Null]`;
+  if (error === undefined)
+    return `${ERROR_CLASSIFICATION_PREFIX}Undefined]`;
+  if (typeof error === "string") {
+    if (error.trim().length === 0)
+      return `${ERROR_CLASSIFICATION_PREFIX}EmptyString]`;
+    return `${ERROR_CLASSIFICATION_PREFIX}String]`;
+  }
+  if (typeof error === "number")
+    return `${ERROR_CLASSIFICATION_PREFIX}Number]`;
+  if (typeof error === "boolean")
+    return `${ERROR_CLASSIFICATION_PREFIX}Boolean]`;
+  if (typeof error === "object")
+    return `${ERROR_CLASSIFICATION_PREFIX}Object]`;
+  return `${ERROR_CLASSIFICATION_PREFIX}Unknown]`;
+}
+function normalizeErrorMessage(error) {
+  if (error instanceof Error) {
+    if (typeof error.message === "string" && error.message.length > 0) {
+      return error.message;
+    }
+    return error.name && error.name !== "Error" ? error.name : "";
+  }
+  if (typeof error === "string")
+    return error;
+  if (typeof error === "number" || typeof error === "boolean") {
+    return String(error);
+  }
+  return "";
+}
+function sanitizeErrorMessage(message, sensitive) {
+  if (!message || sensitive.length === 0)
+    return message;
+  let sanitized = message;
+  const ordered = [...sensitive].sort((a, b) => b.length - a.length);
+  for (const secret of ordered) {
+    if (!secret)
+      continue;
+    sanitized = sanitized.split(secret).join("[REDACTED]");
+  }
+  return sanitized;
+}
+function capErrorLength(message, max = MAX_ERROR_MESSAGE_CHARS) {
+  if (typeof message !== "string" || message.length <= max)
+    return message;
+  const truncated = message.substring(0, max);
+  return `${truncated}…[truncated ${message.length - max} chars; original=${message.length}]`;
+}
+function errorMessageBaseFor(message) {
+  return typeof message === "string" && message.length > 0 ? message : "";
+}
+function collectSensitiveValues(input, messageForEnvScan) {
+  const sensitive = [];
+  if (input && typeof input === "object") {
+    for (const v of Object.values(input)) {
+      if (typeof v === "string" && v.length >= 6)
+        sensitive.push(v);
+    }
+  }
+  const envSecretKeys = new Set;
+  try {
+    for (const [k, v] of Object.entries(process.env ?? {})) {
+      if (typeof v !== "string" || v.length < 6)
+        continue;
+      const kLower = k.toLowerCase();
+      if (kLower.includes("token") || kLower.includes("secret") || kLower.includes("password") || kLower.includes("api_key") || kLower.includes("apikey")) {
+        sensitive.push(v);
+        envSecretKeys.add(k);
+      }
+    }
+  } catch {}
+  if (messageForEnvScan) {
+    try {
+      for (const [k, v] of Object.entries(process.env ?? {})) {
+        if (typeof v !== "string" || v.length < 8)
+          continue;
+        if (envSecretKeys.has(k))
+          continue;
+        if (messageForEnvScan.includes(v) && (/[0-9_-]/.test(v) || /^[A-Za-z0-9+/=_-]+$/.test(v))) {
+          sensitive.push(v);
+        }
+      }
+    } catch {}
+  }
+  return sensitive;
+}
+function extractStackSummary(message) {
+  if (typeof message !== "string" || message.length === 0)
+    return "";
+  const lines = message.split(/\r?\n/).map((l) => l.trimEnd()).filter((l) => l.length > 0);
+  if (lines.length === 0)
+    return "";
+  const picked = [lines[0]];
+  let frameCount = 0;
+  for (let i = 1;i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*(File\s+|at\s+)/.test(line)) {
+      picked.push(line);
+      frameCount++;
+      if (frameCount >= 3)
+        break;
+    }
+  }
+  const lastLine = lines[lines.length - 1];
+  if (picked[picked.length - 1] !== lastLine && !/^\s*(File\s+|at\s+)/.test(lastLine)) {
+    picked.push(lastLine);
+  }
+  const joined = picked.join(`
+`);
+  return joined.length > 600 ? joined.slice(0, 600) + "…[truncated]" : joined;
+}
 var RunWorkflowInputSchema = z8.object({
   workflow_name: z8.string().describe("Name of the workflow to run"),
   input: z8.record(z8.any()).optional().describe("Input to pass to the workflow"),
@@ -801,11 +923,42 @@ function createRunWorkflowTool(workflowService, hooks) {
         }
         durationMs = Date.now() - startTime;
         const finalRunId = capturedByCallback ? capturedRunId : result.runId ?? "";
+        const resolvedStatus = result.status;
+        const isResolvedFailure = resolvedStatus === "failed" || resolvedStatus === "stopped";
+        const sensitiveForResolved = collectSensitiveValues(input, errorMessageBaseFor(result.error ?? ""));
+        const sanitizedResolvedMessage = sanitizeErrorMessage(errorMessageBaseFor(result.error ?? ""), sensitiveForResolved);
+        const resolvedErrorClassification = result.error ? classifyError(new Error(result.error)) : "[ErrorType=EmptyMessage]";
+        const resolvedErrorMessage = capErrorLength(sanitizedResolvedMessage.length > 0 ? sanitizedResolvedMessage : "Workflow reported status=failed without an error message (runId=" + finalRunId + ")");
+        if (isResolvedFailure) {
+          const failureCode = result.error ? "WORKFLOW_FAILED" : "WORKFLOW_FAILED_NO_MESSAGE";
+          return {
+            success: false,
+            output: {
+              run_id: finalRunId,
+              session_id: result.sessionId ?? finalRunId,
+              status: resolvedStatus,
+              error: result.error,
+              error_code: failureCode,
+              error_message: result.error ? sanitizedResolvedMessage : "",
+              error_stack_summary: extractStackSummary(result.error ?? ""),
+              output: result.output,
+              duration_ms: result.durationMs || durationMs,
+              ...result.pendingNodeId ? { pending_node_id: result.pendingNodeId } : {},
+              ...result.query ? { query: result.query } : {},
+              ...result.agentSessionId ? { agent_session_id: result.agentSessionId } : {}
+            },
+            error: `${resolvedErrorMessage} ${resolvedErrorClassification} (runId: ${finalRunId})`,
+            metadata: {
+              execution_time_ms: durationMs,
+              run_id: finalRunId
+            }
+          };
+        }
         return {
-          success: result.status === "completed" || result.status === "paused",
+          success: resolvedStatus === "completed" || resolvedStatus === "paused",
           output: {
             run_id: finalRunId,
-            status: result.status,
+            status: resolvedStatus,
             output: result.output,
             error: result.error,
             duration_ms: result.durationMs || durationMs,
@@ -823,9 +976,13 @@ function createRunWorkflowTool(workflowService, hooks) {
           clearTimeout(timeoutHandle);
         }
         durationMs = Date.now() - startTime;
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorClassification = classifyError(error);
+        const rawErrorMessage = normalizeErrorMessage(error);
+        const errorMessageBase = rawErrorMessage.length > 0 ? rawErrorMessage : `${errorClassification} (no message from thrown value)`;
         const errorRunId = capturedRunId ?? reservedRunId;
-        if (errorMessage.includes("Workflow not found")) {
+        const sensitiveValues = collectSensitiveValues(input, errorMessageBase);
+        const sanitizedMessage = sanitizeErrorMessage(errorMessageBase, sensitiveValues);
+        if (sanitizedMessage.includes("Workflow not found")) {
           return buildErrorReturn({
             errorRunId,
             status: "failed",
@@ -833,7 +990,7 @@ function createRunWorkflowTool(workflowService, hooks) {
             durationMs
           });
         }
-        const isTimeoutLike = errorMessage.includes("abort") || errorMessage.includes("timed out") || errorMessage.includes("execution timeout:");
+        const isTimeoutLike = sanitizedMessage.includes("abort") || sanitizedMessage.includes("timed out") || sanitizedMessage.includes("execution timeout:");
         if (isTimeoutLike) {
           if (!timedOut) {
             attemptStopOnTimeout(workflowService, errorRunId, "timed out");
@@ -846,12 +1003,16 @@ function createRunWorkflowTool(workflowService, hooks) {
           });
         }
         if (logger7?.error) {
-          logger7.error(`Failed to run workflow: ${workflow_name}`, { error: errorMessage });
+          logger7.error(`Failed to run workflow: ${workflow_name}`, {
+            error: rawErrorMessage,
+            errorClassification
+          });
         }
+        const composed = rawErrorMessage.length > 0 ? `Failed to run workflow ${workflow_name}: ${sanitizedMessage} ${errorClassification}` : `Failed to run workflow ${workflow_name} ${errorClassification}: ${sanitizedMessage}`;
         return buildErrorReturn({
           errorRunId,
           status: "failed",
-          errorMessage: `Failed to run workflow ${workflow_name}: ${errorMessage}`,
+          errorMessage: capErrorLength(composed),
           durationMs
         });
       }

package/dist/shared/@ai-setting/{roy-agent-core-dnns0v64.js → roy-agent-core-m0wy7p0q.js}

@@ -1,6 +1,6 @@
 import {
   createAutoTaskPlugin
-} from "./roy-agent-core-yqxrekhg.js";
+} from "./roy-agent-core-btp589bw.js";
 import {
   ContextError,
   ErrorCodes

package/dist/shared/@ai-setting/{roy-agent-core-x36fsm47.js → roy-agent-core-mekk4as5.js}

@@ -6,7 +6,7 @@ import {
   WorkflowEngine,
   exports_engine,
   init_engine
-} from "./roy-agent-core-yr3fp8tv.js";
+} from "./roy-agent-core-f1cjs6c4.js";
 import {
   askUserTool,
   createRunWorkflowTool,
@@ -18,7 +18,7 @@ import {
   createWorkflowSearchTool,
   createWorkflowTagListTool,
   createWorkflowValidateTool
-} from "./roy-agent-core-4z7dzcgb.js";
+} from "./roy-agent-core-kkt2ndpf.js";
 import {
   WorkflowService
 } from "./roy-agent-core-r15sn7ve.js";