@ai-setting/roy-agent-core 1.7.64 → 1.7.65

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

@@ -22,7 +22,7 @@ import {
   searchTasksTool,
   treeTasksTool,
   updateTaskTool
-} from "./roy-agent-core-xw4wsj38.js";
+} from "./roy-agent-core-t0ktaevq.js";
 import {
   createOperationTool,
   deleteOperationTool,
@@ -410,7 +410,8 @@ class TaskComponent extends BaseComponent {
     const createCtx = {
       options: { ...options },
       sessionId,
-      tagService: this.tagService
+      tagService: this.tagService,
+      taskComponent: this
     };
     await this.executeHook(TaskHookPoints.BEFORE_CREATE, createCtx);
     const task = await this.store.createTask(createCtx.options);

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

@@ -1,3 +1,7 @@
+import {
+  NEW_TASK_ID_HASH_PLACEHOLDER,
+  NEW_TASK_ID_PLACEHOLDER
+} from "./roy-agent-core-tr3ep81v.js";
 import {
   getEnvContextOrEmpty,
   init_env_context,
@@ -47,7 +51,7 @@ var CreateTaskToolSchema = z.object({
 ` + `  C. 新建根任务 → 省略 parent_task_id（让树根 ≤10）
 ` + `如何找到 parent_task_id：使用 task_tree(depth=2) 获取的树形结构，
 ` + "根据节点 id 选择合适的父任务 ID（来自 tree 输出，**不要硬编码**数字）。"),
-  context: z.string().default('{"type":"unknown"}').describe("JSON string with time-space positioning information for task continuity. " + "This field is crucial for Agent task handoff. " + "Core fields: worktree_path (git worktree path), branch (current branch), type (feature/bug/refactor/chore). " + 'Example for coding: {"worktree_path": "/path/worktree", "branch": "feature/xyz", "type": "feature"}. ' + 'Example for other: {"type": "general"}. ' + `If unknown, use '{}' or '{"type":"unknown"}'. ` + "IMPORTANT: Must be a valid JSON string!")
+  context: z.string().default('{"type":"unknown"}').describe("JSON string with time-space positioning information for task continuity. " + "This field is crucial for Agent task handoff. " + "Core fields: worktree_path (git worktree path), branch (current branch), type (feature/bug/refactor/chore). " + 'Example for coding: {"worktree_path": "/path/worktree", "branch": "feature/xyz", "type": "feature"}. ' + 'Example for other: {"type": "general"}. ' + `If unknown, use '{}' or '{"type":"unknown"}'. ` + "IMPORTANT: Must be a valid JSON string! " + "**Task #4467 — similar_task_ids (REQUIRED)**: array of existing task ids that " + "cover the same ground as this request, used by the task:before.create decision " + "check to suggest reusing/reopening instead of creating a duplicate. " + "Search first (task_search / task_get), then pass the ids. " + "It may be an empty array [] if you searched and found nothing related — " + "but the field itself must be present. " + 'Example: {"type":"feature", "similar_task_ids": [4433, 4445]}')
 });
 var GetTaskToolSchema = withLegacyTaskId({
   include_operations: z.boolean().optional().default(true).describe("Include operation records (milestones / process log) with the task. " + "Defaults to true — the task's operation history is part of its detail. " + "Pass false for a lean task-only response.")
@@ -208,6 +212,19 @@ function inheritChildContext(args) {
 
 // src/env/task/tools/create-tool.ts
 var logger2 = createLogger("task:tools:create");
+function extractDecisionHint(contextJson) {
+  if (!contextJson)
+    return;
+  try {
+    const parsed = JSON.parse(contextJson);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return;
+    const hint = parsed.decision_hint;
+    return typeof hint === "string" && hint.length > 0 ? hint : undefined;
+  } catch {
+    return;
+  }
+}
 function detectWorktree() {
   try {
     const toplevel = execSync("git rev-parse --show-toplevel", {
@@ -247,6 +264,30 @@ function createTaskTool(taskComponent) {
         step 2: read the tree, then decide per "Decision Tree" below
         step 3: task_create({...})
 
+      ## ⚠️ STEP 1 — FIND SIMILAR TASKS FIRST (Task #4467)
+
+      Before creating a task, you **MUST** first look for existing tasks
+      that cover the same ground, and record them in
+      \`context.similar_task_ids\`. This lets the decision model detect
+      duplicates and suggest reusing / reopening an existing task instead
+      of piling up another root.
+
+      Workflow:
+        step 1: task_search({keywords: [...]}) or task_get(...) to find
+                existing tasks related to this request
+        step 2: collect the relevant task ids (0 or more)
+        step 3: task_create({..., context: {..., similar_task_ids: [id1, id2]}})
+
+      \`context.similar_task_ids\` is **required** (may be an empty array \`[]\`
+      if you searched and found nothing related). It is an array of task ids.
+
+      The decision check runs on \`task:before.create\` and only **advises** —
+      the task is always created. If the output contains a
+      \`[TASK_CREATE_HINT]\` section, you **MUST** read and verify it:
+      verify with \`task_get\`, then either execute the suggested
+      \`task_update\` (reusing / reopening / re-parenting) or explicitly
+      state why it was not adopted. Never ignore it.
+
       ## Decision Tree — How to choose parent_task_id
 
       Walk these paths in order:
@@ -454,9 +495,14 @@ function createTaskTool(taskComponent) {
         });
         setCurrentTaskId(task.id);
         logger2.info(`[createTask] Trace: Task #${task.id} created, currentTaskId=${task.id} set in EnvContext`);
+        const decisionHint = extractDecisionHint(task.context);
+        const renderedHint = decisionHint ? decisionHint.replaceAll(NEW_TASK_ID_HASH_PLACEHOLDER, `#${task.id}`).replaceAll(NEW_TASK_ID_PLACEHOLDER, String(task.id)) : "";
+        const output = `Task created successfully: #${task.id} - ${task.title}` + (renderedHint ? `
+
+${renderedHint}` : "");
         return {
           success: true,
-          output: `Task created successfully: #${task.id} - ${task.title}`,
+          output,
           metadata: {
             execution_time_ms: 0,
             task_id: task.id,

package/dist/shared/@ai-setting/roy-agent-core-tr3ep81v.js

@@ -0,0 +1,397 @@
+import {
+  init_decorator,
+  wrapFunction
+} from "./roy-agent-core-qq96p0tj.js";
+
+// src/env/task/hooks/verdict.ts
+init_decorator();
+var MAX_SIMILAR_TASK_IDS = 20;
+var CANDIDATE_TITLE_MAX = 40;
+var CANDIDATE_DESC_MAX = 45;
+var CANDIDATE_TAGS_MAX = 4;
+var LEAKAGE_DENY_KEYS = [
+  "expected_decision",
+  "expected_root",
+  "expected_",
+  "case_id",
+  "category",
+  "suggested_",
+  "recommended_",
+  "best_match",
+  "answer",
+  "answer_key",
+  "label",
+  "should_",
+  "target",
+  "gold",
+  "ground_truth",
+  "hint",
+  "solution",
+  "duplicate_of",
+  "similar_task_ids",
+  "candidate_order",
+  "verdict",
+  "decision"
+];
+function parseSimilarTaskIdsImpl(contextJson) {
+  if (!contextJson)
+    return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(contextJson);
+  } catch {
+    return [];
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return [];
+  const raw = parsed.similar_task_ids;
+  if (!Array.isArray(raw))
+    return [];
+  const out = [];
+  const seen = new Set;
+  for (const item of raw) {
+    if (typeof item !== "number")
+      continue;
+    if (!Number.isInteger(item) || item <= 0)
+      continue;
+    if (seen.has(item))
+      continue;
+    seen.add(item);
+    out.push(item);
+    if (out.length >= MAX_SIMILAR_TASK_IDS)
+      break;
+  }
+  return out;
+}
+function deriveActionFromStatusImpl(status) {
+  switch (status) {
+    case "completed":
+    case "cancelled":
+    case "paused":
+    case "archived":
+      return "reopen";
+    case "todo":
+    case "active":
+    default:
+      return "enhance";
+  }
+}
+function deriveReopenStatus(status) {
+  return status === "paused" ? "active" : "todo";
+}
+var STATUS_LETTER = {
+  todo: "t",
+  active: "a",
+  completed: "c",
+  paused: "p",
+  cancelled: "x",
+  archived: "r"
+};
+var NEW_TASK_ID_PLACEHOLDER = "__NEW_TASK_ID__";
+var NEW_TASK_ID_HASH_PLACEHOLDER = "#__NEW_TASK_ID__";
+function buildHintTextImpl(input) {
+  switch (input.scenario) {
+    case "reuse":
+      return buildReuseHint(input);
+    case "reopen":
+      return buildReopenHint(input);
+    case "reopen_enhance":
+      return buildReopenEnhanceHint(input);
+    case "remount":
+      return buildRemountHint(input);
+    case "soft_reuse":
+      return buildSoftReuseHint(input);
+  }
+}
+function newTaskRef(input) {
+  return input.newTaskId > 0 ? String(input.newTaskId) : NEW_TASK_ID_PLACEHOLDER;
+}
+function newTaskHashRef(input) {
+  return input.newTaskId > 0 ? `#${input.newTaskId}` : NEW_TASK_ID_HASH_PLACEHOLDER;
+}
+function targetLine(input) {
+  const t = input.targetTask;
+  if (!t)
+    return "";
+  return `#${input.targetTaskId} [${t.type}] ${t.title}
+状态：${t.status}`;
+}
+function buildReuseHint(input) {
+  const goalsPart = input.includeGoals ? ", goals_and_expected_deliverables=<追加本次目标>" : "";
+  return [
+    "[TASK_CREATE_HINT] 检测到与已有任务高度相似，建议复用而非新建。",
+    "",
+    targetLine(input),
+    "状态：" + (input.targetTask?.status ?? "") + " ｜ 建议动作：enhance（补充目标/描述）",
+    "",
+    `如需合并到 #${input.targetTaskId}，可执行：`,
+    `  task_update(task_id=${input.targetTaskId}, description=<追加本次请求的描述>${goalsPart})`,
+    "",
+    `说明：本次已创建新任务 ${newTaskHashRef(input)}。若确认应复用 #${input.targetTaskId}，请调用上述 task_update 并按需归档 ${newTaskHashRef(input)}。`,
+    "",
+    "核实要点：本次请求是否就是 #" + input.targetTaskId + " 的「同一件事」，而不是同主题下新的一步？",
+    "  - 若只是同主题的新一步（需要独立跟踪的新子任务），建子任务不算不采纳，但需在回复中说明为何不直接合并。",
+    "  - 若确实是同一件事，应采纳 (a) 执行复用。",
+    "",
+    `⚠️ 你必须核实本提示：先用 task_get(${input.targetTaskId}) 确认目标任务的当前状态与内容是否与本次请求实质相同。`,
+    "核实后二选一执行：",
+    `(a) 确认实质相同 → 按上面的 task_update(task_id=${input.targetTaskId}, ...) 执行复用，并归档本次新建的任务 ${newTaskHashRef(input)}；`,
+    "(b) 确认不相似 → 在本次回复中明确说明不采纳的理由。",
+    "不允许无视本提示。"
+  ].join(`
+`);
+}
+function buildReopenHint(input) {
+  const targetStatus = input.targetTask?.status ?? "completed";
+  const reopenTo = deriveReopenStatus(targetStatus);
+  const goalsPart = input.includeGoals ? ", goals_and_expected_deliverables=<追加本次目标>" : "";
+  return [
+    "[TASK_CREATE_HINT] 检测到本次请求与已有任务实质相同，建议重开该任务而不是新建。",
+    "",
+    targetLine(input),
+    `状态：${targetStatus} ｜ 建议动作：reopen（恢复为 ${reopenTo}）`,
+    "",
+    `如需重开并承接本次请求，可执行：`,
+    `  task_update(task_id=${input.targetTaskId}, status=${reopenTo}, description=<追加本次请求的描述>${goalsPart})`,
+    "",
+    `说明：本次已创建新任务 ${newTaskHashRef(input)}。若确认应复用 #${input.targetTaskId}，请调用上述 task_update 并按需归档 ${newTaskHashRef(input)}。`,
+    "",
+    `核实要点：#${input.targetTaskId} 是否真的已完结（completed / cancelled），但其语义与本次请求仍然相同？`,
+    "  - 若已完结但语义仍相同（本次请求是该任务的延续）→ 应采纳 (a) 重开。",
+    "  - 若目标已完结且语义不同（只是主题相近）→ 应采纳 (b) 说明不采纳的理由。",
+    "",
+    `⚠️ 你必须核实本提示：先用 task_get(${input.targetTaskId}) 确认目标任务的当前状态与内容是否与本次请求实质相同。`,
+    "核实后二选一执行：",
+    `(a) 确认实质相同 → 按上面的 task_update(task_id=${input.targetTaskId}, status=${reopenTo}, ...) 执行重开，并归档本次新建的任务 ${newTaskHashRef(input)}；`,
+    "(b) 确认不相似 → 在本次回复中明确说明不采纳的理由。",
+    "不允许无视本提示。"
+  ].join(`
+`);
+}
+function buildReopenEnhanceHint(input) {
+  const targetStatus = input.targetTask?.status ?? "completed";
+  const reopenTo = deriveReopenStatus(targetStatus);
+  return [
+    "[TASK_CREATE_HINT] 检测到本次请求与已有任务实质相同，且本次新增了目标，建议重开并增强该任务。",
+    "",
+    targetLine(input),
+    `状态：${targetStatus} ｜ 建议动作：reopen + enhance（恢复为 ${reopenTo} 并追加目标）`,
+    "",
+    "如需重开并承接本次请求，可执行：",
+    `  task_update(task_id=${input.targetTaskId}, status=${reopenTo}, description=<追加本次请求的描述>, goals_and_expected_deliverables=<追加本次目标>)`,
+    "",
+    `说明：本次已创建新任务 ${newTaskHashRef(input)}。若确认应复用 #${input.targetTaskId}，请调用上述 task_update 并按需归档 ${newTaskHashRef(input)}。`,
+    "",
+    `核实要点：① #${input.targetTaskId} 是否真的已完结（completed / cancelled）但语义仍与本次请求相同；② 本次新增的目标是否确实属于该任务的范围内？`,
+    "  - 两点都成立 → 应采纳 (a) 重开并增强。",
+    "  - 新增目标超出原任务范围（是独立的新工作）→ 应采纳 (b) 说明不采纳的理由。",
+    "",
+    `⚠️ 你必须核实本提示：先用 task_get(${input.targetTaskId}) 确认目标任务的当前状态与内容是否与本次请求实质相同。`,
+    "核实后二选一执行：",
+    `(a) 确认实质相同 → 按上面的 task_update(task_id=${input.targetTaskId}, status=${reopenTo}, ..., goals_and_expected_deliverables=...) 执行重开并增强，并归档本次新建的任务 ${newTaskHashRef(input)}；`,
+    "(b) 确认不相似 → 在本次回复中明确说明不采纳的理由。",
+    "不允许无视本提示。"
+  ].join(`
+`);
+}
+function buildRemountHint(input) {
+  return [
+    "[TASK_CREATE_HINT] 检测到本次任务的挂载位置可能不合理。",
+    "",
+    `当前挂载：parent #${input.currentParentId} → root 祖先 #${input.currentRootAncestorId}`,
+    `建议归属：root #${input.recommendedRootId} ${input.recommendedRootTitle ?? ""}`.trimEnd(),
+    "",
+    "如需改挂到建议的 root 下，可执行：",
+    `  task_update(task_id=${newTaskRef(input)}, parent_task_id=${input.recommendedRootId})`,
+    "",
+    `说明：本次已创建新任务 ${newTaskHashRef(input)}，parent 未被自动修改。`,
+    "",
+    `核实要点：当前 parent #${input.currentParentId} 的 root 祖先 #${input.currentRootAncestorId} 与建议的 root #${input.recommendedRootId}，哪一条才是本次任务的正确归属线？（可参考兄弟任务的主题分布）`,
+    "  - 建议的 root 更贴合本次任务主题 → 应采纳 (a) 执行改挂。",
+    "  - 当前归属线已正确 → 应采纳 (b) 说明不采纳的理由。",
+    "",
+    `⚠️ 你必须核实本提示：先用 task_get(${newTaskRef(input)}) 确认本次新建任务的实际 parent，并用 task_get(${input.recommendedRootId})（必要时 task_tree）确认归属线是否真的不对。`,
+    "核实后二选一执行：",
+    `(a) 确认挂载不合理 → 执行改挂 task_update(task_id=${newTaskRef(input)}, parent_task_id=${input.recommendedRootId})；`,
+    "(b) 确认当前挂载合理 → 在本次回复中明确说明不采纳的理由。",
+    "不允许无视本提示。"
+  ].join(`
+`);
+}
+function buildSoftReuseHint(input) {
+  const goalsPart = input.includeGoals ? ", goals_and_expected_deliverables=<追加本次目标>" : "";
+  return [
+    "[TASK_CREATE_HINT] 检测到本次请求可能与已有任务有关联（置信度偏低，仅供参考）。",
+    "",
+    targetLine(input),
+    "",
+    "若确认是同一件事，可执行：",
+    `  task_update(task_id=${input.targetTaskId}, description=<追加本次请求的描述>${goalsPart})`,
+    "",
+    `说明：本提示基于较低置信度，可能误判。本次已创建新任务 ${newTaskHashRef(input)}。`,
+    "",
+    `核实要点：#${input.targetTaskId} 与本次请求是否确为同一件事？（本提示置信度低，核实权重相应降低，但不得跳过表态）`,
+    "",
+    `⚠️ 你必须核实本提示：先用 task_get(${input.targetTaskId}) 确认目标任务的当前状态与内容是否与本次请求实质相同。`,
+    "核实后二选一执行：",
+    `(a) 确认实质相同 → 按上面的 task_update(task_id=${input.targetTaskId}, ...) 执行复用，并归档本次新建的任务 ${newTaskHashRef(input)}；`,
+    "(b) 确认不相似 → 在本次回复中明确说明不采纳的理由。",
+    "不允许无视本提示。"
+  ].join(`
+`);
+}
+function isLeakingKey(key) {
+  const lower = key.toLowerCase();
+  return LEAKAGE_DENY_KEYS.some((deny) => deny.endsWith("_") || deny.endsWith("*") ? lower.startsWith(deny.slice(0, -1)) : lower === deny);
+}
+function assertNoLeakageImpl(state, questions) {
+  const walk = (node, path) => {
+    if (Array.isArray(node)) {
+      node.forEach((item, i) => walk(item, `${path}[${i}]`));
+      return;
+    }
+    if (!node || typeof node !== "object")
+      return;
+    for (const [key, value] of Object.entries(node)) {
+      const childPath = path ? `${path}.${key}` : key;
+      if (isLeakingKey(key)) {
+        throw new Error(`[assertNoLeakage] leakage key detected at ${childPath}: "${key}"`);
+      }
+      walk(value, childPath);
+    }
+  };
+  walk(state, "state");
+  walk(questions, "questions");
+}
+function writeDecisionHintImpl(options, hint) {
+  let parsed;
+  try {
+    parsed = JSON.parse(options.context);
+  } catch {
+    return false;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return false;
+  parsed.decision_hint = hint;
+  options.context = JSON.stringify(parsed);
+  return true;
+}
+function truncate(text, max) {
+  if (text.length <= max)
+    return text;
+  return text.slice(0, max) + "…";
+}
+function renderCandidateKey(c) {
+  return `#${c.id} [${c.type}] ${truncate(c.title, CANDIDATE_TITLE_MAX)}`;
+}
+function renderCandidateValue(c) {
+  const letter = STATUS_LETTER[c.status] ?? (c.status.charAt(0) || "t");
+  const desc = truncate(c.description, CANDIDATE_DESC_MAX);
+  const tags = (c.tags ?? []).slice(0, CANDIDATE_TAGS_MAX);
+  const tagsPart = tags.length > 0 ? ` [tags: ${tags.join(",")}]` : "";
+  return `${letter}|${c.ago}|${desc}${tagsPart}`;
+}
+function formatRelativeAge(isoTimestamp, now = Date.now()) {
+  const ts = Date.parse(isoTimestamp);
+  if (Number.isNaN(ts))
+    return "0m";
+  const diffMs = now - ts;
+  if (diffMs <= 0)
+    return "0m";
+  const minutes = Math.floor(diffMs / 60000);
+  if (minutes < 60)
+    return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24)
+    return `${hours}h`;
+  const days = Math.floor(hours / 24);
+  return `${days}d`;
+}
+var parseSimilarTaskIds = wrapFunction(parseSimilarTaskIdsImpl, "task.decision.parseSimilarTaskIds", {
+  recordParams: true,
+  recordResult: true,
+  log: false,
+  paramFilter: (args) => {
+    const raw = args[0];
+    const ctx = typeof raw === "string" ? raw : "";
+    return {
+      contextLen: ctx.length,
+      contextPreview: ctx.length > 80 ? ctx.slice(0, 80) + "…" : ctx
+    };
+  },
+  resultFilter: (res) => ({ count: res.length, ids: res.join(",") })
+});
+var deriveActionFromStatus = wrapFunction(deriveActionFromStatusImpl, "task.decision.deriveActionFromStatus", {
+  recordParams: true,
+  recordResult: true,
+  log: false
+});
+var buildHintText = wrapFunction(buildHintTextImpl, "task.decision.buildHintText", {
+  recordParams: true,
+  recordResult: true,
+  log: false,
+  paramFilter: (args) => {
+    const i = args[0] ?? {};
+    return {
+      scenario: i.scenario,
+      newTaskId: i.newTaskId,
+      targetTaskId: i.targetTaskId ?? null,
+      recommendedRootId: i.recommendedRootId ?? null,
+      currentParentId: i.currentParentId ?? null,
+      confidence: i.confidence ?? null
+    };
+  },
+  resultFilter: (res) => ({
+    hintLen: res.length,
+    hintPreview: res.slice(0, 240),
+    hasTaskUpdate: /task_update\s*\(/.test(res),
+    hasTaskId: /"task_id"\s*:/.test(res),
+    hasParentTaskId: /"parent_task_id"\s*:/.test(res)
+  })
+});
+var assertNoLeakage = wrapFunction(assertNoLeakageImpl, "task.decision.assertNoLeakage", {
+  recordParams: true,
+  recordResult: false,
+  log: false,
+  paramFilter: (args) => ({
+    stateKeys: collectKeyNames(args[0]),
+    questionKeys: collectKeyNames(args[1])
+  })
+});
+var writeDecisionHint = wrapFunction(writeDecisionHintImpl, "task.decision.writeDecisionHint", {
+  recordParams: true,
+  recordResult: true,
+  log: false,
+  paramFilter: (args) => {
+    const opts = args[0] ?? {};
+    const hint = typeof args[1] === "string" ? args[1] : "";
+    return {
+      contextLen: typeof opts.context === "string" ? opts.context.length : 0,
+      hintLen: hint.length,
+      hintScenario: /task_update\s*\(/.test(hint) ? "actionable" : "plain"
+    };
+  },
+  resultFilter: (res) => ({ written: res }),
+  errorIf: (res) => res === false ? new Error("writeDecisionHint returned false (context not a JSON object)") : undefined
+});
+function collectKeyNames(node, out = [], depth = 0) {
+  if (out.length >= 40 || depth > 4)
+    return out;
+  if (Array.isArray(node)) {
+    for (const item of node.slice(0, 3))
+      collectKeyNames(item, out, depth + 1);
+    return out;
+  }
+  if (!node || typeof node !== "object")
+    return out;
+  for (const key of Object.keys(node)) {
+    if (out.length >= 40)
+      break;
+    if (!out.includes(key))
+      out.push(key);
+    collectKeyNames(node[key], out, depth + 1);
+  }
+  return out;
+}
+
+export { NEW_TASK_ID_PLACEHOLDER, NEW_TASK_ID_HASH_PLACEHOLDER, renderCandidateKey, renderCandidateValue, formatRelativeAge, parseSimilarTaskIds, deriveActionFromStatus, buildHintText, assertNoLeakage, writeDecisionHint };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.7.64",
+  "version": "1.7.65",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",