@ai-setting/roy-agent-core 1.6.16 → 1.6.18

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-vkesx61c.js → roy-agent-core-e9jf4w3z.js}

@@ -7,7 +7,7 @@ import {
 import {
   getCurrentProcessRegistry,
   killProcessTree
-} from "./roy-agent-core-eaj0b1hm.js";
+} from "./roy-agent-core-44g3synv.js";
 import {
   init_decorator,
   wrapFunction

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

@@ -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";

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

@@ -1,6 +1,6 @@
 import {
   builtInPrompts
-} from "./roy-agent-core-pq1q854s.js";
+} from "./roy-agent-core-65vpkh7x.js";
 import {
   getXDGPath
 } from "./roy-agent-core-qxnbvgwe.js";

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-25ngkkpb.js → roy-agent-core-mvmgy9t0.js}

@@ -8,7 +8,7 @@ import {
   BackgroundTaskManager,
   createDelegateTool,
   createStopTool
-} from "./roy-agent-core-8v0hzw96.js";
+} from "./roy-agent-core-n1fx2fx4.js";
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
@@ -24,7 +24,7 @@ import {
   searchTasksTool,
   treeTasksTool,
   updateTaskTool
-} from "./roy-agent-core-r0t34bbh.js";
+} from "./roy-agent-core-c7e3htaq.js";
 import {
   createOperationTool,
   deleteOperationTool,