Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

fix(desktop): 账本按 review 收紧证据、预算、删除清理与刷新代次

zqchrisfa2ed1f5fe5f
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/botWorkingMemory.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/botWorkingMemory.test.ts
index e138eb5e88..140d586903 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/botWorkingMemory.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/botWorkingMemory.test.ts
@@ -12,6 +12,7 @@ import {
emptyWorkingMemory,
isWorkingMemoryFresh,
parseWorkingMemory,
+ pruneWorkingMemoryForMessages,
readBotWorkingMemory,
renderWorkingMemory,
WORKING_MEMORY_HEADING,
@@ -85,13 +86,69 @@ describe('applyWorkingMemoryProposal', () => {
messages,
{ now, coveredThroughRowid: 5 },
);
- expect(next.commitments.map((c) => c.text)).toEqual(['周五前改完周报模板', '给设计稿加暗色模式']);
- expect(next.commitments[0]).toMatchObject({ id: 'c1', messageId: 'old', updatedAt: now });
+ expect(next.commitments.map((c) => c.text)).toEqual(['给设计稿加暗色模式', '周五前改完周报模板']);
+ // 原样带回的条目连时间都不动,排序才能表达"最新优先"。
+ expect(next.commitments.find((c) => c.id === 'c1')).toMatchObject({ messageId: 'old', updatedAt: 1 });
expect(next.recentlyDone.map((d) => d.text)).toEqual(['测试已补上']);
// 水位只前进不后退。
expect(next.coveredThroughRowid).toBe(10);
});
+ it('requires evidence to change a field of an existing item, allows evidenced clearing, and bumps time only on real change', () => {
+ const previous: BotWorkingMemory = {
+ ...emptyWorkingMemory(),
+ commitments: [{ id: 'c1', text: '周五前改完周报模板', trigger: '周五前', updatedAt: 1 }],
+ threads: [{ id: 't1', text: '周报模板改版', status: 'active', next: '发用户确认', updatedAt: 1 }],
+ };
+ const base = { threads: [], commitments: [], waiting: [], corrections: [], recentlyDone: [], resolved: [] };
+ // 无证据改期限 → 当没提,旧值与时间都保留。
+ const unproven = applyWorkingMemoryProposal(
+ previous,
+ { ...base, commitments: [{ text: '周五前改完周报模板', trigger: '下周一' }] },
+ messages,
+ { now, coveredThroughRowid: 1 },
+ );
+ expect(unproven.commitments[0]).toMatchObject({ id: 'c1', trigger: '周五前', updatedAt: 1 });
+ // 有证据的改期限 → 接受并更新时间;有证据的空串 → 清空。
+ const proven = applyWorkingMemoryProposal(
+ previous,
+ {
+ ...base,
+ commitments: [{ text: '周五前改完周报模板', trigger: '下周一', evidence: { messageId: 'u1', quote: '周五前把周报模板' } }],
+ threads: [{ text: '周报模板改版', next: '', evidence: { messageId: 'a1', quote: '改完发你确认' } }],
+ },
+ messages,
+ { now, coveredThroughRowid: 1 },
+ );
+ expect(proven.commitments[0]).toMatchObject({ id: 'c1', trigger: '下周一', updatedAt: now });
+ expect(proven.threads[0]).toMatchObject({ id: 't1', status: 'active', updatedAt: now });
+ expect(proven.threads[0]).not.toHaveProperty('next');
+ // 字段省略 → 沿用旧值,不算变化。
+ const omitted = applyWorkingMemoryProposal(
+ previous,
+ { ...base, threads: [{ text: '周报模板改版', evidence: { messageId: 'a1', quote: '改完发你确认' } }] },
+ messages,
+ { now, coveredThroughRowid: 1 },
+ );
+ expect(omitted.threads[0]).toMatchObject({ id: 't1', next: '发用户确认', updatedAt: 1 });
+ });
+
+ it('prunes items that came from deleted messages', () => {
+ const memory: BotWorkingMemory = {
+ ...emptyWorkingMemory(),
+ commitments: [
+ { id: 'c1', text: '来自被删轮次的承诺', messageId: 'gone', updatedAt: 1 },
+ { id: 'c2', text: '仍然有效的承诺', messageId: 'kept', updatedAt: 2 },
+ { id: 'c3', text: '没有来源记录的旧承诺', updatedAt: 3 },
+ ],
+ corrections: [{ id: 'x', text: '被删的纠正', messageId: 'gone', updatedAt: 1 }],
+ };
+ const { memory: pruned, removed } = pruneWorkingMemoryForMessages(memory, new Set(['gone']));
+ expect(removed).toBe(2);
+ expect(pruned.commitments.map((c) => c.id)).toEqual(['c2', 'c3']);
+ expect(pruned.corrections).toEqual([]);
+ });
+
it('caps each section to its limit keeping the newest', () => {
const previous: BotWorkingMemory = {
...emptyWorkingMemory(),
@@ -133,14 +190,40 @@ describe('renderWorkingMemory', () => {
expect(text).toContain('Recently completed');
});
- it('drops trailing sections under budget but never the corrections, commitments or waiting', () => {
- const text = renderWorkingMemory(memory, {}, 500)!;
+ it('drops trailing sections first (newest-last region) and keeps corrections, commitments and waiting', () => {
+ const full = renderWorkingMemory(memory)!;
+ const text = renderWorkingMemory(memory, {}, full.length - 1)!;
+ expect(text.length).toBeLessThanOrEqual(full.length - 1);
expect(text).toContain('先结论后细节');
expect(text).toContain('周五前改完周报模板');
expect(text).toContain('用户确认配色');
+ expect(text).toContain('Open threads');
expect(text).not.toContain('Recently completed');
});
+ it('always stays within the budget: protected sections shed their oldest items, each keeping at least one', () => {
+ const big = (prefix: string, n: number) =>
+ Array.from({ length: n }, (_, i) => ({ id: `${prefix}${i}`, text: `${prefix} ${'很长的条目内容'.repeat(20)} ${i}`, updatedAt: n - i }));
+ const bloated: BotWorkingMemory = {
+ ...emptyWorkingMemory(),
+ corrections: big('纠正', 8),
+ commitments: big('承诺', 10),
+ waiting: big('等待', 6).map((w) => ({ ...w, on: 'user' as const })),
+ };
+ const budget = 1_500;
+ const text = renderWorkingMemory(bloated, {}, budget)!;
+ expect(text.length).toBeLessThanOrEqual(budget);
+ // 最新的(列表最前)留着,最旧的先被裁。
+ expect(text).toContain('纠正 ');
+ expect(text).toContain('承诺 ');
+ expect(text).toContain('等待 ');
+ expect(text).toContain('纠正 很长');
+ expect(text).not.toContain(' 7\n');
+ // 只有线索也会被裁进预算,而不是因为"区数不足"直接发超预算文本。
+ const threadsOnly: BotWorkingMemory = { ...emptyWorkingMemory(), threads: big('线索', 8).map((t) => ({ ...t, status: 'active' as const })) };
+ expect(renderWorkingMemory(threadsOnly, {}, 600)!.length).toBeLessThanOrEqual(600);
+ });
+
it('returns null for an empty ledger', () => {
expect(renderWorkingMemory(emptyWorkingMemory())).toBeNull();
});
@@ -197,13 +280,20 @@ describe('helpers', () => {
expect(view).toEqual({ threads: [], commitments: [], waiting: [{ text: '等确认', on: 'external' }], corrections: [], recentlyDone: [] });
});
- it('refresh registry is a one-shot per session and the note wraps the rendered ledger', () => {
+ it('refresh registry consumes only the generation that was read, so a compaction during an in-flight send survives', () => {
const registry = createWorkingMemoryRefreshRegistry();
- expect(registry.isPending('s')).toBe(false);
+ expect(registry.pendingGeneration('s')).toBeNull();
+ registry.markCompacted('s');
+ const first = registry.pendingGeneration('s')!;
+ expect(first).toBeGreaterThan(0);
+ // 发送在途时又压缩了一次:新一代替换旧一代。
registry.markCompacted('s');
- expect(registry.isPending('s')).toBe(true);
- registry.consume('s');
- expect(registry.isPending('s')).toBe(false);
+ const second = registry.pendingGeneration('s')!;
+ expect(second).toBeGreaterThan(first);
+ registry.consume('s', first);
+ expect(registry.pendingGeneration('s')).toBe(second);
+ registry.consume('s', second);
+ expect(registry.pendingGeneration('s')).toBeNull();
const note = buildWorkingMemoryRefreshNote('BODY');
expect(note).toContain('[Working memory refresh');
expect(note).toContain('BODY');
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/makerSendTransaction.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/makerSendTransaction.test.ts
index 60c67678c3..c5125ec8b4 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/makerSendTransaction.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/makerSendTransaction.test.ts
@@ -3464,40 +3464,59 @@ it('persists coordination audit metadata and dispatches the model without a prom
describe('working memory refresh after native compaction', () => {
const note = '[Working memory refresh · internal context]\n- 周五前改完周报模板';
- it('prepends the refresh note once and consumes it only after the engine accepted the turn', async () => {
+ it('prepends the refresh note once and consumes that generation only after the engine accepted the turn', async () => {
const session = createSession({ agentKind: 'codex' });
const { deps } = createDeps({
getSession: vi.fn(() => session),
- peekWorkingMemoryRefreshNote: vi.fn(async () => note),
- consumeWorkingMemoryRefreshNote: vi.fn(),
+ peekWorkingMemoryRefresh: vi.fn(async () => ({ generation: 7, note })),
+ consumeWorkingMemoryRefresh: vi.fn(),
});
await createMakerSendTransaction(deps).sendToAgentAccepted('session-1', 'hello');
expect(vi.mocked(session.send).mock.calls[0]?.[0]).toBe(`${uiLanguageNote()}\n\n${note}\n\nhello`);
- expect(deps.consumeWorkingMemoryRefreshNote).toHaveBeenCalledWith('session-1');
+ expect(deps.consumeWorkingMemoryRefresh).toHaveBeenCalledWith('session-1', 7);
const rejecting = createSession({ agentKind: 'codex', send: vi.fn(async () => ({ accepted: false }) as SessionSendResult) });
const { deps: rejectedDeps } = createDeps({
getSession: vi.fn(() => rejecting),
- peekWorkingMemoryRefreshNote: vi.fn(async () => note),
- consumeWorkingMemoryRefreshNote: vi.fn(),
+ peekWorkingMemoryRefresh: vi.fn(async () => ({ generation: 7, note })),
+ consumeWorkingMemoryRefresh: vi.fn(),
});
await createMakerSendTransaction(rejectedDeps).sendToAgentAccepted('session-1', 'hello').catch(() => undefined);
- expect(rejectedDeps.consumeWorkingMemoryRefreshNote).not.toHaveBeenCalled();
+ expect(rejectedDeps.consumeWorkingMemoryRefresh).not.toHaveBeenCalled();
});
- it('skips the refresh when a rebuild handoff already carries the ledger, but still clears the flag', async () => {
+ it('skips the refresh when a rebuild handoff already carries the ledger, but still consumes that generation', async () => {
const session = createSession({ agentKind: 'codex' });
const { deps } = createDeps({
getSession: vi.fn(() => session),
peekPendingHandoff: vi.fn(async () => 'HANDOFF'),
- peekWorkingMemoryRefreshNote: vi.fn(async () => note),
- consumeWorkingMemoryRefreshNote: vi.fn(),
+ peekWorkingMemoryRefresh: vi.fn(async () => ({ generation: 3, note })),
+ consumeWorkingMemoryRefresh: vi.fn(),
});
await createMakerSendTransaction(deps).sendToAgentAccepted('session-1', 'hello');
const sent = vi.mocked(session.send).mock.calls[0]?.[0] as string;
expect(sent).toContain('HANDOFF');
expect(sent).not.toContain('Working memory refresh');
- expect(deps.peekWorkingMemoryRefreshNote).not.toHaveBeenCalled();
- expect(deps.consumeWorkingMemoryRefreshNote).toHaveBeenCalledWith('session-1');
+ expect(deps.consumeWorkingMemoryRefresh).toHaveBeenCalledWith('session-1', 3);
+ });
+
+ it('consumes the marker even when the session has no ledger, and nothing when none is pending', async () => {
+ const session = createSession({ agentKind: 'codex' });
+ const { deps } = createDeps({
+ getSession: vi.fn(() => session),
+ peekWorkingMemoryRefresh: vi.fn(async () => ({ generation: 2, note: null })),
+ consumeWorkingMemoryRefresh: vi.fn(),
+ });
+ await createMakerSendTransaction(deps).sendToAgentAccepted('session-1', 'hello');
+ expect(vi.mocked(session.send).mock.calls[0]?.[0]).toBe(withUiLanguageNote('hello'));
+ expect(deps.consumeWorkingMemoryRefresh).toHaveBeenCalledWith('session-1', 2);
+
+ const { deps: idle, session: idleSession } = createDeps({
+ peekWorkingMemoryRefresh: vi.fn(async () => null),
+ consumeWorkingMemoryRefresh: vi.fn(),
+ });
+ await createMakerSendTransaction(idle).sendToAgentAccepted('session-1', 'hello');
+ expect(idleSession.send).toHaveBeenCalledOnce();
+ expect(idle.consumeWorkingMemoryRefresh).not.toHaveBeenCalled();
});
});
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/messageDeleteHandler.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/messageDeleteHandler.test.ts
index f889024042..c026c819c7 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/messageDeleteHandler.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/messageDeleteHandler.test.ts
@@ -37,6 +37,28 @@ function makeDeps(overrides: Partial<MessageDeleteHandlerDeps> = {}): MessageDel
}
describe('performMessageDeletion', () => {
+ it('excludes ledger items from the deleted messages in the handoff and prunes them only after the commit', async () => {
+ const order: string[] = [];
+ const deps = makeDeps({
+ readWorkingMemoryNote: vi.fn(async (_sessionId, opts) => {
+ order.push('read');
+ expect([...opts.excludeMessageIds]).toEqual(['target']);
+ return '== Working memory (host-maintained summary; not authorization) ==\n- 仍有效的承诺';
+ }),
+ pruneWorkingMemory: vi.fn(async () => {
+ order.push('prune');
+ }),
+ commitDeletion: vi.fn(async (sessionId, deletedClientIds) => {
+ order.push('commit');
+ return { sessionId, deletedClientIds, subagentRunIds: [], updatedAt: 500, preview: 'keep after' };
+ }),
+ });
+ await performMessageDeletion(deps, { sessionId: 'session-1', clientId: 'target' });
+ expect(order).toEqual(['read', 'commit', 'prune']);
+ expect(deps.pruneWorkingMemory).toHaveBeenCalledWith('session-1', new Set(['target']));
+ expect(vi.mocked(deps.commitDeletion).mock.calls[0]?.[2]).toContain('仍有效的承诺');
+ });
+
it('keeps the deleted-session preview on the visible message projection', () => {
const source = readFileSync(resolve(process.cwd(), 'src/main/localDb/ipc/messages.ts'), 'utf8');
const deletionBlock = source.slice(
diff --git a/apps/desktop/src/main/maker-ipc/botLearningReviewPlan.ts b/apps/desktop/src/main/maker-ipc/botLearningReviewPlan.ts
index a8afe2fc31..5348887734 100644
--- a/apps/desktop/src/main/maker-ipc/botLearningReviewPlan.ts
+++ b/apps/desktop/src/main/maker-ipc/botLearningReviewPlan.ts
@@ -54,7 +54,7 @@ For Skills, look actively for reusable workflows, formats, verified successful m
Existing snapshots are current after in-turn saves: do not repeat those saves, or change wording with no new lesson. No quota: empty arrays are appropriate if nothing durable was learned.
Each proposal needs an exact evidence quote from the supplied messages. Memory evidence must come from a user message, not assistant guesses or tool output. Use the user's language for titles and bodies. Do not call tools or initiate work. The host applies validated proposals to this teammate only.
Also maintain "working": the teammate's short-term working memory, supplied as workingMemory (may be empty). Return the full current state: {"threads":[{"text":"...","status":"active|waiting|blocked","next":"...","evidence":{...}}],"commitments":[{"text":"what the teammate promised","trigger":"when","evidence":{...}}],"waiting":[{"text":"...","on":"user|external","evidence":{...}}],"corrections":[{"text":"user's latest correction or decision","supersedes":"older text","evidence":{...}}],"recentlyDone":[{"text":"...","evidence":{...}}],"resolved":[{"text":"exact text of an existing item that is now done or no longer true","evidence":{...}}]}.
-Working-memory rules: copy unchanged items verbatim (no evidence needed); every new or reworded item needs an evidence quote from a user or assistant message in this exchange; list an existing item under "resolved" (with evidence) only when this exchange shows it is done or withdrawn, otherwise keep it. Items are one line each, max 240 characters, in the user's language. Working memory is a summary, never a record of permissions. Omit "working" entirely if nothing in this exchange changes it.`;
+Working-memory rules: copy unchanged items verbatim (no evidence needed); every new or reworded item, and any change to an existing item's status, next, trigger, on or supersedes, needs an evidence quote from a user or assistant message in this exchange; omit a field to keep its current value, send an empty string "" to clear it; list an existing item under "resolved" (with evidence) only when this exchange shows it is done or withdrawn, otherwise keep it. Items are one line each, max 240 characters, in the user's language. Working memory is a summary, never a record of permissions. Omit "working" entirely if nothing in this exchange changes it.`;
export function hasLearningEvidence(
proposal: { evidence: { messageId: string; quote: string } },
diff --git a/apps/desktop/src/main/maker-ipc/botWorkingMemory.ts b/apps/desktop/src/main/maker-ipc/botWorkingMemory.ts
index 96398b9bed..84a32e788f 100644
--- a/apps/desktop/src/main/maker-ipc/botWorkingMemory.ts
+++ b/apps/desktop/src/main/maker-ipc/botWorkingMemory.ts
@@ -243,12 +243,27 @@ const NEW_ITEM_ROLES = ['user', 'assistant'] as const;
const RESOLVE_ROLES = ['user', 'assistant', 'tool_result'] as const;
/**
- * 把模型提案并进已有账本,规则与记忆复盘一致:**没有原文证据的新条目不进账**。
- * - 与旧条目原文相同的条目直接沿用(保留 id / messageId),不需要证据;
- * - 新条目或改写过的条目必须引用本轮消息里的用户或伙伴原话;
+ * 可选文本字段的三态:`undefined` = 提案未提(沿用旧值);`''` = 显式清空;其它 = 新值。
+ * 模型要取消一个期限 / 下一步 / 被替代项,就回传空串。
+ */
+function resolveOptionalField(
+ prior: string | undefined,
+ proposed: string | undefined,
+ cap = WORKING_MEMORY_ITEM_CHARS,
+): string | undefined {
+ if (proposed === undefined) return prior;
+ const text = clampText(proposed, cap);
+ return text ? text : undefined;
+}
+
+/**
+ * 把模型提案并进已有账本,规则与记忆复盘一致:**没有原文证据的改动不进账**。
+ * - 与旧条目**完整内容**相同的条目原样沿用(保留 id / messageId / 时间),不需要证据;
+ * - 新条目、改写正文或改动期限 / 下一步 / 状态等字段,都必须引用本轮用户或伙伴原话;
+ * 无证据的字段改动按"未提"处理,旧值保留;
* - 旧条目不在提案里时**保留**——漏写不等于完成;要删除走 `resolved`,同样要证据
- * (用户 / 伙伴 / 工具结果均可)。
- * - 各区按上限保留最新的。
+ * (用户 / 伙伴 / 工具结果均可);
+ * - 各区按上限保留最新的;只有真正变过的条目才更新时间,排序才有意义。
*/
export function applyWorkingMemoryProposal(
previous: BotWorkingMemory | null,
@@ -264,12 +279,17 @@ export function applyWorkingMemoryProposal(
);
let seq = 0;
const nextId = () => `wm_${opts.now.toString(36)}_${(seq += 1)}`;
+ const sameItem = (a: WorkingMemoryItem, b: WorkingMemoryItem): boolean => {
+ const { updatedAt: _a, ...left } = a;
+ const { updatedAt: _b, ...right } = b;
+ return JSON.stringify(left) === JSON.stringify(right);
+ };
function merge<P extends ProposedItem, T extends WorkingMemoryItem>(
existing: T[],
proposed: P[],
cap: number,
- build: (base: WorkingMemoryItem, item: P) => T,
+ build: (base: T | null, item: P, seed: WorkingMemoryItem) => T,
): T[] {
const byText = new Map(existing.map((item) => [item.text, item] as const));
const kept = new Map<string, T>();
@@ -277,12 +297,16 @@ export function applyWorkingMemoryProposal(
const text = clampText(item.text);
if (!text || resolvedTexts.has(text)) continue;
const prior = byText.get(text);
+ const evidenced = evidenceHolds(item.evidence, messages, NEW_ITEM_ROLES);
if (prior) {
- kept.set(text, build({ ...prior, updatedAt: opts.now }, item));
+ const candidate = build(prior, item, { ...prior, updatedAt: opts.now });
+ // 完整内容没变:原样沿用,时间也不动。字段变了:要证据,没证据就当没提。
+ if (sameItem(candidate, prior) || !evidenced) kept.set(text, prior);
+ else kept.set(text, candidate);
continue;
}
- if (!evidenceHolds(item.evidence, messages, NEW_ITEM_ROLES)) continue;
- kept.set(text, build({ id: nextId(), text, messageId: item.evidence!.messageId, updatedAt: opts.now }, item));
+ if (!evidenced) continue;
+ kept.set(text, build(null, item, { id: nextId(), text, messageId: item.evidence!.messageId, updatedAt: opts.now }));
}
// 提案没提到的旧条目保留(漏写 ≠ 完成),除非被 resolved 点名。
for (const item of existing) {
@@ -290,31 +314,77 @@ export function applyWorkingMemoryProposal(
}
return [...kept.values()].sort((a, b) => b.updatedAt - a.updatedAt).slice(0, cap);
}
+ // seed 由旧条目展开而来,可能已带该字段:值为 undefined 表示清空,要把旧键一并去掉。
+ const withField = <T extends WorkingMemoryItem, K extends string>(
+ seed: WorkingMemoryItem,
+ key: K,
+ value: string | undefined,
+ ): T => {
+ const { [key]: _dropped, ...rest } = seed as WorkingMemoryItem & Record<K, unknown>;
+ return { ...rest, ...(value ? { [key]: value } : {}) } as unknown as T;
+ };
return {
coveredThroughRowid: Math.max(prev.coveredThroughRowid, opts.coveredThroughRowid),
updatedAt: opts.now,
- threads: merge(prev.threads, proposal.threads, WORKING_MEMORY_LIMITS.threads, (base, item) => ({
- ...base,
- status: item.status ?? ('status' in base ? (base as WorkingThread).status : 'active'),
- ...(clampText(item.next) ? { next: clampText(item.next) } : {}),
- })),
- commitments: merge(prev.commitments, proposal.commitments, WORKING_MEMORY_LIMITS.commitments, (base, item) => ({
- ...base,
- ...(clampText(item.trigger, 120) ? { trigger: clampText(item.trigger, 120) } : {}),
- })),
- waiting: merge(prev.waiting, proposal.waiting, WORKING_MEMORY_LIMITS.waiting, (base, item) => ({
- ...base,
- on: item.on ?? ('on' in base ? (base as WorkingWait).on : 'user'),
+ threads: merge(prev.threads, proposal.threads, WORKING_MEMORY_LIMITS.threads, (prior, item, seed) => ({
+ ...withField<WorkingThread, 'next'>(seed, 'next', resolveOptionalField(prior?.next, item.next)),
+ status: item.status ?? prior?.status ?? 'active',
})),
- corrections: merge(prev.corrections, proposal.corrections, WORKING_MEMORY_LIMITS.corrections, (base, item) => ({
- ...base,
- ...(clampText(item.supersedes) ? { supersedes: clampText(item.supersedes) } : {}),
+ commitments: merge(prev.commitments, proposal.commitments, WORKING_MEMORY_LIMITS.commitments, (prior, item, seed) =>
+ withField<WorkingCommitment, 'trigger'>(seed, 'trigger', resolveOptionalField(prior?.trigger, item.trigger, 120)),
+ ),
+ waiting: merge(prev.waiting, proposal.waiting, WORKING_MEMORY_LIMITS.waiting, (prior, item, seed) => ({
+ ...seed,
+ on: item.on ?? prior?.on ?? 'user',
})),
- recentlyDone: merge(prev.recentlyDone, proposal.recentlyDone, WORKING_MEMORY_LIMITS.recentlyDone, (base) => base),
+ corrections: merge(prev.corrections, proposal.corrections, WORKING_MEMORY_LIMITS.corrections, (prior, item, seed) =>
+ withField<WorkingCorrection, 'supersedes'>(seed, 'supersedes', resolveOptionalField(prior?.supersedes, item.supersedes)),
+ ),
+ recentlyDone: merge(prev.recentlyDone, proposal.recentlyDone, WORKING_MEMORY_LIMITS.recentlyDone, (_prior, _item, seed) => seed),
};
}
+/**
+ * 用户删除消息后,由这些消息产生的账本条目也要一起消失——否则被删轮次的承诺 / 纠正
+ * 会通过交接回到新上下文。只删 messageId 命中的条目;没有来源记录的旧条目不动。
+ */
+export function pruneWorkingMemoryForMessages(
+ memory: BotWorkingMemory,
+ deletedMessageIds: ReadonlySet<string>,
+): { memory: BotWorkingMemory; removed: number } {
+ let removed = 0;
+ const keep = <T extends WorkingMemoryItem>(items: T[]): T[] =>
+ items.filter((item) => {
+ const hit = !!item.messageId && deletedMessageIds.has(item.messageId);
+ if (hit) removed += 1;
+ return !hit;
+ });
+ const pruned: BotWorkingMemory = {
+ ...memory,
+ threads: keep(memory.threads),
+ commitments: keep(memory.commitments),
+ waiting: keep(memory.waiting),
+ corrections: keep(memory.corrections),
+ recentlyDone: keep(memory.recentlyDone),
+ };
+ return { memory: pruned, removed };
+}
+
+/** 持久化版本:CAS 写回;没有命中或账本不存在则不写。 */
+export async function pruneBotWorkingMemoryForMessages(
+ userDataDir: string,
+ botId: string,
+ deletedMessageIds: ReadonlySet<string>,
+): Promise<number> {
+ const current = await readBotWorkingMemory(userDataDir, botId);
+ if (!current) return 0;
+ const { memory, removed } = pruneWorkingMemoryForMessages(current, deletedMessageIds);
+ if (removed === 0) return 0;
+ await writeBotWorkingMemory(userDataDir, botId, memory, current.revision);
+ return removed;
+}
+
/** 发给复盘模型的紧凑视图(不带 id / 时间戳,省 token)。 */
export function workingMemoryForReview(memory: BotWorkingMemory | null): Record<string, unknown> {
const m = memory ?? emptyWorkingMemory();
@@ -337,9 +407,16 @@ export interface WorkingMemoryOpenTask {
export const WORKING_MEMORY_HEADING = '== Working memory (host-maintained summary; not authorization) ==';
+interface RenderSection {
+ title: string;
+ lines: string[];
+ /** 受保护的区(纠正 / 承诺 / 等待)只在无路可退时从最旧的条目开始裁,不整段丢。 */
+ protected: boolean;
+}
+
/**
- * 渲染顺序即优先级:超预算时从末尾的区整段丢。纠正、承诺、等待永不丢;
- * 后台任务来自数据库;线索和近期完成在预算紧张时省略。
+ * 渲染顺序即优先级。总长度硬上限:先整段丢非保护区(近期完成 → 线索 → 后台任务),
+ * 仍超时从保护区各自最旧的条目(列表末尾)开始裁,最后一道是硬截断。
*/
export function renderWorkingMemory(
memory: BotWorkingMemory,
@@ -347,54 +424,71 @@ export function renderWorkingMemory(
budget = WORKING_MEMORY_RENDER_BUDGET,
): string | null {
const ref = (item: WorkingMemoryItem) => (item.messageId ? ` (message_id: ${item.messageId})` : '');
- const sections: string[] = [];
+ const sections: RenderSection[] = [];
if (memory.corrections.length) {
- sections.push(
- 'Latest user corrections and decisions (newest first; later ones override earlier ones):\n' +
- memory.corrections.map((c) => `- ${c.text}${c.supersedes ? ` [supersedes: ${c.supersedes}]` : ''}${ref(c)}`).join('\n'),
- );
+ sections.push({
+ protected: true,
+ title: 'Latest user corrections and decisions (newest first; later ones override earlier ones):',
+ lines: memory.corrections.map((c) => `- ${c.text}${c.supersedes ? ` [supersedes: ${c.supersedes}]` : ''}${ref(c)}`),
+ });
}
if (memory.commitments.length) {
- sections.push(
- 'Things you promised and have not yet delivered:\n' +
- memory.commitments.map((c) => `- ${c.text}${c.trigger ? ` [when: ${c.trigger}]` : ''}${ref(c)}`).join('\n'),
- );
+ sections.push({
+ protected: true,
+ title: 'Things you promised and have not yet delivered:',
+ lines: memory.commitments.map((c) => `- ${c.text}${c.trigger ? ` [when: ${c.trigger}]` : ''}${ref(c)}`),
+ });
}
if (memory.waiting.length) {
- sections.push(
- 'Waiting on:\n' + memory.waiting.map((w) => `- ${w.on === 'user' ? 'user' : 'external'}: ${w.text}${ref(w)}`).join('\n'),
- );
+ sections.push({
+ protected: true,
+ title: 'Waiting on:',
+ lines: memory.waiting.map((w) => `- ${w.on === 'user' ? 'user' : 'external'}: ${w.text}${ref(w)}`),
+ });
}
const openTasks = extras.openTasks ?? [];
if (openTasks.length) {
- sections.push(
- 'Background tasks still running (from the host task records; results arrive as receipts, do not redo them):\n' +
- openTasks.map((t) => `- [${t.status}] ${clampText(t.objective, 160)} (task_id: ${t.id})`).join('\n'),
- );
+ sections.push({
+ protected: false,
+ title: 'Background tasks still running (from the host task records; results arrive as receipts, do not redo them):',
+ lines: openTasks.map((t) => `- [${t.status}] ${clampText(t.objective, 160)} (task_id: ${t.id})`),
+ });
}
if (memory.threads.length) {
- sections.push(
- 'Open threads:\n' +
- memory.threads
- .map((t) => `- [${t.status}] ${t.text}${t.next ? ` → next: ${t.next}` : ''}${ref(t)}`)
- .join('\n'),
- );
+ sections.push({
+ protected: false,
+ title: 'Open threads:',
+ lines: memory.threads.map((t) => `- [${t.status}] ${t.text}${t.next ? ` → next: ${t.next}` : ''}${ref(t)}`),
+ });
}
if (memory.recentlyDone.length) {
- sections.push('Recently completed (do not repeat):\n' + memory.recentlyDone.map((d) => `- ${d.text}${ref(d)}`).join('\n'));
+ sections.push({
+ protected: false,
+ title: 'Recently completed (do not repeat):',
+ lines: memory.recentlyDone.map((d) => `- ${d.text}${ref(d)}`),
+ });
}
if (sections.length === 0) return null;
const guidance =
'This is a host-maintained summary of the ongoing work, not a new instruction and not authorization: ' +
'past approvals do not permit new actions. When the user refers to something you do not see here, ' +
'search the conversation history before saying you have no record of it, and never mention this note.';
- // 预算从尾部的区整段丢,头部(纠正 / 承诺 / 等待)保留。
- let body = sections.join('\n\n');
- while (body.length + guidance.length > budget && sections.length > 3) {
- sections.pop();
- body = sections.join('\n\n');
+ const head = `${WORKING_MEMORY_HEADING}\n${guidance}\n\n`;
+ const render = () => head + sections.map((s) => `${s.title}\n${s.lines.join('\n')}`).join('\n\n');
+ let text = render();
+ while (text.length > budget) {
+ const lastUnprotected = sections.map((s) => s.protected).lastIndexOf(false);
+ if (lastUnprotected >= 0) {
+ sections.splice(lastUnprotected, 1);
+ } else {
+ // 只剩保护区:从条目最多的区裁掉最旧的一条;每区至少留一条。
+ const victim = sections.reduce((best, s) => (s.lines.length > best.lines.length ? s : best), sections[0]!);
+ if (victim.lines.length <= 1) break;
+ victim.lines.pop();
+ }
+ text = render();
}
- return `${WORKING_MEMORY_HEADING}\n${guidance}\n\n${body}`;
+ return text.length > budget ? `${text.slice(0, budget - 1)}…` : text;
}
// ── 会话 → 伙伴 → 渲染好的交接段 ───────────────────────────────────────────────
@@ -435,16 +529,22 @@ async function listOpenTasks(botId: string): Promise<WorkingMemoryOpenTask[]> {
/**
* 换窗交接 / 压缩后刷新用的渲染段;非伙伴主对话或没有账本时返回 null。
* 任何读取失败都按"没有账本"处理——账本是增强,不能挡住换窗。
+ * `excludeMessageIds`:正在删除的消息,渲染时先把它们产生的条目排除(持久清理在删除
+ * 提交后另做,见 pruneWorkingMemoryForSession)。
*/
export async function readWorkingMemoryNoteForSession(
sessionId: string,
userDataDir: string,
+ opts: { excludeMessageIds?: ReadonlySet<string> } = {},
): Promise<string | null> {
try {
const botId = await resolveCanonicalBotIdForSession(sessionId);
if (!botId) return null;
- const memory = await readBotWorkingMemory(userDataDir, botId);
- if (!memory) return null;
+ const stored = await readBotWorkingMemory(userDataDir, botId);
+ if (!stored) return null;
+ const memory = opts.excludeMessageIds
+ ? pruneWorkingMemoryForMessages(stored, opts.excludeMessageIds).memory
+ : stored;
const openTasks = await listOpenTasks(botId).catch(() => []);
return renderWorkingMemory(memory, { openTasks });
} catch {
@@ -452,25 +552,46 @@ export async function readWorkingMemoryNoteForSession(
}
}
+/** 删除消息提交后,持久清掉由这些消息产生的账本条目;失败不抛(下一次复盘可重建)。 */
+export async function pruneWorkingMemoryForSession(
+ sessionId: string,
+ userDataDir: string,
+ deletedMessageIds: ReadonlySet<string>,
+): Promise<void> {
+ try {
+ const botId = await resolveCanonicalBotIdForSession(sessionId);
+ if (botId) await pruneBotWorkingMemoryForMessages(userDataDir, botId, deletedMessageIds);
+ } catch {
+ /* 账本是增强;清理失败不影响删除本身。 */
+ }
+}
+
// ── 原生压缩后的一次性刷新 ─────────────────────────────────────────────────────
/**
* 原生自动压缩边界之后,下一次发送前置一次账本:宿主拿不到原生摘要,不知道它丢了什么,
* 只能用账本兜住。交接首条(pending handoff)已含账本时不重复。
+ *
+ * 标记带代次:发送在途时(Pi 的受理本身可能等压缩)又来一次 compact_boundary,
+ * accepted 后只消费构造本次说明时读到的那一代,新一代留给下一次发送。
*/
export interface WorkingMemoryRefreshRegistry {
markCompacted(sessionId: string): void;
- isPending(sessionId: string): boolean;
- /** 引擎接受发送后调用;未接受保留,下次重试。 */
- consume(sessionId: string): void;
+ /** 当前待刷新代次;没有待刷新返回 null。 */
+ pendingGeneration(sessionId: string): number | null;
+ /** 引擎接受发送后调用;只有代次仍是当时读到的那一代才清除。 */
+ consume(sessionId: string, generation: number): void;
}
export function createWorkingMemoryRefreshRegistry(): WorkingMemoryRefreshRegistry {
- const pending = new Set<string>();
+ const pending = new Map<string, number>();
+ let generation = 0;
return {
- markCompacted: (sessionId) => void pending.add(sessionId),
- isPending: (sessionId) => pending.has(sessionId),
- consume: (sessionId) => void pending.delete(sessionId),
+ markCompacted: (sessionId) => void pending.set(sessionId, (generation += 1)),
+ pendingGeneration: (sessionId) => pending.get(sessionId) ?? null,
+ consume: (sessionId, gen) => {
+ if (pending.get(sessionId) === gen) pending.delete(sessionId);
+ },
};
}
diff --git a/apps/desktop/src/main/maker-ipc/makerSendTransaction.ts b/apps/desktop/src/main/maker-ipc/makerSendTransaction.ts
index e979cab0d7..496a7c11c7 100644
--- a/apps/desktop/src/main/maker-ipc/makerSendTransaction.ts
+++ b/apps/desktop/src/main/maker-ipc/makerSendTransaction.ts
@@ -510,10 +510,12 @@ export interface MakerSendTransactionDeps {
consumeWorkingDirectoryRecoveryNote?(sessionId: string, note: string): void;
/**
* 伙伴工作记忆刷新(botWorkingMemory):原生自动压缩之后的下一次发送前置一次账本,
- * 只进 wire payload;交接首条(pending handoff)已含账本时不重复。accepted 后 consume。
+ * 只进 wire payload;交接首条(pending handoff)已含账本时不重复。
+ * 返回 null = 没有待刷新;`note` 为 null = 有标记但该会话没有账本(仍要消费)。
+ * accepted 后只消费当时读到的 `generation`:发送在途时再来一次压缩边界,新一代留给下次。
*/
- peekWorkingMemoryRefreshNote?(sessionId: string): Promise<string | null>;
- consumeWorkingMemoryRefreshNote?(sessionId: string): void;
+ peekWorkingMemoryRefresh?(sessionId: string): Promise<{ generation: number; note: string | null } | null>;
+ consumeWorkingMemoryRefresh?(sessionId: string, generation: number): void;
/**
* 计划对账:会话里若有待处理计划,返回一段只进 wire payload 的指示文本。
* sealedTurnId 只用于已完成计划的一次性保护,跨过 accepted 后才消费。
@@ -1224,11 +1226,11 @@ export function createMakerSendTransaction(deps: MakerSendTransactionDeps): Make
? prependNoteToWireUserMessage(normalized as HandoffWireMessage, workdirRecoveryNote)
: normalized;
const pendingHandoff = (await deps.peekPendingHandoff?.(sessionId)) ?? null;
- // 原生压缩后的账本刷新:交接首条已含账本时不重复(但同样在 accepted 后消费)。
- const workingMemoryRefreshNote =
- !pendingHandoff && shouldPrependMobileClientPromptNote(normalized, sess.agentKind)
- ? ((await deps.peekWorkingMemoryRefreshNote?.(sessionId).catch(() => null)) ?? null)
- : null;
+ // 原生压缩后的账本刷新:交接首条已含账本时不重复(但同样在 accepted 后消费当时那一代)。
+ const workingMemoryRefresh = shouldPrependMobileClientPromptNote(normalized, sess.agentKind)
+ ? ((await deps.peekWorkingMemoryRefresh?.(sessionId).catch(() => null)) ?? null)
+ : null;
+ const workingMemoryRefreshNote = !pendingHandoff ? workingMemoryRefresh?.note ?? null : null;
const withWorkingMemoryRefresh = workingMemoryRefreshNote
? prependNoteToWireUserMessage(withRecoveryNote as HandoffWireMessage, workingMemoryRefreshNote)
: withRecoveryNote;
@@ -1758,9 +1760,10 @@ export function createMakerSendTransaction(deps: MakerSendTransactionDeps): Make
if (workdirRecoveryNote && sendResult.accepted) {
deps.consumeWorkingDirectoryRecoveryNote?.(sessionId, workdirRecoveryNote);
}
- // 交接首条已经带了账本;刷新标记一并消费,避免下一轮再补一份。
- if ((workingMemoryRefreshNote || pendingHandoff) && sendResult.accepted) {
- deps.consumeWorkingMemoryRefreshNote?.(sessionId);
+ // 只消费构造本次说明时读到的那一代;交接首条已带账本时同样消费。发送期间新来的
+ // 压缩边界代次不同,留给下一次发送。
+ if (workingMemoryRefresh && sendResult.accepted) {
+ deps.consumeWorkingMemoryRefresh?.(sessionId, workingMemoryRefresh.generation);
}
if (planReconcile?.sealedTurnId && sendResult.accepted) {
try {
diff --git a/apps/desktop/src/main/maker-ipc/messageDeleteHandler.ts b/apps/desktop/src/main/maker-ipc/messageDeleteHandler.ts
index 6e124b088a..17c58f0168 100644
--- a/apps/desktop/src/main/maker-ipc/messageDeleteHandler.ts
+++ b/apps/desktop/src/main/maker-ipc/messageDeleteHandler.ts
@@ -46,8 +46,13 @@ export interface MessageDeleteHandlerDeps {
clientId: string,
): Promise<MessageDeletionTarget | null>;
listMessagesForContext(sessionId: string): Promise<ContextSourceMessage[]>;
- /** 伙伴工作记忆账本渲染段(botWorkingMemory);删除消息后的重建交接同样带上。 */
- readWorkingMemoryNote?(sessionId: string): Promise<string | null>;
+ /**
+ * 伙伴工作记忆账本渲染段(botWorkingMemory);删除消息后的重建交接同样带上,
+ * 但由待删消息产生的条目必须先排除,否则被删轮次的承诺 / 纠正会借交接回到新上下文。
+ */
+ readWorkingMemoryNote?(sessionId: string, opts: { excludeMessageIds: ReadonlySet<string> }): Promise<string | null>;
+ /** 删除提交后持久清掉由这些消息产生的账本条目;失败不影响删除。 */
+ pruneWorkingMemory?(sessionId: string, deletedMessageIds: ReadonlySet<string>): Promise<void>;
getLiveSession(sessionId: string): { isTurnRunning(): boolean } | null | undefined;
hasBackgroundActivity(sessionId: string): boolean;
closeSession(sessionId: string): Promise<void>;
@@ -140,7 +145,7 @@ export async function performMessageDeletion(
toLabel: label,
sessionId,
reason: 'message-deletion',
- workingMemory: (await deps.readWorkingMemoryNote?.(sessionId)) ?? null,
+ workingMemory: (await deps.readWorkingMemoryNote?.(sessionId, { excludeMessageIds: deletedClientIds })) ?? null,
});
const committed = await deps.commitDeletion(
@@ -150,6 +155,8 @@ export async function performMessageDeletion(
target.subagentTurnWindow,
);
deps.setPendingHandoff(sessionId, handoff, handoffGeneration);
+ // 持久账本在删除提交后再清:提交失败时账本不动,交接文本已经排除过这些条目。
+ await deps.pruneWorkingMemory?.(sessionId, new Set(committed.deletedClientIds));
await deps.onCommitted(committed, clientId);
deps.log.info('message delete committed; native context will rebuild on next send', {
sessionId,
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index a77990df75..3fe266032a 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -598,6 +598,7 @@ import {
import {
buildWorkingMemoryRefreshNote,
createWorkingMemoryRefreshRegistry,
+ pruneWorkingMemoryForSession,
readWorkingMemoryNoteForSession,
} from './botWorkingMemory.js';
import { isBotCanonicalReplacementBusy } from './botCanonicalReplacementGuard.js';
@@ -10233,7 +10234,10 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
},
getMessage: getMessageDeletionTarget,
listMessagesForContext: (sessionId) => listMessagesForAgentHandoff(sessionId, 400),
- readWorkingMemoryNote,
+ readWorkingMemoryNote: (sessionId, opts) =>
+ readWorkingMemoryNoteForSession(sessionId, ownerScopedUserDataPath(), opts),
+ pruneWorkingMemory: (sessionId, deletedMessageIds) =>
+ pruneWorkingMemoryForSession(sessionId, ownerScopedUserDataPath(), deletedMessageIds),
getLiveSession: (sessionId) => maker.getSession(sessionId),
hasBackgroundActivity: getClaudeSessionBackgroundActivity,
closeSession: (sessionId) => maker.closeSession(sessionId),
@@ -16169,17 +16173,15 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
// 调用方自报;与手机说明同层(只进 wire 消息)。
isCindyMakeSession: async (sessionId) =>
(await readSessionSource(sessionId)) === CINDY_MAKE_SESSION_SOURCE,
- // 原生压缩后的账本刷新:只对伙伴主对话且有账本的会话真正注入;读不到按无。
- peekWorkingMemoryRefreshNote: async (sessionId) => {
- if (!workingMemoryRefresh.isPending(sessionId)) return null;
+ // 原生压缩后的账本刷新:只对伙伴主对话且有账本的会话真正注入;读不到按无账本,
+ // 标记仍由事务在 accepted 后按代次消费。
+ peekWorkingMemoryRefresh: async (sessionId) => {
+ const generation = workingMemoryRefresh.pendingGeneration(sessionId);
+ if (generation === null) return null;
const rendered = await readWorkingMemoryNote(sessionId);
- if (!rendered) {
- workingMemoryRefresh.consume(sessionId);
- return null;
- }
- return buildWorkingMemoryRefreshNote(rendered);
+ return { generation, note: rendered ? buildWorkingMemoryRefreshNote(rendered) : null };
},
- consumeWorkingMemoryRefreshNote: (sessionId) => workingMemoryRefresh.consume(sessionId),
+ consumeWorkingMemoryRefresh: (sessionId, generation) => workingMemoryRefresh.consume(sessionId, generation),
applyPendingAgentSwitch: async (sessionId, options) => {
await applyPendingAgentSwitchIfIdle(agentSwitchDeps, sessionId);
// 已归组的任务所在那台现在不能用时,先换到组里下一台再发(失败不影响这次发送);离线时先等它恢复,