@shgroup/dsh-serenity-hooks 1.27.0 → 1.27.2

package/lib/skiff-debug.d.ts

@@ -69,6 +69,13 @@ export declare function jscSafeJsonText(jsonText: string): string;
  * @param hideThink 为 true 时 `<think>` 内容完全不渲染（public 问答页体验）
  */
 export declare function renderSkiffMarkdown(raw: string, hideThink?: boolean): string;
+/**
+ * 剥离 `<think>…</think>` 块（v1.27.1，微信桥用户反馈："过微信桥回复给用户的消息，
+ * 要去掉 think 标签，用户不应看到"）。复用 extractThinkBlocks 状态机（v1.26.8，
+ * 弃正则）——提取后**只保留正文**（占位符替换为空，think 内容丢弃），
+ * 未闭合 think 优雅截断。适用于纯文本输出面（微信等不支持 think 折叠的通道）。
+ */
+export declare function stripThink(raw: string): string;
 /**
  * 启动调试问答服务（单实例；重复启动幂等返回既有实例）。
  *

package/lib/tools/session.d.ts

@@ -18,8 +18,6 @@ import { defineTool } from '@deepseek-ai/dsh-tools';
 import type { Context } from 'cordis';
 import { type ActiveSessionInfo, type CreateSessionResult } from '../session-ops.js';
 export interface RenameOnUseDeps {
-    /** naming.enabled 简单配置（DSH settings） */
-    namingEnabled: boolean;
     /** sessionTitle 服务可用性 */
     sessionTitleAvailable: boolean;
 }
@@ -33,8 +31,8 @@ export interface RenameOnUseDeps {
 export declare function namingTitleFor(active: ActiveSessionInfo): string;
 /**
  * use 激活宁静号会话后，把当前 dsh 会话重命名为命名标题（`S###-日期`）。
- * 门控：naming.enabled + sessionTitle 服务存在；失败不静默——返回结果对象
- * 而非 null（v1.22.9），调用方决定可见性。
+ * v1.27.1：**永远开启**（不再有 naming.enabled 门控）——仅 sessionTitle 服务
+ * 存在性守卫；失败不静默——返回结果对象而非 null（v1.22.9），调用方决定可见性。
  *
  * v1.23.2 修复（this 绑定）：第三参从**解构的裸 rename 函数**改为**整个
  * sessionTitle 服务对象**——内部以 `titles.rename(session, title)` **方法调用**

package/lib/weixin-bridge.d.ts

@@ -19,7 +19,9 @@ import { type WeixinAccountCredential } from './weixin-route.js';
  *
  * 会话语义：`weixinSessionIdFor(fromUserId)` 固定可重建——同用户长期同一会话；
  * 进程内已有（getSkiffAgent 命中）→ 延续；无（首次/进程重启）→ createSkiffAgent
- * 以固定 id 新建（角色不变，记忆从新开始——重启后自动重建，与 3100 问答页同语义）。
+ * 固定 id resume-or-create（v1.27.2）：磁盘已有持久化 log → resume（历史延续，
+ * 重启后记忆保留——真正的"同用户长期延续"）；无 log（首次）→ create。
+ * "新的对话已开始"通知仅真正首次（create）时发送；resume/进程内延续不发。
  */
 export declare function handleIncoming(ctx: Context, root: string, _accountId: string, cred: WeixinAccountCredential, msg: {
     from_user_id?: string;

package/lib/{weixin-route-CHCWBvLZ.js → weixin-route-CvAWARN3.js}

@@ -282,7 +282,8 @@ function runLocalStore(root, args) {
 * 职责（零 DSH 依赖，可独立单测）：
 * - 读取 CCC 的 weixin 配置（.opencode/serenity.json weixin 段——结构/路由/开关）
 * - 读取/写入 CCC localstore 的账号凭据（weixin.accounts.<accountId>.token/.baseUrl/.userId）
-* - 微信用户 → skiff 会话 id 映射（固定可重建：skiff-weixin-<sha256(userid)>.slice(16)）
+* - 微信用户 → skiff 会话 id 映射（固定可重建：skiff-weixin-<sha256(userid)>.slice(1, 17)；
+*   v1.27.3 错位一位避开损坏 log）
 * - 路由匹配（exact user → 通配 * 兜底）
 *
 * 配置归属（S142 用户拍板）：**CCC 级**——serenity.json 结构 + localstore 凭据分离；
@@ -293,6 +294,7 @@ var weixin_route_exports = /* @__PURE__ */ __exportAll({
 	clearWeixinCredential: () => clearWeixinCredential,
 	extractWeixinText: () => extractWeixinText,
 	matchWeixinRoute: () => matchWeixinRoute,
+	nextWeixinAccountId: () => nextWeixinAccountId,
 	readWeixinCredential: () => readWeixinCredential,
 	readWeixinSettings: () => readWeixinSettings,
 	removeWeixinAccount: () => removeWeixinAccount,
@@ -311,9 +313,12 @@ function accountKeyPart(accountId) {
 }
 /** 微信桥 skiff 会话 id 前缀（seams 旁路判定；对外面纯净——守卫识别外部面） */
 const WEIXIN_SESSION_PREFIX = "skiff-weixin-";
-/** 微信用户 → 固定会话 id（同用户长期同一会话，记忆延续；多用户天然隔离） */
+/** 微信用户 → 固定会话 id（同用户长期同一会话，记忆延续；多用户天然隔离）。
+*  **v1.27.3 错位一位（用户拍板）**：`.slice(0, 16)` → `.slice(1, 17)`——旧规则生成的
+*  固定 id 已与磁盘损坏的持久化 log 绑定（dsh 不可硬删，create 同 id 必撞）→
+*  新规则下同用户生成**全新 id**，避开损坏 log；固定可重建语义不变（同用户恒同 id）。 */
 function weixinSessionIdFor(fromUserId) {
-	const digest = createHash("sha256").update(fromUserId).digest("hex").slice(0, 16);
+	const digest = createHash("sha256").update(fromUserId).digest("hex").slice(1, 17);
 	return `${WEIXIN_SESSION_PREFIX}${digest}`;
 }
 /**
@@ -460,6 +465,17 @@ function saveWeixinRoutes(root, routes) {
 	writeWeixinSection(root, next);
 	return next;
 }
+/**
+* 生成下一个可用账号 id（`wechat-N`，N 自增取**最小未占用**）：
+* 多账号支持（S142 用户反馈 ①"要支持添加多个账号，每个都是扫码"）——
+* 移除中间账号后不冲突（wechat-2 被删 → 新账号复用 wechat-2 而非跳到 4）。
+*/
+function nextWeixinAccountId(settings) {
+	const used = new Set((settings.accounts ?? []).map((a) => a.accountId));
+	let n = 1;
+	while (used.has(`wechat-${n}`)) n++;
+	return `wechat-${n}`;
+}
 /** 切换总开关 */
 function setWeixinEnabled(root, enabled) {
 	const next = {

package/lib/weixin-route.d.ts

@@ -4,7 +4,8 @@
  * 职责（零 DSH 依赖，可独立单测）：
  * - 读取 CCC 的 weixin 配置（.opencode/serenity.json weixin 段——结构/路由/开关）
  * - 读取/写入 CCC localstore 的账号凭据（weixin.accounts.<accountId>.token/.baseUrl/.userId）
- * - 微信用户 → skiff 会话 id 映射（固定可重建：skiff-weixin-<sha256(userid)>.slice(16)）
+ * - 微信用户 → skiff 会话 id 映射（固定可重建：skiff-weixin-<sha256(userid)>.slice(1, 17)；
+ *   v1.27.3 错位一位避开损坏 log）
  * - 路由匹配（exact user → 通配 * 兜底）
  *
  * 配置归属（S142 用户拍板）：**CCC 级**——serenity.json 结构 + localstore 凭据分离；
@@ -15,7 +16,10 @@ import { type WeixinSettings, type WeixinRouteConfig, type WeixinAccountConfig }
 export declare const WEIXIN_SESSION_PREFIX = "skiff-weixin-";
 /** 判定 sessionId 是否为微信桥会话（外部面——输出守卫/轨迹隐藏生效） */
 export declare function isWeixinSessionId(sessionId: string | undefined): boolean;
-/** 微信用户 → 固定会话 id（同用户长期同一会话，记忆延续；多用户天然隔离） */
+/** 微信用户 → 固定会话 id（同用户长期同一会话，记忆延续；多用户天然隔离）。
+ *  **v1.27.3 错位一位（用户拍板）**：`.slice(0, 16)` → `.slice(1, 17)`——旧规则生成的
+ *  固定 id 已与磁盘损坏的持久化 log 绑定（dsh 不可硬删，create 同 id 必撞）→
+ *  新规则下同用户生成**全新 id**，避开损坏 log；固定可重建语义不变（同用户恒同 id）。 */
 export declare function weixinSessionIdFor(fromUserId: string): string;
 /**
  * 读取 CCC 微信桥配置（未配置/未启用 → 归一默认）。
@@ -57,5 +61,11 @@ export declare function upsertWeixinAccount(root: string, account: WeixinAccount
 export declare function removeWeixinAccount(root: string, accountId: string): WeixinSettings;
 /** 保存路由表（整体替换） */
 export declare function saveWeixinRoutes(root: string, routes: WeixinRouteConfig[]): WeixinSettings;
+/**
+ * 生成下一个可用账号 id（`wechat-N`，N 自增取**最小未占用**）：
+ * 多账号支持（S142 用户反馈 ①"要支持添加多个账号，每个都是扫码"）——
+ * 移除中间账号后不冲突（wechat-2 被删 → 新账号复用 wechat-2 而非跳到 4）。
+ */
+export declare function nextWeixinAccountId(settings: WeixinSettings): string;
 /** 切换总开关 */
 export declare function setWeixinEnabled(root: string, enabled: boolean): WeixinSettings;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shgroup/dsh-serenity-hooks",
-  "version": "1.27.0",
+  "version": "1.27.2",
   "description": "宁静号 ACC harness — Native Cordis 插件（DeepSeek Harness 运行时）。真实 DSH 工具注册（cc_fs/session/acc_msm 等 9 工具）+ 拦截缝机械约束（safe-mode/路径守卫/会话落盘）+ 系统提示词注入（ACC/CCE/Constraints/SKILL/Session 五块）。适配 DSH 公开版（deepseek-ai/deepseek-harness 0.1.0-rc）。",
   "license": "MIT",
   "repository": {

package/lib/skiff-core-BewZSbVH.js

@@ -1,424 +0,0 @@
-import { a as resolveRoleSystemPrompt, i as readSkiffRoles, n as buildSkiffBasePrompt, o as roleMsmWhitelist, r as isSkiffSessionId, u as trajectorySubset } from "./skiff-role-Dw7UKCUm.js";
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { createUserMessage } from "@deepseek-ai/dsh-llm";
-import { randomBytes, randomUUID } from "node:crypto";
-//#region src/skiff-registry.ts
-const skiffSessions = /* @__PURE__ */ new Map();
-/** 查 sessionId 的 Skiff 角色名（无 → null）——向后兼容（guards/seams 依赖） */
-function skiffRoleFor$1(sessionId) {
-	return skiffSessions.get(sessionId)?.role ?? null;
-}
-/** 查 sessionId 的完整绑定（role + ccc；无 → null）——v1.25.10 会话追问校验 */
-function skiffSessionInfo$1(sessionId) {
-	return skiffSessions.get(sessionId) ?? null;
-}
-function registerSkiffSession$1(sessionId, role, ccc) {
-	skiffSessions.set(sessionId, {
-		role,
-		ccc
-	});
-}
-function unregisterSkiffSession$1(sessionId) {
-	skiffSessions.delete(sessionId);
-}
-/** 测试/调试：注册表快照（sessionId → {role, ccc}） */
-function skiffSessionSnapshot$1() {
-	return new Map(skiffSessions);
-}
-//#endregion
-//#region src/handyman-ops.ts
-/**
-* handyman-ops.ts — handyman（杂工）纯逻辑层（零 DSH 依赖，可独立单测）
-*
-* v1.24.0：loop（牛马）→ handyman（杂工）重命名。语义对齐 osp loop：
-* 进度文件（handyman-<label>.md/.json）、续跑、轮次 prompt 结构、stop token。
-* 不兼容旧 loop- 进度文件（用户拍板：仅新 handyman- 前缀）。
-*/
-/** label 脱敏（Windows 审计问题 17）：非法字符 → '-'，去尾点/空格，限长（按码点截断，修复代理对切散 U+FFFD） */
-function sanitizeLabel(label) {
-	return [...label.replace(/[<>:"/\\|?*\u0000-\u001f]/g, "-").replace(/[ .]+$/g, "")].slice(0, 50).join("");
-}
-function handymanProgressPaths(root, label) {
-	const dir = join(root, "AGENT_SESSIONS");
-	const safe = sanitizeLabel(label);
-	return {
-		md: join(dir, `handyman-${safe}.md`),
-		json: join(dir, `handyman-${safe}.json`)
-	};
-}
-/** 读取进度（续跑）；无文件返回 round 0 */
-function readProgress(root, label) {
-	const { json } = handymanProgressPaths(root, label);
-	if (!existsSync(json)) return null;
-	try {
-		return JSON.parse(readFileSync(json, "utf-8"));
-	} catch {
-		return null;
-	}
-}
-function writeProgress(root, label, p) {
-	const { md, json } = handymanProgressPaths(root, label);
-	mkdirSync(join(root, "AGENT_SESSIONS"), { recursive: true });
-	writeFileSync(json, JSON.stringify({
-		...p,
-		status: p.status ?? "running",
-		updated: (/* @__PURE__ */ new Date()).toISOString()
-	}, null, 2) + "\n", "utf-8");
-	const lines = [
-		`# handyman: ${label}`,
-		`- Model: ${p.model}`,
-		`- Round: ${p.round}`,
-		`- Done: ${p.done}`,
-		"",
-		`## Latest response`,
-		"",
-		p.lastResponse,
-		""
-	];
-	writeFileSync(md, lines.join("\n"), "utf-8");
-}
-/** 失败状态落盘（对齐 osp writeFailedStatus：done=true / status=failed / errorCode） */
-function writeFailedStatus(root, label, info) {
-	const { json } = handymanProgressPaths(root, label);
-	mkdirSync(join(root, "AGENT_SESSIONS"), { recursive: true });
-	const prev = readProgress(root, label);
-	writeFileSync(json, JSON.stringify({
-		round: prev?.round ?? 0,
-		done: true,
-		label,
-		model: prev?.model ?? "",
-		status: "failed",
-		errorCode: info.errorCode,
-		errorMessage: info.errorMessage,
-		updated: (/* @__PURE__ */ new Date()).toISOString(),
-		lastResponse: prev?.lastResponse ?? ""
-	}, null, 2) + "\n", "utf-8");
-}
-function newStopToken() {
-	return `SERENITY_HANDYMAN_DONE_${randomBytes(8).toString("hex")}`;
-}
-/** 解析 model 字符串（provider/model）→ {provider, model}；无 / 视为 model-only */
-function splitModel(model) {
-	const idx = model.indexOf("/");
-	if (idx < 0) return {
-		provider: void 0,
-		model
-	};
-	return {
-		provider: model.slice(0, idx),
-		model: model.slice(idx + 1)
-	};
-}
-/** 校验模型在白名单内；不在 → 抛错（用户拍板：只能使用 CCC 配置的模型） */
-function requireWhitelistedModel(model, models) {
-	if (!models.includes(model)) throw new Error(`handyman: model "${model}" is not in the CCC whitelist. Configure .opencode/serenity.json "handyman.models" with one of: ${models.join(", ")}`);
-}
-/** 轮次 prompt（对齐老 loop 结构：回顾进度 → 自由工作 → 汇报；S134 EAP 化：固定详尽） */
-function buildRoundPrompt(opts) {
-	const { root, session, label, round, stopToken, progress, task } = opts;
-	const resumeNote = progress && progress.round > 0 ? `Previous round (round ${progress.round}) completed: ${progress.lastResponse.slice(0, 300)}\nAlways continue from where you left off; never redo completed work.` : "This is the first round.";
-	return `# ${label} — handyman round ${round}
-
-CCC root: ${root}
-${session ? `Work session: ${session} (progress recorded in AGENT_SESSIONS/${session}/SESSION.md)` : ""}
-${task ? `Task: ${task}` : `Task: follow the work corresponding to label "${label}" (if a work session exists, read SESSION.md first to clarify the goal)`}
-${resumeNote}
-
-## Work rules (fixed every round, must follow)
-1. Work freely within this round: read files, modify code, execute commands — use every means to advance the task.
-2. If this task is **reading/curating or text-writing work** (extracting from files, summarizing, writing docs, generating text, etc.),
-   first load eap (acc-eap skill) and organize output per the EAP standard:
-   - E↑ Explicit: entities/variables clearly defined, relationships with direction and cardinality, boundaries drawn, no ambiguous words
-   - R↓ Reconstructable: key conclusions record sources and reasoning, rebuildable by later agents
-   - S↑ Stable: output structure regenerates repeatably, no reliance on implicit context
-3. Reports must be concrete and verifiable — no filler.
-
-## Per-round report (fixed format, answer each item)
-1. What was done this round (concrete)
-2. Next-step plan
-3. Whether the task is complete (if complete, output only ${stopToken})
-
-If the task is complete, output only ${stopToken}.`;
-}
-/**
-* handyman 规模化使用指引（guide 子命令输出；S134 继承 + v1.24.0 更新）：
-* 使用 handyman 前必须先加载 eap 设计方案；并行策略（jobs 编排）；提示词规范（详尽固定 EAP）；
-* 阅读/文字编写类 handyman 内部也加载 eap。
-*/
-const HANDYMAN_GUIDE = `# handyman — Scale-Up Usage Guide (guide)
-
-## ⚠️ Before using: load eap and design the plan
-Before calling handyman, load eap (acc-eap skill) and design the "scale-up handyman plan" based on the EAP framework.
-
-### 1. Task decomposition (E↑ Explicit)
-- Split large tasks into explicit subtasks: each subtask defines goal / input / boundaries (what to do, what not to do) / acceptance criteria
-- Make dependencies explicit: dependent tasks run serially, independent ones can run in parallel
-
-### 2. Prompt design (handyman's task parameter)
-- task must be detailed, fixed, and EAP-compliant: clear goal, drawn boundaries, decidable acceptance criteria
-- Anti-example "handle this file" — ambiguous; good example "read <path>, extract all rows of the「关键决策」table,
-  output a JSON array (fields id/conclusion/evidence), do not modify the original file"
-- Reading/curating or text-writing work (extracting from files, summarizing, writing docs, generating text, etc.):
-  the handyman-internal agent is also required to load eap and organize output per the EAP standard
-
-### 3. Model whitelist (CCC-configured, mandatory)
-- handyman only uses models listed in .opencode/serenity.json "handyman.models" — never arbitrary models
-- Recursive subagents inside a handyman inherit the handyman's model automatically (DSH native)
-- Keep the subagent tool instance free of a fixed agentOptions, or model inheritance breaks
-
-### 4. Parallel strategy (jobs orchestration, workflow capability)
-- Independent subtasks can run in parallel via handyman(jobs=[...]): each job gets its own label + task + stop token + progress file
-- Concurrency safety guaranteed: unique sessionId (handyman-<label>-<uuid>), progress files isolated per label
-  (AGENT_SESSIONS/handyman-<label>.json) — same label resumes, different labels never interfere
-- Parallel cap: handyman.maxParallel (default 10 — cheap models are cheap)
-- Aggregation: after each parallel job produces progress, the main agent merges (or spawns one aggregation handyman)
-- For programmable pipeline/phase orchestration at scale, use the platform's workflow tool instead
-
-## Completion criteria (osp loop standard)
-- The only completion condition = the handyman-internal agent echoes this round's random verification code (stop token); dialogue round cap (default 100, osp fail-safe, forced stop beyond the cap, resumable)
-- Automatic restart on abnormal agent stop (≤100 restarts, anti-infinite-loop)
-
-## Waiting UI
-- The WebUI session-header Serenity detail card shows running handymen's progress (label / round / last response), one line per parallel job, ~3s refresh
-`;
-/** 列出 AGENT_SESSIONS/handyman-*.json 的全部进度（按 updated 倒序；坏文件跳过） */
-function listActiveHandymen(root) {
-	const dir = join(root, "AGENT_SESSIONS");
-	if (!existsSync(dir)) return [];
-	const out = [];
-	for (const entry of readdirSync(dir)) {
-		if (!entry.startsWith("handyman-") || !entry.endsWith(".json")) continue;
-		try {
-			const data = JSON.parse(readFileSync(join(dir, entry), "utf-8"));
-			if (typeof data.label !== "string" || typeof data.round !== "number") continue;
-			out.push({
-				label: data.label,
-				round: data.round,
-				done: data.done === true,
-				model: typeof data.model === "string" ? data.model : "",
-				updated: typeof data.updated === "string" ? data.updated : "",
-				lastResponse: typeof data.lastResponse === "string" ? data.lastResponse : ""
-			});
-		} catch {}
-	}
-	out.sort((a, b) => a.updated < b.updated ? 1 : -1);
-	return out;
-}
-//#endregion
-//#region src/skiff-core.ts
-const PLUGIN_SOURCE = {
-	kind: "plugin",
-	plugin: "dsh-serenity-hooks"
-};
-const skiffAgents = /* @__PURE__ */ new Map();
-/** 查 sessionId 的 Skiff 角色名（无 → null） */
-function skiffRoleFor(sessionId) {
-	return skiffRoleFor$1(sessionId);
-}
-/** 查 sessionId 的会话绑定（role + ccc；无 → null）——v1.25.10 追问校验 */
-function skiffSessionInfo(sessionId) {
-	return skiffSessionInfo$1(sessionId);
-}
-/** 查 sessionId 的活体 agent（进程内会话延续用；未注册/已清理 → undefined） */
-function getSkiffAgent(sessionId) {
-	return skiffAgents.get(sessionId);
-}
-function registerSkiffSession(sessionId, role, ccc, agent) {
-	skiffAgents.set(sessionId, agent);
-	registerSkiffSession$1(sessionId, role, ccc);
-}
-function unregisterSkiffSession(sessionId) {
-	skiffAgents.delete(sessionId);
-	unregisterSkiffSession$1(sessionId);
-}
-/** 测试/调试：注册表快照（sessionId → {role} 兼容展示） */
-function skiffSessionSnapshot() {
-	const out = /* @__PURE__ */ new Map();
-	for (const [id, b] of skiffSessionSnapshot$1()) out.set(id, {
-		role: b.role,
-		ccc: b.ccc
-	});
-	return out;
-}
-/** Skiff agent 挂载的 DSH preset（v1.25.3 修复：read/grep/glob 等平台工具由 preset 决定工具面；
-*  handyman 经 composeFrom 继承父、skiff 无父上下文——直接挂 DSH 默认 standard preset；
-*  guard 角色白名单再按角色过滤可见/可用面——白名单外工具仍 deny） */
-const SKIFF_PRESET = "standard";
-/**
-* 创建 Skiff agent：标准 DSH agent + cwd=CCC root + 角色模型 +
-* standard preset（平台工具面）+ scoped 系统提示词（基础提示词 + CCC 定义段，全替换 ACC 默认注入）。
-* @param sessionId 指定会话 id（可选；微信桥等外部面用固定 id 实现用户↔会话长期映射——
-*   不传则随机生成 skiff-<role>-<uuid>，ACP/调试页默认路径）
-*/
-async function createSkiffAgent(ctx, root, roleName, role, defaultModel, sessionId) {
-	if (!ctx.agents) throw new Error("skiff: ctx.agents unavailable");
-	const model = role.model?.trim() || defaultModel || "";
-	const id = sessionId ?? `skiff-${roleName}-${randomUUID()}`;
-	const handle = await ctx.agents.create({
-		sessionId: id,
-		meta: {
-			cwd: root,
-			agentPreset: SKIFF_PRESET
-		},
-		setup: async (agentCtx) => {
-			try {
-				await agentCtx.get("agentPresets")?.mount?.(agentCtx, SKIFF_PRESET);
-			} catch {}
-		},
-		...model ? { agentOptions: splitModel(model) } : {}
-	});
-	const agent = handle.agent;
-	let cccPrompt = "";
-	try {
-		cccPrompt = resolveRoleSystemPrompt(root, role);
-	} catch (err) {
-		console.warn(`[serenity-hooks] skiff 角色 "${roleName}" 系统提示词解析失败（回退仅基础段）: ${String(err?.message ?? err)}`);
-	}
-	try {
-		agent.ctx.systemPrompt.section({
-			name: "serenity-skiff",
-			order: -60,
-			text: () => [buildSkiffBasePrompt(roleName, role), cccPrompt].filter(Boolean).join("\n")
-		});
-	} catch (err) {
-		console.warn(`[serenity-hooks] skiff 系统提示词注册失败: ${String(err?.message ?? err)}`);
-	}
-	registerSkiffSession(id, roleName, root, agent);
-	return {
-		handle,
-		agent,
-		sessionId: id
-	};
-}
-/** 等待 agent 空闲（agent/status → idle）；无超时（agent 工作多久等多久，handyman 同款） */
-function waitIdle(ctx, agent) {
-	return new Promise((resolve) => {
-		let settled = false;
-		let dispose = () => {};
-		const finish = () => {
-			if (settled) return;
-			settled = true;
-			dispose();
-			resolve();
-		};
-		dispose = ctx.on("agent/status", (payload) => {
-			if (payload.agent === agent && payload.status === "idle") finish();
-		});
-	});
-}
-/** 读会话最后一个 assistant/message 文本（handyman 同款） */
-function lastAssistantText(agent) {
-	const events = agent.session.events;
-	for (let i = events.length - 1; i >= 0; i--) {
-		const e = events[i];
-		if (e && e.type === "assistant/message") {
-			const text = (e.data?.message?.content ?? e.data?.content ?? []).filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
-			if (text) return text;
-		}
-	}
-	return "";
-}
-/** events → 可读轨迹（user/assistant 文本 + 工具调用 + 工具结果；单条解析失败跳过） */
-function eventsToTrajectory(events) {
-	const out = [];
-	for (const raw of events) try {
-		const ev = raw;
-		if (ev.type === "user/message") {
-			const text = extractText(ev.data);
-			if (text) out.push({
-				role: "user",
-				text
-			});
-		} else if (ev.type === "assistant/message") {
-			const d = ev.data;
-			const text = (d?.message?.content ?? d?.content ?? []).filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
-			const calls = d?.message?.tool_calls ?? [];
-			if (text) out.push({
-				role: "assistant",
-				text
-			});
-			for (const c of calls ?? []) {
-				const args = typeof c.arguments === "string" ? c.arguments : JSON.stringify(c.arguments ?? {});
-				out.push({
-					role: "assistant",
-					text: `→ ${c.name ?? "(tool)"} ${truncate(args, 300)}`,
-					tool: c.name
-				});
-			}
-		} else if (ev.type === "tool/result") {
-			const outText = extractText(ev.data);
-			if (outText) out.push({
-				role: "tool",
-				text: truncate(outText, 500),
-				tool: String(ev.data?.name ?? "")
-			});
-		}
-	} catch {}
-	return out;
-}
-function extractText(data) {
-	const content = data?.content;
-	if (!Array.isArray(content)) return "";
-	return content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
-}
-function truncate(s, n) {
-	return s.length > n ? `${s.slice(0, n)}…` : s;
-}
-/**
-* 提问一轮：followup → 等 idle → 读答案 + 轨迹。
-* @param eventsStart 轨迹起点：显式传 0 = 全量轨迹（会话追问时页面重绘完整时间线，
-*   v1.25.10 用户拍板）；不传（undefined）= 本轮增量（followup 前 events 之后）
-* @param options.includeTrajectory 是否计算轨迹（v1.26.10：**3100 对外只提供问答**——
-*   公开问答页 / ACP JSON-RPC 不返回 trajectory，传 false 跳过计算；3099 调试页默认 true 保留）
-*/
-async function askSkiff(ctx, agent, question, eventsStart, options) {
-	const before = eventsStart === void 0 ? agent.session.events.length : eventsStart;
-	agent.followup(createUserMessage({
-		content: [{
-			type: "text",
-			text: question
-		}],
-		source: PLUGIN_SOURCE
-	}));
-	await waitIdle(ctx, agent);
-	const answer = lastAssistantText(agent);
-	const trajectory = options?.includeTrajectory === false ? [] : eventsToTrajectory(agent.session.events.slice(before));
-	return {
-		answer,
-		sessionId: String(agent.session.id ?? ""),
-		trajectory
-	};
-}
-/**
-* Skiff 会话的轨迹纪律参与判定：非 skiff 会话恒 true（正常参与）；
-* skiff 会话按角色 trajectory 子集（session/keeper/rebuild）决定；
-* 注册表缺失（进程重启遗留等）→ 保守旁路（false，完全独立）。
-*/
-function skiffTrajectoryEnabled(root, sessionId, key) {
-	if (!isSkiffSessionId(sessionId)) return true;
-	const roleName = sessionId ? skiffRoleFor(sessionId) : null;
-	if (!roleName) return false;
-	const role = readSkiffRoles(root).get(roleName);
-	return trajectorySubset(role)[key];
-}
-/**
-* acc_msm 的 Skiff 门控：非 skiff 会话恒放行；skiff 会话——
-* exec 非白名单 MSM 拒绝（不列名单）、register/deregister 必拒、
-* list 白名单过滤、check/guide/ccc-config 只读放行。
-*/
-function skiffMsmGate(root, sessionId, action, name) {
-	if (!isSkiffSessionId(sessionId)) return {};
-	const roleName = sessionId ? skiffRoleFor(sessionId) : null;
-	const role = roleName ? readSkiffRoles(root).get(roleName) : void 0;
-	if (!roleName || !role) return { reject: "MSM not allowed in this skiff session" };
-	if (action === "register" || action === "deregister") return { reject: "register/deregister is not allowed in skiff sessions" };
-	if (action === "exec") {
-		if (!name || !(role.msms ?? []).includes(name)) return { reject: "MSM not allowed" };
-		return {};
-	}
-	if (action === "list") return { whitelist: roleMsmWhitelist(role) };
-	return {};
-}
-//#endregion
-export { writeFailedStatus as _, skiffSessionInfo as a, unregisterSkiffSession as c, handymanProgressPaths as d, listActiveHandymen as f, splitModel as g, requireWhitelistedModel as h, skiffMsmGate as i, HANDYMAN_GUIDE as l, readProgress as m, createSkiffAgent as n, skiffSessionSnapshot as o, newStopToken as p, getSkiffAgent as r, skiffTrajectoryEnabled as s, askSkiff as t, buildRoundPrompt as u, writeProgress as v, skiffRoleFor$1 as y };