@ai-setting/roy-agent-core 1.7.70 → 1.7.72

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

@@ -13,17 +13,17 @@ import {
   createPerTaskGroupChatPlugin,
   extractPerTaskChatId,
   extractPerTaskChatName
-} from "./roy-agent-core-hx46nhh1.js";
+} from "./roy-agent-core-5gw0qa8m.js";
 import {
   getSharedEventStore
 } from "./roy-agent-core-na18zwj0.js";
 import {
   createLarkCliWorkflowNotifyHook
-} from "./roy-agent-core-8bjj3d1b.js";
+} from "./roy-agent-core-1w9y7mxj.js";
 import {
   LarkCardPatchNotifier,
   buildTaskCard
-} from "./roy-agent-core-tadj19vp.js";
+} from "./roy-agent-core-46rv4d7d.js";
 import {
   normalizeLarkAtMentions
 } from "./roy-agent-core-m880qz3y.js";
@@ -1720,6 +1720,85 @@ var listCommand = {
   }
 };
 
+// src/env/event-source/reset-command.ts
+import { connect } from "net";
+var DEFAULT_SOCKET_PATH = "/tmp/deamon-for-roy.sock";
+var RESET_ACK_TIMEOUT_MS = 3000;
+function resolveSocketPath() {
+  return process.env.ROY_DAEMON_SOCKET || DEFAULT_SOCKET_PATH;
+}
+async function requestReset(socketPath, reason) {
+  return new Promise((resolve) => {
+    let sock;
+    try {
+      sock = connect(socketPath);
+    } catch (e) {
+      resolve({ confirmed: false, reason: e.message });
+      return;
+    }
+    let settled = false;
+    const finish = (confirmed, why) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      sock.destroy();
+      resolve({ confirmed, reason: why });
+    };
+    const timer = setTimeout(() => finish(false, `daemon 未在 ${RESET_ACK_TIMEOUT_MS}ms 内确认`), RESET_ACK_TIMEOUT_MS);
+    sock.once("connect", () => {
+      sock.write(JSON.stringify({ type: "reset", reason }) + `
+`);
+    });
+    let buf = "";
+    sock.on("data", (d) => {
+      buf += d.toString();
+      const idx = buf.indexOf(`
+`);
+      if (idx < 0)
+        return;
+      try {
+        const ack = JSON.parse(buf.slice(0, idx));
+        if (ack.type === "ack" && ack.action === "respawning") {
+          finish(true, "daemon 已确认");
+        } else {
+          finish(false, `daemon 回复异常: ${buf.slice(0, idx)}`);
+        }
+      } catch (e) {
+        finish(false, `daemon 回复解析失败: ${e.message}`);
+      }
+    });
+    sock.once("error", (e) => finish(false, `连接 daemon 失败: ${e.message}`));
+  });
+}
+function buildResetCard(text) {
+  return renderTextCard("\uD83D\uDD04 重启请求", text);
+}
+var resetCommand = {
+  name: "reset",
+  description: "请求 deamon-for-roy 重启本进程（SIGTERM 后用最新构建的 roy-agent-local 重新拉起）",
+  usage: "##command##: reset [reason]",
+  async execute(ctx) {
+    const reason = ctx.args.join(" ") || undefined;
+    const socketPath = resolveSocketPath();
+    const { confirmed, reason: why } = await requestReset(socketPath, reason);
+    if (confirmed) {
+      const text2 = "✅ 已请求重启：daemon 将停止本进程并用最新版本重新拉起，请稍候片刻。";
+      return {
+        ok: true,
+        output: { text: text2, card: buildResetCard(text2), kind: "card" }
+      };
+    }
+    const text = `⚠️ 未能联系 daemon，重启请求未生效（${why}）。
+` + `socket: ${socketPath}
+` + `请检查 deamon-for-roy 是否在运行；本进程将继续工作，不会中断。`;
+    return {
+      ok: true,
+      output: { text, card: buildResetCard(text), kind: "card" }
+    };
+  }
+};
+
 // src/env/event-source/command-registry.ts
 var logger2 = createLogger("command-registry");
 var COMMAND_PREFIX = "##command##:";
@@ -1812,6 +1891,7 @@ function getGlobalCommandRegistry() {
     const registry = new CommandRegistry;
     registry.register(fallbackModelCommand);
     registry.register(listCommand);
+    registry.register(resetCommand);
     g.__royCommandRegistry = registry;
   }
   return g.__royCommandRegistry;

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

@@ -1,8 +1,9 @@
 import {
   TASK_COMPLETE_ITEM_BY_ITEM,
   TASK_COMPLETE_VERIFY_DUTY,
-  TASK_COMPLETION_HINT_ANCHOR
-} from "./roy-agent-core-6m4bw8jy.js";
+  TASK_COMPLETION_HINT_ANCHOR,
+  TASK_DISCIPLINE_PROMPT
+} from "./roy-agent-core-4jjwewvw.js";
 
 // src/env/prompt/prompts-index.ts
 var builtInPrompts = {
@@ -832,163 +833,7 @@ roy-agent <command> <subcmd> --help
 | \`delegate_task\` | 子 agent 委托入口，由 \`default\` 接待员独占 | 直接用 \`bash\` / \`read_file\` / \`edit_file\` 等工具自己完成任务；若是真正的复杂多步任务，建议用户切换到 \`default\` agent |
 | \`stop_task\` | 后台进程管理入口，由 \`default\` 接待员独占 | 你无法启动后台进程，自然不需要 \`stop_task\` |
 
-### Task Lifecycle
-
-Follow this lifecycle for every task:
-
-\`\`\`text
-┌─────────────────────────────────────────────────────────────────┐
-│ 0. CHECK TASK CONTEXT OR SEARCH                                  │
-│    - First: Check if [当前 Task #N] is in the context            │
-│      If yes → use \`task_get #N\` directly, skip to step 1      │
-│    - If no taskId in context:                                    │
-│      Use \`task_list\` to search for existing related tasks      │
-│    - If found → reuse, extend, and update (see rules below)     │
-│    - If not found → proceed to step 1                           │
-└─────────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────────┐
-│ 1. CREATE (task_create) OR REUSE (task_get + task_update)       │
-│    - No existing task → Create new with title, desc, goals      │
-│    - Existing task → Reuse via task_get, then task_update:      │
-│      * Append new context to description (preserve old)         │
-│      * Add/extend goals_and_expected_deliverables               │
-│      * Create operation record documenting the continuation     │
-│    - Set priority (low/medium/high) and due date (if any)       │
-└─────────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────────┐
-│ 2. GATHER CONTEXT (task_get + task_operation_list)              │
-│    - Read description, goals, current_status                      │
-│    - Check parent_task_id for sub-tasks                          │
-│    - Review recent operations for history and decisions           │
-│                                                                   │
-│ ⚠️ REQUIRED: Never skip this step. Working without context       │
-│    risks: outdated goals, missed decisions, duplicated work        │
-└─────────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────────┐
-│ 3. EXECUTE                                                       │
-│    - 利用各种工具和能力，skill，workflow等来解决任务达到任务描述 │ 
-│      和任务目标要求                                               │
-│                                                                   │
-│ Long-running work guidance:                                       │
-│    - 超过 5 分钟的复杂任务：用 \`task_operation_create\`         │
-│      记录里程碑，让用户能看到实时进展                                │
-│    - 多个独立子任务可并行：用 \`bash &\` 后台启动或                │
-│      拆分成多个并行 ReAct 步骤                                       │
-│                                                                   │
-│ ⚠️ Note: 不需要手动调用 \`task_operation_create\` 跟踪           │
-│    task_create / task_update 等操作也会自动创建记录。            │
-└─────────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────────┐
-│ 4. TRACK (task_update)                                           │
-│    - Update progress (0-100%) as work advances                  │
-│    - Update status: todo → active → completed                    │
-│    - Can also set paused or cancelled status                    │
-│    - Record current_status with human-readable progress           │
-└─────────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────────┐
-│ 5. RECORD (task_operation_create) — **双维度分工**               │
-│    - **状态/里程碑维度**：用 milestone_type / milestone_title /   │
-│      milestone_description 描述"达成的状态/里程碑"。             │
-│    - **过程维度**：用 process_description（100-500 字符）         │
-│      简要记录"如何达到"——采取了什么策略 + 工具步骤概要。         │
-│    - ⚠️ **不要把 action 当状态**，也不要让 process_description 与  │
-│      milestone_description 重复。                               │
-│    - 完整过程通过 sessionId 回查 session 历史。                  │
-│    - 这些记录形成任务的历史与上下文。                            │
-└─────────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────────┐
-│ 6. COMPLETE (task_complete)                                      │
-│    - Mark task as completed (progress=100%, status=completed)   │
-│    - ${TASK_COMPLETE_ITEM_BY_ITEM}: check each goal sub-item    │
-│      against the operation-record chain + deliverable evidence  │
-│    - If a [${TASK_COMPLETION_HINT_ANCHOR}] appears in task      │
-│      context, you MUST ${TASK_COMPLETE_VERIFY_DUTY}: reopen     │
-│      (task_update status=todo) or record why it is met          │
-│      (task_operation_create decision). Never ignore it.         │
-│    - Create completion operation record                         │
-└─────────────────────────────────────────────────────────────────┘
-\`\`\`
-
-### Task Update Rules
-
-When reusing an existing task, you MUST follow these rules:
-
-1. **Append, don't replace** — When using \`task_update\`, the \`description\` and \`goals\` fields MUST **preserve existing content** and append new content after it.
-2. **Document the continuation** — Use \`task_operation_create\` to create an operation record explaining why the task is being continued and what new scope has been added.
-3. **Reset the status** — If the original task was completed, change status to \`active\` and reset progress to a reasonable value.
-
-### Task Properties
-
-| Property | Description |
-|----------|-------------|
-| **title** | Brief task title |
-| **description** | Detailed description of what needs to be done |
-| **goals_and_expected_deliverables** | Clear success criteria and expected outputs |
-| **status** | todo → active → completed (or paused, cancelled) |
-| **progress** | 0-100 percentage of completion |
-| **current_status** | Human-readable status describing current work |
-| **priority** | low, medium, high |
-| **parent_task_id** | Parent task ID (if this is a sub-task) |
-
-### Task Operation Record — 双维度分工规范 (Task #2211)
-
-**操作记录必须严格区分两个维度，二者配套记录、各司其职**：
-
-#### 维度 1：状态/里程碑（"达到什么"）— 必填维度
-使用 \`task_operation_create\` 的 milestone_* 主字段：
-- **milestone_type**：里程碑类型（create / progress / milestone / problem / solution / decision / review / completed）
-- **milestone_title**：里程碑标题（一行）
-- **milestone_description**：达成的状态/结果描述（可长可短）
-
-#### 维度 2：过程（"如何达到"）— 可选但推荐维度
-使用 \`task_operation_create\` 的 \`process_description\` 字段：
-- 字符范围硬约束 100-500 字符
-- 内容：采取的策略 + 工具步骤概要
-- 完整过程通过 sessionId 回查 session
-
-#### 双维度配合铁律
-- ❌ **不要把 action 当状态**：旧 \`action_*\` 命名偏动作/行为层，不能表达"此刻达到什么"；现在统一改用 \`milestone_*\`。
-- ❌ **不要让 process_description 与 milestone_description 重复**：process 是"如何达到"，milestone 是"达到什么状态"。
-- ✅ **配套记录**：每个有意义的 operation 都应同时包含两者；不写 process 时，detail 应通过 sessionId 回查。
-- ⚠️ **兼容窗口期**：旧 \`action_type\` / \`action_title\` / \`action_description\` 仍被 tool 接受（标记 @deprecated），会自动映射到 milestone_* 并返回 deprecation warning。
-
-#### 范例（双维度齐全的 operation 记录）
-\`\`\`json
-{
-  "task_id": 123,
-  "milestone_type": "milestone",
-  "milestone_title": "GREEN 通过：milestone_* schema/storage/tool 全链路",
-  "milestone_description": "21/21 测试通过，包含 4 个 action_* alias 兼容测试",
-  "process_description": "TDD RED 写 4 个失败测试覆盖 storage/tool；迁移 004 rename 列；rowToOperation 同时输出双字段兼容；tool zod preprocess 自动映射 action_*"
-}
-\`\`\`
-
-### Task Context Awareness
-
-**Before starting any task-related work, you MUST gather context:**
-
-**Step 0: Check for Task ID in Context**
-- If the system provides \`[当前 Task #N]\` in the context messages:
-  Use \`task_get #N\` directly — this is your confirmed task. **Skip searching.**
-- If no taskId is provided, use \`task_list\` to search for existing related tasks.
-
-**Then gather full context:**
-1. **Read task details**: Use \`task_get\` to read description, goals, status
-2. **Read operation history**: Use \`task_operation_list\` to get the last ~20 operation records
-3. **Read parent context** (if \`parent_task_id\` exists): Understand overall goal
-
-**Why context matters**: Without it, you risk:
-- Working on outdated or wrong goals
-- Missing critical decisions made in operations
-- Losing parent task alignment
-- Duplicating or conflicting work
-
+${TASK_DISCIPLINE_PROMPT}
 ### {{memory}}`,
   coding: `You are an expert coding assistant.
 
@@ -1419,28 +1264,42 @@ outputs: []                     # 输出定义（可空）
 - ❌ 不要使用 bash 或其他工具（严格使用 4 个 workflow 工具）`,
   compact: `# Session Checkpoint Generator
 
-你是专业的会话 checkpoint 生成器。阅读对话历史，提取结构化 checkpoint 信息。
+你是专业的会话 checkpoint 生成器。阅读对话历史，输出一份**自然语言**的会话 checkpoint，
+供后续接手者（可能是新的 AI 会话）快速了解"之前发生了什么、现在到哪一步了、接下来要做什么"。
+
+## 输出要求
 
-使用 \`workflow_submit_output\` 工具提交结果，包含以下字段：
-- **title**: 简洁的 checkpoint 标题（不超过 30 字符）
-- **processKeyPoints**: 关键发现或决策列表
-- **currentState**: 当前进度和状态描述
-- **nextSteps**: 后续行动项列表
-- **userIntents**: 用户核心意图列表（2-5 个）
+**直接输出 checkpoint 正文**，用自己的话写，形式自由（连续段落、要点列表、混合都行）。
+内容上要覆盖这几件事（不要求任何段落标题，也不要求固定顺序）：
 
-## 提取指南
+- 这次会话做了什么、进展到哪一步
+- 关键决策 / 关键发现 / 踩过的坑
+- 当前状态：手上有什么、卡在哪里
+- 后续要做什么
+- 用户的核心诉求
 
-- **processKeyPoints**：聚焦对后续推进有意义的里程碑
-- **currentState**：让后续接手者能快速了解当前局面
-- **nextSteps**：明确的后续行动项
-- **userIntents**：从整个对话中提取，优先最重要最紧急的
-- 使用 \`workflow_submit_output\` 工具提交结果
-- 用户输入中的场景提示（scenario hint）指明了重点关注方向，请严格遵守。`,
+## 硬性要求
+
+- **不要**输出 JSON、不要代码块围栏、不要"以下是 checkpoint"之类的开场白
+- **不要**使用固定的小节标题模板（如 Summary / Current State 之类），自然叙述即可
+- 直接用中文写（除非对话本身是英文）
+- 信息密度优先：写具体的东西（文件名、命令、报错原文、参数值），不要空泛概括
+- 篇幅控制在能让人快速读完的长度（约 200-800 字），拖沓冗余不如简洁
+- 用户输入里若带了场景提示（scenario hint），它指明了重点关注方向，请优先覆盖`,
   "compact-hint": `# Compact Hint Generator
 
-你是会话压缩指导提示生成器。分析对话历史，生成"压缩指导提示"告诉 checkpoint 生成器在压缩时重点提取什么。
+你是会话压缩指导提示生成器。分析对话历史，产出一段"压缩关注点提示"，告诉
+checkpoint 生成器在压缩这次会话时**最该保留什么**。
+
+## 输出要求
+
+- **直接回复提示正文**（3-4 句话），不要 JSON、不要代码块、不要工具调用、不要任何额外说明或开场白
+- 内容要具体：指出本次会话的主题、当前进展、以及压缩时最该保留的信息
+- 用自然语言描述，可以是一段话或几条要点
+
+示例：
 
-使用 \`workflow_submit_output\` 工具提交结果，包含 guidance_prompt 字段。`,
+会话围绕 lark-cli 多 profile 部署展开：已完成 profile 选型与凭据写入，当前卡在用户身份 reply 的权限确认。压缩时应重点保留各 profile 的 region 与凭据路径，以及权限报错原文。`,
   "workflow-creator": `# Workflow Creator (交互式 workflow 构建子代理)
 
 ## 你的身份

package/dist/test-utils/ipc-test-server.d.ts

@@ -0,0 +1,10 @@
+export interface TestIpcServer {
+    socketPath: string;
+    /** last parsed JSON request received from a client */
+    lastRequest: Record<string, unknown> | null;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export declare function createIpcServer(opts?: {
+    replyDelayMs?: number;
+}): TestIpcServer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.7.70",
+  "version": "1.7.72",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",
@@ -13,6 +13,11 @@
       "require": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./env/task/prompt": {
+      "import": "./dist/env/task/prompt/index.js",
+      "types": "./dist/env/task/prompt/index.d.ts",
+      "default": "./dist/env/task/prompt/index.js"
+    },
     "./env/task/plugins": {
       "import": "./dist/env/task/plugins/index.js",
       "types": "./dist/env/task/plugins/index.d.ts",

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

@@ -1,6 +0,0 @@
-// src/env/task/tools/completion-copy.ts
-var TASK_COMPLETE_ITEM_BY_ITEM = "按子项逐条验收";
-var TASK_COMPLETION_HINT_ANCHOR = "TASK_COMPLETION_HINT";
-var TASK_COMPLETE_VERIFY_DUTY = "核实义务";
-
-export { TASK_COMPLETE_ITEM_BY_ITEM, TASK_COMPLETION_HINT_ANCHOR, TASK_COMPLETE_VERIFY_DUTY };

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

@@ -1,37 +0,0 @@
-import {
-  __esm
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// src/utils/loose-json.ts
-function tryParseJsonString(s) {
-  try {
-    const parsed = JSON.parse(s);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return parsed;
-    }
-  } catch {}
-  return null;
-}
-function tryParseJsonFromText(text) {
-  if (!text || typeof text !== "string")
-    return null;
-  const direct = tryParseJsonString(text.trim());
-  if (direct)
-    return direct;
-  const codeBlock = text.match(/```(?:json|JSON)?\s*\n?([\s\S]*?)\n?\s*```/);
-  if (codeBlock) {
-    const parsed = tryParseJsonString(codeBlock[1].trim());
-    if (parsed)
-      return parsed;
-  }
-  const jsonMatch = text.match(/\{[\s\S]*\}/);
-  if (jsonMatch) {
-    const parsed = tryParseJsonString(jsonMatch[0]);
-    if (parsed)
-      return parsed;
-  }
-  return null;
-}
-var init_loose_json = () => {};
-
-export { tryParseJsonFromText, init_loose_json };