dsh-workplan 3.0.3 → 3.0.9
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +76 -0
- package/README.en.md +15 -7
- package/README.md +32 -20
- package/README.zh.md +8 -7
- package/client.js +181 -27
- package/docs/release-notes-3.0.3.md +7 -0
- package/docs/release-notes-3.0.9.md +7 -0
- package/lib/approval-gate.js +79 -3
- package/lib/client.js +181 -27
- package/lib/comm-format.js +6 -6
- package/lib/dept-journal.js +223 -6
- package/lib/{three-phase.js → five-step.js} +210 -134
- package/lib/host.js +316 -79
- package/lib/lessons.js +87 -19
- package/lib/llm-rules.js +25 -82
- package/lib/notice-ledger.js +238 -0
- package/lib/plan.js +275 -68
- package/lib/runtime.js +747 -161
- package/lib/understanding.js +85 -6
- package/lib/v3-contract.js +48 -15
- package/package.json +2 -3
- package/src/approval-gate.ts +77 -3
- package/src/client.ts +178 -24
- package/src/comm-format.ts +6 -6
- package/src/dept-journal.ts +219 -7
- package/src/{three-phase.ts → five-step.ts} +236 -169
- package/src/host.ts +316 -79
- package/src/lessons.ts +92 -19
- package/src/llm-rules.ts +30 -101
- package/src/notice-ledger.ts +251 -0
- package/src/plan.ts +276 -66
- package/src/runtime.ts +800 -159
- package/src/understanding.ts +100 -6
- package/src/v3-contract.ts +49 -16
package/lib/lessons.js
CHANGED
|
@@ -7,8 +7,8 @@
|
|
|
7
7
|
* 记忆并预防再犯。
|
|
8
8
|
*
|
|
9
9
|
* 实现分三块,缺一块就只是口号:
|
|
10
|
-
* 1.
|
|
11
|
-
* 必填项;缺少问题/弯路/解决/预防就无法记成 done(见
|
|
10
|
+
* 1. 证据契约:第四步(验证阶段)的 `phases.verification.retrospective` 是
|
|
11
|
+
* 必填项;缺少问题/弯路/解决/预防就无法记成 done(见 five-step.ts)。
|
|
12
12
|
* 2. 永久记忆:复盘通过后立刻落盘到 JSONL(默认 `~/.dsh/workplan/lessons.jsonl`,
|
|
13
13
|
* 可用 `DSH_WORKPLAN_LESSONS_FILE` 覆盖),追加写、跨会话跨项目长期保留。
|
|
14
14
|
* 3. 防再犯:每次派发子任务前,按部门/关键词/时间/重复次数排序,把最相关的
|
|
@@ -18,7 +18,7 @@
|
|
|
18
18
|
* 本模块不依赖 harness 服务,只做纯函数 + 同步文件读写,便于离线回放与测试。
|
|
19
19
|
*/
|
|
20
20
|
import { createHash } from 'node:crypto';
|
|
21
|
-
import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
|
|
21
|
+
import { appendFileSync, chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
|
|
22
22
|
import { homedir } from 'node:os';
|
|
23
23
|
import { dirname, join } from 'node:path';
|
|
24
24
|
export const LESSON_VERSION = 1;
|
|
@@ -56,7 +56,7 @@ function totalChars(items) {
|
|
|
56
56
|
return items.reduce((sum, item) => sum + item.length, 0);
|
|
57
57
|
}
|
|
58
58
|
/**
|
|
59
|
-
* 复盘证据的**唯一**校验入口:
|
|
59
|
+
* 复盘证据的**唯一**校验入口:five-step.ts 与运行时都调它,保证
|
|
60
60
|
* 「提示词要求什么」和「完成判定检查什么」是同一份契约。
|
|
61
61
|
*/
|
|
62
62
|
export function validateRetrospective(value) {
|
|
@@ -66,7 +66,7 @@ export function validateRetrospective(value) {
|
|
|
66
66
|
return {
|
|
67
67
|
ok: false,
|
|
68
68
|
retrospective: empty,
|
|
69
|
-
errors: ['phases.verification.retrospective
|
|
69
|
+
errors: ['phases.verification.retrospective 缺失:第四步收尾必须复盘「问题 / 弯路 / 解决 / 预防」四项'],
|
|
70
70
|
};
|
|
71
71
|
}
|
|
72
72
|
const problems = readList(value.problems);
|
|
@@ -141,17 +141,18 @@ export function resolveLessonsFile(env = process.env) {
|
|
|
141
141
|
return override;
|
|
142
142
|
return join(homedir(), '.dsh', 'workplan', 'lessons.jsonl');
|
|
143
143
|
}
|
|
144
|
-
function
|
|
144
|
+
function readJsonLinesSnapshot(file) {
|
|
145
145
|
if (!existsSync(file))
|
|
146
|
-
return [];
|
|
146
|
+
return { rows: [], corrupt: [], readError: null };
|
|
147
147
|
let text = '';
|
|
148
148
|
try {
|
|
149
149
|
text = readFileSync(file, 'utf8');
|
|
150
150
|
}
|
|
151
|
-
catch {
|
|
152
|
-
return [];
|
|
151
|
+
catch (readError) {
|
|
152
|
+
return { rows: [], corrupt: [], readError };
|
|
153
153
|
}
|
|
154
154
|
const rows = [];
|
|
155
|
+
const corrupt = [];
|
|
155
156
|
for (const line of text.split('\n')) {
|
|
156
157
|
const trimmed = line.trim();
|
|
157
158
|
if (!trimmed)
|
|
@@ -160,12 +161,18 @@ function readJsonLines(file) {
|
|
|
160
161
|
const parsed = JSON.parse(trimmed);
|
|
161
162
|
if (isRecord(parsed))
|
|
162
163
|
rows.push(parsed);
|
|
164
|
+
else
|
|
165
|
+
corrupt.push(trimmed);
|
|
163
166
|
}
|
|
164
167
|
catch {
|
|
165
|
-
//
|
|
168
|
+
// 单行损坏不能拖垮整份记忆:读端跳过该行,写端原样保留。
|
|
169
|
+
corrupt.push(trimmed);
|
|
166
170
|
}
|
|
167
171
|
}
|
|
168
|
-
return rows;
|
|
172
|
+
return { rows, corrupt, readError: null };
|
|
173
|
+
}
|
|
174
|
+
function readJsonLines(file) {
|
|
175
|
+
return readJsonLinesSnapshot(file).rows;
|
|
169
176
|
}
|
|
170
177
|
function coerceRecord(raw) {
|
|
171
178
|
if (!isRecord(raw))
|
|
@@ -196,12 +203,54 @@ export function readLessons(file = resolveLessonsFile()) {
|
|
|
196
203
|
.map(coerceRecord)
|
|
197
204
|
.filter((item) => item !== null);
|
|
198
205
|
}
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
206
|
+
/**
|
|
207
|
+
* [3.0.3] 防符号链接投毒:写入前确认目标不是符号链接,否则抛错拒绝
|
|
208
|
+
* (风格同 LESSONS_READ_FAILED)。攻击者把教训文件或临时文件路径换成
|
|
209
|
+
* 符号链接后,一次「原子重写」就会被重定向去覆盖无关文件。
|
|
210
|
+
*/
|
|
211
|
+
function assertLessonsWriteTarget(file, what) {
|
|
212
|
+
let stat;
|
|
213
|
+
try {
|
|
214
|
+
stat = lstatSync(file);
|
|
215
|
+
}
|
|
216
|
+
catch {
|
|
217
|
+
return; // 不存在:正常新写。
|
|
218
|
+
}
|
|
219
|
+
if (stat.isSymbolicLink()) {
|
|
220
|
+
throw new Error(`LESSONS_WRITE_REFUSED: 拒绝向符号链接${what}写入 ${file},以免被重定向覆盖无关文件`);
|
|
221
|
+
}
|
|
222
|
+
}
|
|
223
|
+
function writeLessonsAtomic(file, records, corrupt = []) {
|
|
224
|
+
assertLessonsWriteTarget(file, '');
|
|
225
|
+
assertLessonsWriteTarget(`${file}.bak`, '备份');
|
|
226
|
+
mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
|
|
227
|
+
const lines = [
|
|
228
|
+
...records.map((item) => JSON.stringify(item)),
|
|
229
|
+
// 坏行原样留在文件末尾:下次读端仍会跳过,但绝不会因为一次重写就消失。
|
|
230
|
+
...corrupt,
|
|
231
|
+
];
|
|
232
|
+
const body = lines.length > 0 ? `${lines.join('\n')}\n` : '';
|
|
233
|
+
// 覆盖前留一代备份;备份失败不阻断主写入(主写入仍走临时文件 + 原子改名)。
|
|
234
|
+
if (existsSync(file)) {
|
|
235
|
+
try {
|
|
236
|
+
copyFileSync(file, `${file}.bak`);
|
|
237
|
+
}
|
|
238
|
+
catch {
|
|
239
|
+
// 备份是尽力而为:权限不足等情况下,主写入的失败会由调用方显式上报。
|
|
240
|
+
}
|
|
241
|
+
}
|
|
202
242
|
const tmp = `${file}.tmp-${process.pid}`;
|
|
203
|
-
|
|
243
|
+
assertLessonsWriteTarget(tmp, '临时文件');
|
|
244
|
+
writeFileSync(tmp, body, { encoding: 'utf8', mode: 0o600 });
|
|
204
245
|
renameSync(tmp, file);
|
|
246
|
+
// 已存在文件收紧到 0o600(rename 覆盖了同名符号链接之外的目标时,
|
|
247
|
+
// 权限可能带着旧文件的宽松位):best-effort,文件系统不支持时不断写。
|
|
248
|
+
try {
|
|
249
|
+
chmodSync(file, 0o600);
|
|
250
|
+
}
|
|
251
|
+
catch {
|
|
252
|
+
// best-effort。
|
|
253
|
+
}
|
|
205
254
|
}
|
|
206
255
|
/**
|
|
207
256
|
* 把一次复盘写入永久记忆。
|
|
@@ -221,7 +270,22 @@ export function recordLesson(input) {
|
|
|
221
270
|
problems: retro.problems,
|
|
222
271
|
prevention: retro.prevention,
|
|
223
272
|
});
|
|
224
|
-
const
|
|
273
|
+
const snapshot = readJsonLinesSnapshot(file);
|
|
274
|
+
/*
|
|
275
|
+
* 数据安全红线:读失败 ≠ 没有历史。
|
|
276
|
+
* 以前这里把 EACCES/EMFILE/EIO 当成空数组,随后「读-改-写」会把整份永久记忆
|
|
277
|
+
* 覆盖成刚写入的这一条。现在读失败直接抛错,由 runtime 的 catch 记录到状态里;
|
|
278
|
+
* 坏行则原样带回写端,重写时不会丢。
|
|
279
|
+
*/
|
|
280
|
+
if (snapshot.readError) {
|
|
281
|
+
const message = snapshot.readError instanceof Error
|
|
282
|
+
? snapshot.readError.message
|
|
283
|
+
: String(snapshot.readError);
|
|
284
|
+
throw new Error(`LESSONS_READ_FAILED: 无法读取 ${file},已拒绝写入以免覆盖历史教训(${message})`);
|
|
285
|
+
}
|
|
286
|
+
const records = snapshot.rows
|
|
287
|
+
.map(coerceRecord)
|
|
288
|
+
.filter((item) => item !== null);
|
|
225
289
|
const sameRow = records.findIndex((item) => item.planId === input.planId && item.subtaskId === input.subtaskId);
|
|
226
290
|
const sameIssue = records.findIndex((item) => item.fingerprint === fingerprint && item.department === input.department);
|
|
227
291
|
const base = {
|
|
@@ -262,11 +326,15 @@ export function recordLesson(input) {
|
|
|
262
326
|
// 时间正序保留最近 N 条;id 冲突(同一毫秒重复)时无需特殊处理,读端按行。
|
|
263
327
|
const kept = records.slice(Math.max(0, records.length - MAX_LESSON_RECORDS));
|
|
264
328
|
try {
|
|
265
|
-
writeLessonsAtomic(file, kept);
|
|
329
|
+
writeLessonsAtomic(file, kept, snapshot.corrupt);
|
|
266
330
|
}
|
|
267
|
-
catch {
|
|
331
|
+
catch (error) {
|
|
332
|
+
// 符号链接投毒是拒绝不是故障:不上 append 兜底,直接向上抛。
|
|
333
|
+
if (error instanceof Error && error.message.startsWith('LESSONS_WRITE_REFUSED'))
|
|
334
|
+
throw error;
|
|
268
335
|
try {
|
|
269
|
-
mkdirSync(dirname(file), { recursive: true });
|
|
336
|
+
mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
|
|
337
|
+
assertLessonsWriteTarget(file, '');
|
|
270
338
|
appendFileSync(file, `${JSON.stringify(base)}\n`, 'utf8');
|
|
271
339
|
}
|
|
272
340
|
catch {
|
package/lib/llm-rules.js
CHANGED
|
@@ -15,9 +15,8 @@
|
|
|
15
15
|
* 两道闸各自留痕(U7 裁决:静态表权威 + 能力面交集钳制留痕)。
|
|
16
16
|
*/
|
|
17
17
|
import { allowedEffortsForModel, classifyModelFamily, DEFAULT_REASONING_EFFORT, defuseSessionReferenceText, EFFORT_STRENGTH_ORDER, effortForComplexity, EVIDENCE_MARKER_BEGIN, EVIDENCE_MARKER_END, effortsForModelFamily, highestEffortOf, OTHER_MODEL_EFFORTS, QWEN_MODEL_EFFORTS, REASONING_EFFORTS, truncate, } from './plan.js';
|
|
18
|
-
// [
|
|
19
|
-
|
|
20
|
-
import { MIN_PLANNING_APPROACH_CHARS, MIN_PLANNING_BASIS_CHARS, MIN_PLANNING_PROBLEM_CHARS, threePhasePromptLines, } from './three-phase.js';
|
|
18
|
+
// [3.0.8] 注入 five-step 的五步提示词段落(buildDelegateePrompt 使用)。
|
|
19
|
+
import { fiveStepPromptLines, START_EVIDENCE_MIN_CHARS_BRIEF } from './five-step.js';
|
|
21
20
|
// [3.0.0] 用户 2026-11-14 第 5、6、7、9 条要求的纯逻辑契约(零依赖模块):
|
|
22
21
|
// 极简任务硬门槛 + 质量要求硬门槛 + 专家精简 JSON 汇报契约。
|
|
23
22
|
import { checkAtomicAssignment, normalizeQualityRequirements, renderExpertReportSpec, renderQualityRequirementsBlock, } from './v3-contract.js';
|
|
@@ -101,21 +100,22 @@ export function buildLlmRulesBrief(info = {}) {
|
|
|
101
100
|
lines.push(`- 部门负责人已为本任务配置整体推理等级 \`${info.taskEffort}\`(effortOverride,负责人自配档):本任务每次派发/重试/续跑全程沿用该等级,不得中途丢弃或覆盖;下级自己的等级以 self_effort 自配为权威(分工表档仅建议)。`);
|
|
102
101
|
}
|
|
103
102
|
if (info.tier === 'delegate') {
|
|
104
|
-
lines.push(`- 你是部门第三层执行者(本部门相关领域全球顶尖专家${info.memberName ? `:${info.memberName}` : ''}
|
|
103
|
+
lines.push(`- 你是部门第三层执行者(本部门相关领域全球顶尖专家${info.memberName ? `:${info.memberName}` : ''})。执行自己的任务必须遵守五步工作法的前三步(3.0.8 单一框架):第一步全面、全盘、深入梳理、研究、思考自己的任务;第二步基于第一步完成好的所有结果,研究需要哪些资源、哪些工具、具体实施方案(方法、流程、步骤,含依据);第三步把资源与工具真正备齐并给出就绪证据;然后进入第四步具体执行,全程少走弯路(先查历史教训、先验证再动手、不重复试错)。前三步证据经 phase-0(low 档启动)由 dsh_workplan_delegate(action="self_effort") 一并提交 startPhases={ planning{ problemAnalysis[], approach[], approachBasis[], resources[], tools[] }, preparation{ prepared[], evidence[] } },未登记合格证据平台不会接续你进入正式执行。分工表给你的档位仅为建议:你必须在 phase-0 经 self_effort 按自己任务复杂度提交自配档(reasoningEffort+complexityRationale),平台登记后立即以自配档接续你执行正式任务;越界档会被钳制并留痕。开工前必须先预估本人任务耗时(整数分钟)并经 self_effort 的 timeNotice 上报部门负责人,未上报不接续(T6/D9 硬门禁)。必须确保自身任务完成品质非常高的前提下,完美、超高效率地执行。`);
|
|
105
104
|
}
|
|
106
105
|
else {
|
|
107
106
|
// [2.5.4][T4] 人数口径同步(D1/D2):非复杂≤6;复杂(medium/high/xhigh/max)≥8 且 ≤12,少于 8 硬性阻断。
|
|
108
|
-
lines.push('- 部门负责人(本任务书的直接接收者)强制流程(用户要求 1/2/3,
|
|
107
|
+
lines.push('- 部门负责人(本任务书的直接接收者)强制流程(用户要求 1/2/3,3.0.8 五步工作法单框架):你拥有本部门内的再分配权限——执行自己的任务必须先完成五步前三步(第一步任务梳理;第二步基于第一步全部结果研究资源、工具与具体实施方案;第三步把资源与工具真正备齐并给出就绪证据),正式执行与再分配全程少走弯路(先查历史教训、先验证再动手、不重复试错),经 dsh_workplan_delegate(action="review") 一并提交分工表(assignments + taskReasoningEffort)与第 1/2/3 步证据(startPhases={ planning{ problemAnalysis[], approach[], approachBasis[], resources[], tools[] }, preparation{ prepared[], evidence[] } }),并在 consolidation.taskReasoningEffort 里按你接到任务的复杂度配置你自己的整体推理等级(先配置后开工:phase-0 以 low 启动,登记后平台立即以自配档接续本会话进入 phase-1,重试/续跑全程生效);第 1/2/3 步证据与分工表未提交前,dsh_workplan_delegate(action="dispatch") 会被平台拒绝(硬门禁)。梳理完成后必须把任务拆得更简单——每位下级只承担单一目标、单一主产物、可独立验收的一项工作——再合理分配给本部门多名相关领域全球顶尖专家(部门组员角色已按用户要求 9 取消,分工表只允许 role="expert",至少 1 名;low/未配置任务禁止下派——负责人亲自执行,第 1/2/3 步证据经 dsh_workplan_delegate(action="direct") 登记(' + START_EVIDENCE_MIN_CHARS_BRIEF + ';可选 reasoningEffort="low");复杂任务(medium/high/xhigh/max)合计不少于 8 人且最多 12 人,少于 8 人硬性阻断);每位下级必须在 phase-0 经 dsh_workplan_delegate(action="self_effort") 按自己分到的单项任务复杂度自配推理等级(轻度=low;qwen 中等=medium、非 qwen 中等=high;qwen 非常复杂=xhigh、非 qwen 非常复杂=max),专家自配为权威(分工表 per-expert 档仅建议),平台登记后以自配档接续下级会话,全程应用;平台会按上述等级集合自动钳制越界档并留痕,等级在其任务全生命周期生效且不可被覆盖。第三层为叶子层:任何第四层派发一律被拒绝。');
|
|
109
108
|
/*
|
|
110
109
|
* [3.0.0] 用户 2026-11-14 第 3、5、6、7、8、10、11 条要求:负责人侧四条硬规则。
|
|
111
110
|
* 与代码门禁同源(planDelegations 的 checkAtomicAssignment、comm-format 的
|
|
112
111
|
* F10/F11),提示词只是把代码已经在执行的规则提前说清楚。
|
|
113
112
|
*/
|
|
114
|
-
lines.push('- 极简任务硬门槛(用户要求 5,用户裁决 A=硬门槛):你派出的每一条任务必须简单到像 1+1=2
|
|
113
|
+
lines.push('- 极简任务硬门槛(用户要求 5,用户裁决 A=硬门槛):你派出的每一条任务必须简单到像 1+1=2——一个动作、一个主产物、一项可独立验收;出现「并且/并/同时/另外/还要/以及/分别/顺便/然后/接着/再」或分号并列、或一个任务里写了多句(含英文句点分隔的多句)、或超过 300 字符,平台直接拒绝派发(DELEGATE_TASK_NOT_ATOMIC)并给出拆分提示,实例:不要派「分析并修复并写测试」,要拆成「读 X 定位原因」「按原因改 Y」「写 Z 用例」三条。');
|
|
115
114
|
lines.push('- 质量要求硬门槛(用户要求 6):每一条分派都必须带 qualityRequirements(至少 1 条、每条 ≤400 字符、最多 8 条),写清「成果必须达到什么要求、什么算合格、怎么算不合格」;缺它平台拒绝派发(DELEGATE_QUALITY_REQUIREMENTS_MISSING)。任务书会把这块原文交给专家。');
|
|
116
115
|
lines.push('- 专家汇报必须精简且是 JSON(用户要求 7):专家完成后在证据块里给出 report(keyResults/keyInfo/importantInfo/leadRequirements 四个字符串数组,每数组 ≤6 条、每条 ≤200 字符,禁止重复);你收到后逐条核对,缺项或重复会被格式门禁退回(F10)。');
|
|
117
116
|
lines.push('- 你的汇总必须精简且是 JSON(用户要求 8/10/11):汇总本部门全部专家汇报后,在证据块里给出 departmentSummary(keyResults/keyInfo/importantInfo/sources 四个字符串数组,sources 必须覆盖全部已派发专家,禁止累赘重复);不合格会被退回(F11)。汇总完成后直接交回主 Agent,不需要另建文件。');
|
|
118
117
|
lines.push('- 执行时间与验收:你和每位全球顶尖专家均没有总时长、单次时长、空闲或回执硬截止。开工预估及其汇总只用于协调与告知,未报齐时如实显示部分和,但不构成分钟判据;不得以耗时、预估超额或未经时间批准为由拒绝 done,extendMs 已停用。完成只由真实结果、产物、结构化证据和质量验收决定;用户显式取消与真实错误仍然有效。');
|
|
118
|
+
lines.push('- 专家遇阻处置(3.0.5 硬规则,机制已强制):任何专家调用 dsh_workplan_escalate 后,禁止用 review/dispatch/direct 把该问题改派、重派或降级给其他专家;你必须先用 action="status" 全面梳理该成员的问题与本部门全部 delegates 执行状态,再研究形成解决方案,最后用 dsh_workplan_instruct 答复原 member;平台在该成员待指示期间会硬拒一切改派动作,投递成功后强制原专家继续执行。');
|
|
119
119
|
}
|
|
120
120
|
return lines.join('\n');
|
|
121
121
|
}
|
|
@@ -130,12 +130,8 @@ const MIN_COMPLEX_DELEGATE_MEMBERS = 8;
|
|
|
130
130
|
const MAX_COMPLEX_DELEGATE_MEMBERS = 12;
|
|
131
131
|
/** [2.5.4][T4] D1:除 low 外全部算复杂——medium/high/xhigh/max 均触发 ≥8 人门禁,xhigh 不豁免。 */
|
|
132
132
|
const COMPLEX_DECLARED_EFFORTS = Object.freeze(['medium', 'high', 'xhigh', 'max']);
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
.map((item) => String(item ?? '').trim())
|
|
136
|
-
.filter(Boolean)
|
|
137
|
-
.slice(0, limit);
|
|
138
|
-
}
|
|
133
|
+
// [3.0.8] 梳理产物(problemAnalysis/approach/approachBasis 等)已随两轮思考
|
|
134
|
+
// deepThink 门禁废除,分工表闸不再读取清单字段,readTrimmedStrings 一并退役。
|
|
139
135
|
/**
|
|
140
136
|
* 梳理产物校验 + 分工表校验 + 等级钳制,三合一(一次调用给出全部拒因)。
|
|
141
137
|
* @param input.consolidation 部门负责人提交的梳理产物(review 阶段写入行,
|
|
@@ -147,23 +143,15 @@ export function planDelegations(input) {
|
|
|
147
143
|
const empty = { ok: false, code: 'DELEGATE_CONSOLIDATION_MISSING', members: [], clamped: [], taskEffort: null, taskEffortClamped: null };
|
|
148
144
|
const consolidation = input?.consolidation;
|
|
149
145
|
if (!consolidation || typeof consolidation !== 'object') {
|
|
150
|
-
return { ...empty, error: '
|
|
151
|
-
}
|
|
152
|
-
const problemAnalysis = readTrimmedStrings(consolidation.problemAnalysis, 12);
|
|
153
|
-
if (problemAnalysis.length === 0) {
|
|
154
|
-
return { ...empty, code: 'DELEGATE_CONSOLIDATION_INCOMPLETE', error: '梳理产物不完整:problemAnalysis 至少 1 条(现状/事实/约束/未知/主要矛盾逐条写清),未梳理完不得进入再分配。' };
|
|
146
|
+
return { ...empty, error: '尚未提交分工表:先用 dsh_workplan_delegate(action="review") 提交分工表(assignments + taskReasoningEffort),派发才会放行(用户要求 4 的硬门禁)。' };
|
|
155
147
|
}
|
|
156
148
|
/*
|
|
157
|
-
* [
|
|
158
|
-
*
|
|
159
|
-
*
|
|
160
|
-
*
|
|
161
|
-
*
|
|
149
|
+
* [3.0.8] 深度梳理质量闸(problemAnalysis≥40 字)已随两轮思考 deepThink 门禁
|
|
150
|
+
* 一并废除:第 1/2/3 步证据(problemAnalysis/approach/approachBasis/resources/
|
|
151
|
+
* tools/preparation)改由开工闸 startPhases 承载(validateStartPhaseEvidence,
|
|
152
|
+
* review 时随 consolidation 一并校验),同一判据不再两处重复。此处只校验
|
|
153
|
+
* 分工表与整体等级,拒因顺序不变。
|
|
162
154
|
*/
|
|
163
|
-
const problemChars = problemAnalysis.reduce((sum, item) => sum + item.length, 0);
|
|
164
|
-
if (problemChars < MIN_PLANNING_PROBLEM_CHARS) {
|
|
165
|
-
return { ...empty, code: 'DELEGATE_CONSOLIDATION_INCOMPLETE', error: `梳理产物太薄:problemAnalysis 合计 ${problemChars} 字,至少 ${MIN_PLANNING_PROBLEM_CHARS} 字——第一轮必须全面、全盘、深入梳理、研究、思考自己的任务,逐条写清目标与验收、现状、约束、未知、主要矛盾与边界;一句话不能冒充深度梳理。` };
|
|
166
|
-
}
|
|
167
155
|
/*
|
|
168
156
|
* [2.5.4][T4] 复杂判定必须用「声明档」(钳制前):
|
|
169
157
|
* declared = consolidation.taskReasoningEffort ?? input.taskEffortFallback。
|
|
@@ -196,7 +184,7 @@ export function planDelegations(input) {
|
|
|
196
184
|
return {
|
|
197
185
|
...empty,
|
|
198
186
|
code: 'DELEGATE_LOW_TASK_FORBIDDEN',
|
|
199
|
-
error: '本任务为 low 档(或未配置,视同 low):按用户裁决 D1–D5 禁止第三层下派,review/dispatch
|
|
187
|
+
error: '本任务为 low 档(或未配置,视同 low):按用户裁决 D1–D5 禁止第三层下派,review/dispatch 一律硬拒,无任何例外通道。请部门负责人亲自执行:完成五步第 1/2/3 步(任务梳理 + 资源/工具/方案研究 + 准备)后经 dsh_workplan_delegate(action="direct") 登记 startPhases={ planning{ problemAnalysis[], approach[], approachBasis[], resources[], tools[] }, preparation{ prepared[], evidence[] } }(' + START_EVIDENCE_MIN_CHARS_BRIEF + ';可选 reasoningEffort="low";不接受分工表),平台将以 low 档接续本会话亲自执行。已完成的历史派发不回溯。',
|
|
200
188
|
};
|
|
201
189
|
}
|
|
202
190
|
const memberCap = complexTask ? MAX_COMPLEX_DELEGATE_MEMBERS : MAX_DELEGATE_MEMBERS;
|
|
@@ -301,50 +289,10 @@ export function planDelegations(input) {
|
|
|
301
289
|
};
|
|
302
290
|
}
|
|
303
291
|
/*
|
|
304
|
-
* [
|
|
305
|
-
*
|
|
306
|
-
*
|
|
307
|
-
* 思考自己的任务;
|
|
308
|
-
* 第二轮(approach):基于第一轮完成好的所有结果,再全面、全盘、深入地
|
|
309
|
-
* 开展梳理、研究和思考,理清具体一步步执行、完美完成任务的方法、流程、
|
|
310
|
-
* 步骤;approachBasis 写清第二轮如何基于第一轮全部结果(依赖可审计)。
|
|
311
|
-
* 放在角色配比校验之后:缺 problemAnalysis/assignments/角色配比的旧拒因
|
|
312
|
-
* 顺序不变,两轮产物门禁是新增的最后一道闸。
|
|
292
|
+
* [3.0.8] 两轮思考产物闸(approach≥40 字 / approachBasis≥20 字)已废除:第 1/2
|
|
293
|
+
* 步证据经 review 的 startPhases 开工闸校验(与主 Agent/专家同一判据),不再在
|
|
294
|
+
* 分工表闸重复。下方直接是复杂任务人数下限闸,拒因顺序不变。
|
|
313
295
|
*/
|
|
314
|
-
const approach = readTrimmedStrings(consolidation.approach, 12);
|
|
315
|
-
if (approach.length === 0) {
|
|
316
|
-
return {
|
|
317
|
-
...empty,
|
|
318
|
-
code: 'DELEGATE_CONSOLIDATION_INCOMPLETE',
|
|
319
|
-
error: '两轮深度思考未完成:approach 至少 1 条——第二轮必须基于第一轮完成好的所有结果,再全面、全盘、深入地开展梳理、研究和思考,理清自己该具体如何一步步执行、达到最终完美完成自己任务的方法、流程和步骤;未理清前不得进入执行与再分配。',
|
|
320
|
-
};
|
|
321
|
-
}
|
|
322
|
-
// [2.5.4][T3R1] 第二轮方法流程步骤质量闸:与主 Agent/叶子同一 40 字下限。
|
|
323
|
-
const approachChars = approach.reduce((sum, item) => sum + item.length, 0);
|
|
324
|
-
if (approachChars < MIN_PLANNING_APPROACH_CHARS) {
|
|
325
|
-
return {
|
|
326
|
-
...empty,
|
|
327
|
-
code: 'DELEGATE_CONSOLIDATION_INCOMPLETE',
|
|
328
|
-
error: `梳理产物太薄:approach 合计 ${approachChars} 字,至少 ${MIN_PLANNING_APPROACH_CHARS} 字——第二轮要基于第一轮全部结果理清具体一步步执行、完美完成任务的方法、流程和步骤,而不是一句目标。`,
|
|
329
|
-
};
|
|
330
|
-
}
|
|
331
|
-
const approachBasis = readTrimmedStrings(consolidation.approachBasis, 12);
|
|
332
|
-
if (approachBasis.length === 0) {
|
|
333
|
-
return {
|
|
334
|
-
...empty,
|
|
335
|
-
code: 'DELEGATE_CONSOLIDATION_INCOMPLETE',
|
|
336
|
-
error: '两轮深度思考未完成:approachBasis 至少 1 条——第二轮的方法、流程、步骤必须基于第一轮完成好的所有结果,逐条写清第一轮的哪些事实/约束/矛盾决定了第二轮的哪些方法/流程/步骤(依赖依据,不可省略)。',
|
|
337
|
-
};
|
|
338
|
-
}
|
|
339
|
-
// [2.5.4][T3R1] 第二轮依据质量闸:与主 Agent/叶子同一 20 字下限。
|
|
340
|
-
const basisChars = approachBasis.reduce((sum, item) => sum + item.length, 0);
|
|
341
|
-
if (basisChars < MIN_PLANNING_BASIS_CHARS) {
|
|
342
|
-
return {
|
|
343
|
-
...empty,
|
|
344
|
-
code: 'DELEGATE_CONSOLIDATION_INCOMPLETE',
|
|
345
|
-
error: `梳理产物太薄:approachBasis 合计 ${basisChars} 字,至少 ${MIN_PLANNING_BASIS_CHARS} 字——要写清第二轮的方法、流程、步骤如何基于第一轮梳理、研究、思考完成好的所有结果(拆解理由与依赖对应,不可省略)。`,
|
|
346
|
-
};
|
|
347
|
-
}
|
|
348
296
|
/*
|
|
349
297
|
* [2.5.4][T4] 用户决策 D1/D2 人数下限硬门禁(新增的最后一道闸):
|
|
350
298
|
* 复杂任务(声明档 medium/high/xhigh/max)expert+member 合计必须 ≥8 人,
|
|
@@ -397,11 +345,6 @@ export function planDelegations(input) {
|
|
|
397
345
|
// [2.5.5][T3] 钳制前原始声明随 ok 返回,供平台持久化为 taskReasoningEffortDeclared。
|
|
398
346
|
taskEffortDeclared: typeof rawTaskEffort === 'string' ? rawTaskEffort : null,
|
|
399
347
|
consolidation: {
|
|
400
|
-
problemAnalysis,
|
|
401
|
-
constraints: readTrimmedStrings(consolidation.constraints, 12),
|
|
402
|
-
unknowns: readTrimmedStrings(consolidation.unknowns, 12),
|
|
403
|
-
approach,
|
|
404
|
-
approachBasis,
|
|
405
348
|
assignments: members.length,
|
|
406
349
|
taskReasoningEffort: taskEffort,
|
|
407
350
|
},
|
|
@@ -444,18 +387,18 @@ export function buildDelegateePrompt(input) {
|
|
|
444
387
|
input.rulesBrief,
|
|
445
388
|
'',
|
|
446
389
|
'执行要求(用户强制要求 5 原文口径):',
|
|
447
|
-
'-
|
|
390
|
+
'- 执行自己的任务必须先完成下方「五步工作法」的前三步(3.0.8 单一框架):第一步全面、全盘、深入梳理、研究、思考自己的任务;第二步基于第一步完成好的所有结果研究需要哪些资源、哪些工具、具体实施方案(方法、流程、步骤,含依据 approachBasis);第三步把资源与工具真正备齐并给出就绪证据。前三步证据经 phase-0 的 self_effort 一并提交 startPhases,未登记合格证据平台不会接续你进入正式执行;第四步执行必须严格基于第二步理清的方法、流程、步骤,全程少走弯路(先查历史教训、先验证再动手、不重复试错)。',
|
|
448
391
|
'- 你的推理等级以自配为权威(分工表档仅建议):phase-0(low 档启动)唯一职责是经 dsh_workplan_delegate(action="self_effort") 提交自配档;phase-1 以登记生效的自配档全程应用(规划、执行、验证、复盘全生命周期),不得自行换档。',
|
|
449
392
|
'- 开工前必须先预估本人任务耗时(整数分钟)并经 self_effort 的 timeNotice={ declaredMinutes: 正整数分钟, reason? } 上报部门负责人,未上报不接续(T6/D9 硬门禁:ESTIMATE_MISSING/ESTIMATE_INVALID);该上报只是协调信息,必须如实预估。你和部门负责人执行任务均没有总时长、单次时长、空闲或回执硬截止;预估或实际耗时不会触发延期、超时接手,也不影响 done 验收。',
|
|
450
393
|
'- 必须在确保自身任务完成品质非常高的前提下,完美、超高效率地执行;严禁低效执行与浪费 token。',
|
|
451
394
|
'- 你是第三层叶子执行者:不得派生任何第四层 Agent/子会话;无法完成时在结论首行写 BLOCKED: 原因 并说明缺什么,不要空转。',
|
|
452
|
-
'-
|
|
395
|
+
'- 遇阻上报通道(3.0.5 四步闭环):遇阻(缺权限/缺输入/依赖产物缺失/需求自相矛盾/无法验证/需要负责人决定方向)时,第一动作是调用 dsh_workplan_escalate({ "question": "需要负责人回答的单个问题", "options": ["可选方向"], "needs": ["需要谁提供什么"] })。流程必须严格为:你先向部门负责人报告具体问题→负责人全面梳理你的问题与本部门全部已派发任务执行状态→负责人研究形成解决方案→负责人用 dsh_workplan_instruct 把方案告诉你→你继续执行原任务。平台禁止负责人在你待指示期间把你改派给其他专家;你必须是继续执行的人。调用 escalate 成功后停止推进、只做只读核对,不要自行选定一个选项继续。',
|
|
453
396
|
'- 完成后把结论与逐项证据(命令输出/文件/引用)用简洁中文回报给部门负责人会话;同时把同一份结构化结论写入 reports/wp-member-<你的成员名>-<任务代号>.json(相对工作目录,目录不存在就创建)作为结算兜底。',
|
|
454
|
-
`- 结果块契约:以 ${EVIDENCE_MARKER_BEGIN} 开头、${EVIDENCE_MARKER_END} 结尾,内含合法 JSON(status ∈ done/blocked/partial、phases
|
|
397
|
+
`- 结果块契约:以 ${EVIDENCE_MARKER_BEGIN} 开头、${EVIDENCE_MARKER_END} 结尾,内含合法 JSON(status ∈ done/blocked/partial、phases 五步证据、acceptance 逐条带证据)。`,
|
|
455
398
|
'',
|
|
456
399
|
renderExpertReportSpec(),
|
|
457
400
|
'',
|
|
458
|
-
...
|
|
401
|
+
...fiveStepPromptLines(),
|
|
459
402
|
].filter(Boolean).join('\n'));
|
|
460
403
|
}
|
|
461
404
|
/**
|
|
@@ -471,8 +414,8 @@ export function buildPhaseZeroDelegateePrompt(input) {
|
|
|
471
414
|
...(qualityBlock ? [qualityBlock] : []),
|
|
472
415
|
`工作目录:${input.cwd || '(未知)'}`,
|
|
473
416
|
...(input.extraContext ? ['', input.extraContext] : []),
|
|
474
|
-
'
|
|
475
|
-
'
|
|
476
|
-
'不要执行任务本身,不得派生任何第四层 Agent/子会话。缺交或不合格
|
|
417
|
+
'本阶段唯一职责(先配置+先研究准备,后开工):评估你分到的单项任务的复杂度,并完成五步工作法前三步(任务梳理、资源/工具/方案研究、准备就绪),然后调用 dsh_workplan_delegate(action="self_effort") 一次性提交:reasoningEffort(你的自配推理等级:轻度=low;qwen 中等=medium、非 qwen 中等=high;qwen 非常复杂=xhigh、非 qwen 非常复杂=max)+ complexityRationale(复杂度依据,必填)+ startPhases={ planning{ problemAnalysis[], approach[], approachBasis[], resources[], tools[] }, preparation{ prepared[], evidence[] } }(第 1/2/3 步证据,必填)+ timeNotice={ declaredMinutes: 正整数分钟, reason? }(开工前预估,必填)。未提交/不合格预估会被硬拒(ESTIMATE_MISSING/ESTIMATE_INVALID):没有告知部门负责人预估时间,先拦截,再告知此人,你必须自己预估时间,汇报给对应负责人后,才可以重试或继续执行。',
|
|
418
|
+
'startPhases 五步前三步口径(与主 Agent/负责人同一判据):第一步 problemAnalysis=先全面、全盘、深入梳理、研究、思考自己分到的任务(目标与验收/现状/事实/约束/未知/主要矛盾/边界,合计≥40字);第二步 resources=需要哪些资源(数据/文件/权限/人/知识/时间,合计≥20字)+ tools=需要哪些工具、每个用来做什么(合计≥10字)+ approach=基于第一步完成好的所有结果理清的具体一步步执行、确保完美完成的方法、流程和步骤(合计≥40字,含如何少走弯路:先查历史教训、先验证再动手、不重复试错)+ approachBasis=第二步如何基于第一步全部结果的依据对应(合计≥20字);第三步 preparation.prepared=已备齐的资源/工具清单(合计≥20字)+ preparation.evidence=逐项就绪证据(命令输出/文件路径/配置项/版本号/引用,合计≥20字)。',
|
|
419
|
+
'不要执行任务本身,不得派生任何第四层 Agent/子会话。缺交或不合格 startPhases 会被硬拒(START_EVIDENCE_MISSING / START_EVIDENCE_INCOMPLETE),不登记、不接续。三项齐全提交后结束本回合;平台会立即以你的自配档接续本会话进入 phase-1(正式任务),正式执行必须严格按你第二步理清的方法、流程、步骤进行。越界档由平台按模型家族合法集合钳制并留痕。',
|
|
477
420
|
].join('\n');
|
|
478
421
|
}
|
|
@@ -0,0 +1,238 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* [3.0.6][第 3 批②] dsh-workplan 专用通知台账(notice ledger)。
|
|
3
|
+
*
|
|
4
|
+
* 审计病根:插件通知唯一的持久可见通道是 user/message,与用户真实输入混在同
|
|
5
|
+
* 一条事件流里(source.kind 虽可区分,但没有任何插件侧权威台账可供工具/前端
|
|
6
|
+
* 直接消费)。
|
|
7
|
+
*
|
|
8
|
+
* 官方约束(dsh-agent-preset/skills/dsh-doc/references/practices.md:21):
|
|
9
|
+
* 1. 禁止给 Session 新增自定义事件类型——live Session.append 无法打
|
|
10
|
+
* ignorable 标记,重启后 Session 会拒绝重新打开;
|
|
11
|
+
* 2. appendPluginRecord() 保留给 DSH 实验包,本插件不得使用;
|
|
12
|
+
* 3. 插件自有数据应放在插件自己的存储里。
|
|
13
|
+
*
|
|
14
|
+
* 因此 v1 专用通道 = 插件自有 JSONL 台账(默认 ~/.dsh/workplan/notices.jsonl,
|
|
15
|
+
* 可用 DSH_WORKPLAN_NOTICES_FILE 覆盖):
|
|
16
|
+
* - appendUserMessage 每次成功落盘一条 workplan 通知后,同步追加一行台账;
|
|
17
|
+
* - 台账行自带 sessionId/planId/kind/form/summary/text,是机器可读的权威
|
|
18
|
+
* 通知流(区别于用户真实输入——真实输入永远不会进本文件);
|
|
19
|
+
* - 写入失败不拖垮通知投递(user/message 才是模型的权威通道,且已通过
|
|
20
|
+
* 回读校验):失败行进内存环形缓冲,下一次写入时先行补落,尽最大努力
|
|
21
|
+
* 不丢、且绝不静默。
|
|
22
|
+
*
|
|
23
|
+
* 纪律与 lessons.ts(第 1 批)一致:同步读写、整行 JSON、坏行读端跳过/写端
|
|
24
|
+
* 原样保留。审计证据默认永久保留,不做轮转(与 journalRetentionDays 默认 0
|
|
25
|
+
* 的裁决一致)。
|
|
26
|
+
*
|
|
27
|
+
* [复审修复][第 4 批] 治理与安全加固:
|
|
28
|
+
* - 行数上限 NOTICE_LEDGER_MAX_LINES(默认 5000,可被正整数环境变量
|
|
29
|
+
* DSH_WORKPLAN_NOTICES_MAX_LINES 覆盖):超限即重写为「最新 N 行」
|
|
30
|
+
* (读全 → 取末 N → tmp+rename 原子替换),重写失败 best-effort 不拖垮写入;
|
|
31
|
+
* - 权限:目录 0o700、文件 0o600(新建以 mode 落盘、既有文件 best-effort chmod);
|
|
32
|
+
* - 防符号链接投毒:写/重写前 lstatSync 目标文件,是符号链接则跳过写入并
|
|
33
|
+
* console.warn(不抛错),绝不跟随链接写任意路径。
|
|
34
|
+
*/
|
|
35
|
+
import { appendFileSync, chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
|
|
36
|
+
import { homedir } from 'node:os';
|
|
37
|
+
import { dirname, join } from 'node:path';
|
|
38
|
+
export const NOTICE_LEDGER_VERSION = 1;
|
|
39
|
+
/** 写失败时的内存环形缓冲上限(尽最大努力补落,绝不清空丢弃)。 */
|
|
40
|
+
export const NOTICE_LEDGER_OVERFLOW_MAX = 100;
|
|
41
|
+
/** 台账行数上限:超过即重写为「最新 N 行」。可被 DSH_WORKPLAN_NOTICES_MAX_LINES(正整数)覆盖。 */
|
|
42
|
+
export const NOTICE_LEDGER_MAX_LINES = 5000;
|
|
43
|
+
function errorText(error) {
|
|
44
|
+
const text = error instanceof Error ? error.message : String(error);
|
|
45
|
+
return text.slice(0, 500);
|
|
46
|
+
}
|
|
47
|
+
/** 解析行数上限(env 优先,沿用 resolveNoticeLedgerFile 的解析风格)。 */
|
|
48
|
+
function resolveNoticeLedgerMaxLines(env = process.env) {
|
|
49
|
+
const raw = typeof env?.DSH_WORKPLAN_NOTICES_MAX_LINES === 'string'
|
|
50
|
+
? env.DSH_WORKPLAN_NOTICES_MAX_LINES.trim()
|
|
51
|
+
: '';
|
|
52
|
+
if (!raw)
|
|
53
|
+
return NOTICE_LEDGER_MAX_LINES;
|
|
54
|
+
const parsed = Number(raw);
|
|
55
|
+
return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : NOTICE_LEDGER_MAX_LINES;
|
|
56
|
+
}
|
|
57
|
+
/** 统计文本中的行数(按换行计;本模块写盘恒以 \n 结尾,行数 == \n 数)。 */
|
|
58
|
+
function countNewlines(text) {
|
|
59
|
+
let count = 0;
|
|
60
|
+
for (let i = 0; i < text.length; i += 1) {
|
|
61
|
+
if (text.charCodeAt(i) === 10)
|
|
62
|
+
count += 1;
|
|
63
|
+
}
|
|
64
|
+
return count;
|
|
65
|
+
}
|
|
66
|
+
/**
|
|
67
|
+
* 行数治理:写后若总行数超过上限,重写为「最新 N 行」。
|
|
68
|
+
* 全程 best-effort:任何失败只 console.warn,绝不抛错、绝不拖垮已成功的写入。
|
|
69
|
+
*/
|
|
70
|
+
function enforceNoticeLedgerCap(file, maxLines) {
|
|
71
|
+
if (!Number.isSafeInteger(maxLines) || maxLines <= 0)
|
|
72
|
+
return;
|
|
73
|
+
let text;
|
|
74
|
+
try {
|
|
75
|
+
text = readFileSync(file, 'utf8');
|
|
76
|
+
}
|
|
77
|
+
catch (error) {
|
|
78
|
+
console.warn(`dsh-workplan: notice 台账行数统计失败(不重写)file=${file}(${errorText(error)})`);
|
|
79
|
+
return;
|
|
80
|
+
}
|
|
81
|
+
const total = countNewlines(text);
|
|
82
|
+
if (total <= maxLines)
|
|
83
|
+
return;
|
|
84
|
+
// 防符号链接投毒:重写前再确认目标是普通文件(TOCTOU 缩小面;rename 只换链接本身也不跟随,但按纪律跳过)。
|
|
85
|
+
try {
|
|
86
|
+
if (lstatSync(file).isSymbolicLink()) {
|
|
87
|
+
console.warn(`dsh-workplan: notice 台账是符号链接,跳过重写 file=${file}`);
|
|
88
|
+
return;
|
|
89
|
+
}
|
|
90
|
+
}
|
|
91
|
+
catch (error) {
|
|
92
|
+
console.warn(`dsh-workplan: notice 台账重写前 lstat 失败(不重写)file=${file}(${errorText(error)})`);
|
|
93
|
+
return;
|
|
94
|
+
}
|
|
95
|
+
const kept = text.split('\n').filter((line) => line.trim() !== '').slice(-maxLines);
|
|
96
|
+
const body = kept.length > 0 ? `${kept.join('\n')}\n` : '';
|
|
97
|
+
const tmp = `${file}.tmp-${process.pid}`;
|
|
98
|
+
try {
|
|
99
|
+
writeFileSync(tmp, body, { encoding: 'utf8', mode: 0o600 });
|
|
100
|
+
renameSync(tmp, file);
|
|
101
|
+
}
|
|
102
|
+
catch (error) {
|
|
103
|
+
console.warn(`dsh-workplan: notice 台账超限重写失败(保留原文件)file=${file}(${errorText(error)})`);
|
|
104
|
+
try {
|
|
105
|
+
unlinkSync(tmp);
|
|
106
|
+
}
|
|
107
|
+
catch {
|
|
108
|
+
/* 临时文件清理失败可忽略。 */
|
|
109
|
+
}
|
|
110
|
+
}
|
|
111
|
+
}
|
|
112
|
+
/** 台账文件位置:默认用户主目录,跨项目保留;测试可用环境变量覆盖。 */
|
|
113
|
+
export function resolveNoticeLedgerFile(env = process.env) {
|
|
114
|
+
const override = typeof env?.DSH_WORKPLAN_NOTICES_FILE === 'string'
|
|
115
|
+
? env.DSH_WORKPLAN_NOTICES_FILE.trim()
|
|
116
|
+
: '';
|
|
117
|
+
if (override)
|
|
118
|
+
return override;
|
|
119
|
+
return join(homedir(), '.dsh', 'workplan', 'notices.jsonl');
|
|
120
|
+
}
|
|
121
|
+
function isRecord(value) {
|
|
122
|
+
return !!value && typeof value === 'object' && !Array.isArray(value);
|
|
123
|
+
}
|
|
124
|
+
function coerceRecord(raw) {
|
|
125
|
+
if (!isRecord(raw))
|
|
126
|
+
return null;
|
|
127
|
+
return {
|
|
128
|
+
version: Number(raw.version) || NOTICE_LEDGER_VERSION,
|
|
129
|
+
at: Number(raw.at) || 0,
|
|
130
|
+
sessionId: typeof raw.sessionId === 'string' ? raw.sessionId : '',
|
|
131
|
+
planId: typeof raw.planId === 'string' ? raw.planId : '',
|
|
132
|
+
kind: typeof raw.kind === 'string' ? raw.kind : '',
|
|
133
|
+
form: typeof raw.form === 'string' ? raw.form : '',
|
|
134
|
+
summary: typeof raw.summary === 'string' ? raw.summary : '',
|
|
135
|
+
text: typeof raw.text === 'string' ? raw.text : '',
|
|
136
|
+
surfaceSeq: Number.isSafeInteger(Number(raw.surfaceSeq)) ? Number(raw.surfaceSeq) : -1,
|
|
137
|
+
};
|
|
138
|
+
}
|
|
139
|
+
/** 读端:坏行跳过不拖垮整份台账。 */
|
|
140
|
+
export function readNoticeLedger(file = resolveNoticeLedgerFile()) {
|
|
141
|
+
if (!existsSync(file))
|
|
142
|
+
return [];
|
|
143
|
+
let text = '';
|
|
144
|
+
try {
|
|
145
|
+
text = readFileSync(file, 'utf8');
|
|
146
|
+
}
|
|
147
|
+
catch {
|
|
148
|
+
return [];
|
|
149
|
+
}
|
|
150
|
+
const out = [];
|
|
151
|
+
for (const line of text.split('\n')) {
|
|
152
|
+
const trimmed = line.trim();
|
|
153
|
+
if (!trimmed)
|
|
154
|
+
continue;
|
|
155
|
+
try {
|
|
156
|
+
const parsed = coerceRecord(JSON.parse(trimmed));
|
|
157
|
+
if (parsed)
|
|
158
|
+
out.push(parsed);
|
|
159
|
+
}
|
|
160
|
+
catch {
|
|
161
|
+
// 单行损坏跳过:append-only 文件不做重写,坏行原样留在盘上。
|
|
162
|
+
}
|
|
163
|
+
}
|
|
164
|
+
return out;
|
|
165
|
+
}
|
|
166
|
+
/** 内存补落缓冲:文件写入失败时暂存,下一次写入先行补落。 */
|
|
167
|
+
let overflow = [];
|
|
168
|
+
/** 取出当前积压的补落行数(可观测性/测试用)。 */
|
|
169
|
+
export function noticeLedgerOverflowSize() {
|
|
170
|
+
return overflow.length;
|
|
171
|
+
}
|
|
172
|
+
function textOfMessage(message) {
|
|
173
|
+
const content = message?.content;
|
|
174
|
+
if (typeof content === 'string')
|
|
175
|
+
return content;
|
|
176
|
+
if (Array.isArray(content)) {
|
|
177
|
+
return content
|
|
178
|
+
.map((block) => (typeof block?.text === 'string' ? block.text : ''))
|
|
179
|
+
.filter(Boolean)
|
|
180
|
+
.join('\n');
|
|
181
|
+
}
|
|
182
|
+
return '';
|
|
183
|
+
}
|
|
184
|
+
/**
|
|
185
|
+
* 追加一行通知台账(同步、尽力而为)。
|
|
186
|
+
*
|
|
187
|
+
* @returns 是否写入(含补落)成功;失败行留在内存环形缓冲等待下次补落。
|
|
188
|
+
*/
|
|
189
|
+
export function appendNoticeLedger(sessionId, message, file = resolveNoticeLedgerFile(), now = Date.now()) {
|
|
190
|
+
const source = isRecord(message?.source) ? message.source : {};
|
|
191
|
+
const record = {
|
|
192
|
+
version: NOTICE_LEDGER_VERSION,
|
|
193
|
+
at: now,
|
|
194
|
+
sessionId: String(sessionId ?? ''),
|
|
195
|
+
planId: typeof source.planId === 'string' ? source.planId
|
|
196
|
+
: (typeof message?.planId === 'string' ? message.planId : ''),
|
|
197
|
+
kind: typeof source.kind === 'string' ? source.kind : 'workplan',
|
|
198
|
+
form: typeof source.form === 'string' ? source.form : 'notice',
|
|
199
|
+
summary: typeof source.summary === 'string' ? source.summary : '',
|
|
200
|
+
text: textOfMessage(message),
|
|
201
|
+
surfaceSeq: typeof message?.seq === 'number' ? message.seq : -1,
|
|
202
|
+
};
|
|
203
|
+
return flushNoticeLedger(file, [JSON.stringify(record)]);
|
|
204
|
+
}
|
|
205
|
+
/** 先补落积压行,再写新行;全部成功才清空缓冲。 */
|
|
206
|
+
function flushNoticeLedger(file, freshLines) {
|
|
207
|
+
const pending = [...overflow, ...freshLines];
|
|
208
|
+
// 防符号链接投毒:目标是符号链接则跳过写入并告警(不抛错,行留缓冲等待下次)。
|
|
209
|
+
try {
|
|
210
|
+
if (lstatSync(file).isSymbolicLink()) {
|
|
211
|
+
console.warn(`dsh-workplan: notice 台账目标是符号链接,跳过写入 file=${file}`);
|
|
212
|
+
overflow = pending.slice(-NOTICE_LEDGER_OVERFLOW_MAX);
|
|
213
|
+
return false;
|
|
214
|
+
}
|
|
215
|
+
}
|
|
216
|
+
catch {
|
|
217
|
+
/* 文件不存在(ENOENT,首写)或 lstat 失败:交给 appendFileSync 显式成败。 */
|
|
218
|
+
}
|
|
219
|
+
try {
|
|
220
|
+
mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
|
|
221
|
+
appendFileSync(file, `${pending.join('\n')}\n`, { encoding: 'utf8', mode: 0o600 });
|
|
222
|
+
try {
|
|
223
|
+
// 既有文件权限收紧为 0o600(best-effort;新建文件已由 mode 覆盖)。
|
|
224
|
+
chmodSync(file, 0o600);
|
|
225
|
+
}
|
|
226
|
+
catch {
|
|
227
|
+
/* best-effort:权限收紧失败不阻断追加。 */
|
|
228
|
+
}
|
|
229
|
+
overflow = [];
|
|
230
|
+
// 行数治理(best-effort):超限即重写为「最新 N 行」,失败只 warn 不拖垮写入。
|
|
231
|
+
enforceNoticeLedgerCap(file, resolveNoticeLedgerMaxLines());
|
|
232
|
+
return true;
|
|
233
|
+
}
|
|
234
|
+
catch {
|
|
235
|
+
overflow = pending.slice(-NOTICE_LEDGER_OVERFLOW_MAX);
|
|
236
|
+
return false;
|
|
237
|
+
}
|
|
238
|
+
}
|