kaijibot 2026.8.21 → 2026.8.23

package/README.en.md

@@ -52,7 +52,7 @@ Five core mechanisms:
 
 - **Persona Profiling** — Every conversation teaches it something new. LLM-driven structured extraction automatically discovers domains and interests from conversations. Insights decay by category independently (`tool_config` 7d / `domain_knowledge` 30d / `behavioral_pattern` 90d...). Interest lifecycle is tracked automatically (emergent→stable→declining→dormant→revived). Domain names discovered dynamically by LLM — no hardcoded keywords.
 - **Cross-Domain Insights** — You're interested in both A and B, it finds potential connections. You asked about something before but didn't dig deeper, it follows up from a new angle. You've gone deep enough in one area, it suggests extension directions. LLM self-refine loop (critique→rewrite, up to 3 rounds) ensures quality, semantic dedup ensures every push is fresh.
-- **Timing Gate** — It doesn't push whenever it feels like it. The PRISM model calculates expected value for each insight. Only pushes when expected benefit exceeds interruption cost. No late-night interruptions, restraint during low trust, waits if you've been inactive.
+- **Timing Gate** — It doesn't push whenever it feels like it. The PRISM model calculates expected value for each insight. Only pushes when expected benefit exceeds interruption cost. No late-night interruptions, restraint during low trust, waits if you've been inactive. Daily self-restraint (1-2 by default) plus randomized, non-scheduled pacing — like a friend sharing, not a cron job. Ignored messages make it naturally back off; any reply brings it right back.
 - **Trust Evolution** — Cautious at first, understands you better over time, eventually becomes a confident partner who can make bold recommendations. SARA framework drives four-stage trust evolution. Trust level determines what the system is allowed to do.
 - **Preference Learning** — You wrote a long reply? It notes you like this topic. You gave a one-word response? It tries a different direction next time. Thompson Sampling-driven preference learning. Implicit feedback is more honest than explicit feedback.
 

package/README.md

@@ -52,7 +52,7 @@ flowchart LR
 
 - **Persona 画像** — 每次对话都在学习你。LLM 驱动的结构化提取,从对话中自动发现领域和兴趣。洞察按类别独立衰减(`tool_config` 7天 / `domain_knowledge` 30天 / `behavioral_pattern` 90天...),兴趣生命周期自动追踪(emergent→stable→declining→dormant→revived)。领域由 LLM 动态发现,不依赖硬编码关键词。
 - **跨域洞察** — 你同时关注 A 和 B,它发现二者有潜在联系。你之前问过但没深入的问题,它从新角度跟进。你在某个领域钻得够深了,它推荐延伸方向。LLM 自我精炼(critique→rewrite,最多 3 轮)保证质量,语义去重确保每次推送都有新意。
-- **时机门控** — 不是想发就发。PRISM 模型计算每条洞察的期望价值,只有预期收益超过打扰成本时才推送。凌晨不打扰,信任度低时克制,你最近活跃度低就先等等。
+- **时机门控** — 不是想发就发。PRISM 模型计算每条洞察的期望价值,只有预期收益超过打扰成本时才推送。凌晨不打扰,信任度低时克制,你最近活跃度低就先等等。每日自持上限(默认 1-2 条)+ 不固定间隔的随机投放节奏,像朋友分享而不是定时任务;不回复会自然收敛,你一开口立刻恢复。
 - **信任演化** — 刚认识时谨慎试探,聊多了越来越懂你,最终变成可以大胆推荐的深度伙伴。SARA 框架驱动四个阶段的信任演化,信任等级决定系统被允许做什么。
 - **偏好学习** — 你回复长了、追问了"为什么",它记下你喜欢这个话题。你敷衍了,它下次换一个方向。Thompson Sampling 驱动的偏好学习,隐式反馈比显式反馈更诚实。
 

package/dist/.buildstamp

@@ -1 +1 @@
-{"builtAt":1787303703851,"head":"a1c6efc845f222731bace35718c2c318327a7c1d"}
+{"builtAt":1787479249491,"head":"26351116b5c5bfbff54ea351f30d52969f76f8df"}

package/dist/abort-Bg5O8Yiz.js

@@ -0,0 +1,202 @@
+import { o as normalizeOptionalLowercaseString, s as normalizeOptionalString } from "./string-coerce-xZwG7Dq8.js";
+import { r as formatErrorMessage } from "./errors-Ez4cKI2Y.js";
+import { s as parseAgentSessionKey } from "./session-key-utils-DEfwsZM6.js";
+import { v as resolveSessionAgentId } from "./agent-scope-z3lpbLWu.js";
+import { r as logVerbose } from "./globals-CwigADVM.js";
+import { a as resolveSessionStoreEntry, c as updateSessionStore } from "./store-BCDEVRXR.js";
+import "./sessions-BxOkBx-e.js";
+import { l as resolveStorePath } from "./paths-DrQr2my6.js";
+import { t as loadSessionStore } from "./store-load-5DAj5ABj.js";
+import { o as getLatestSubagentRunByChildSessionKey, p as markSubagentRunTerminated, u as listSubagentRunsForController } from "./subagent-registry-DfHx9pew.js";
+import { b as resolveMainSessionAlias, y as resolveInternalSessionKey } from "./subagents-format-DXuyOMu-.js";
+import { i as clearSessionQueues } from "./queue-fniCZ6ND.js";
+import { h as replyRunRegistry, t as abortEmbeddedPiRun } from "./runs-Djzm6zWd.js";
+import { n as getAcpSessionManager } from "./manager-CWqmCOrL.js";
+import "./pi-embedded-BycqI-F6.js";
+import { i as setAbortMemory, n as isAbortRequestText } from "./abort-primitives-DqU6syXA.js";
+import { o as stripMentions, s as stripStructuralPrefixes } from "./mentions-DLP3Al9F.js";
+import { t as resolveCommandAuthorization } from "./command-auth-xvVjuKSW.js";
+import { a as shouldPersistAbortCutoff, i as resolveAbortCutoffFromContext, t as applyAbortCutoffToSessionEntry } from "./abort-cutoff-BptR8dUG.js";
+const abortDeps = {
+	getAcpSessionManager,
+	abortEmbeddedPiRun,
+	getLatestSubagentRunByChildSessionKey,
+	listSubagentRunsForController,
+	markSubagentRunTerminated
+};
+function formatAbortReplyText(stoppedSubagents) {
+	if (typeof stoppedSubagents !== "number" || stoppedSubagents <= 0) return "⚙️ Agent was aborted.";
+	return `⚙️ Agent was aborted. Stopped ${stoppedSubagents} ${stoppedSubagents === 1 ? "sub-agent" : "sub-agents"}.`;
+}
+function resolveSessionEntryForKey(store, sessionKey) {
+	if (!store || !sessionKey) return {};
+	const resolved = resolveSessionStoreEntry({
+		store,
+		sessionKey
+	});
+	if (resolved.existing) return resolved.legacyKeys.length > 0 ? {
+		entry: resolved.existing,
+		key: resolved.normalizedKey,
+		legacyKeys: resolved.legacyKeys
+	} : {
+		entry: resolved.existing,
+		key: resolved.normalizedKey
+	};
+	return {};
+}
+function normalizeRequesterSessionKey(cfg, key) {
+	const cleaned = normalizeOptionalString(key);
+	if (!cleaned) return;
+	const { mainKey, alias } = resolveMainSessionAlias(cfg);
+	return resolveInternalSessionKey({
+		key: cleaned,
+		alias,
+		mainKey
+	});
+}
+function stopSubagentsForRequester(params) {
+	const requesterKey = normalizeRequesterSessionKey(params.cfg, params.requesterSessionKey);
+	if (!requesterKey) return { stopped: 0 };
+	const dedupedRunsByChildKey = /* @__PURE__ */ new Map();
+	for (const run of abortDeps.listSubagentRunsForController(requesterKey)) {
+		const childKey = normalizeOptionalString(run.childSessionKey);
+		if (!childKey) continue;
+		const latest = abortDeps.getLatestSubagentRunByChildSessionKey(childKey);
+		if (!latest) {
+			const existing = dedupedRunsByChildKey.get(childKey);
+			if (!existing || run.createdAt >= existing.createdAt) dedupedRunsByChildKey.set(childKey, run);
+			continue;
+		}
+		const latestControllerSessionKey = normalizeOptionalString(latest?.controllerSessionKey) ?? normalizeOptionalString(latest?.requesterSessionKey);
+		if (latest.runId !== run.runId || latestControllerSessionKey !== requesterKey) continue;
+		const existing = dedupedRunsByChildKey.get(childKey);
+		if (!existing || run.createdAt >= existing.createdAt) dedupedRunsByChildKey.set(childKey, run);
+	}
+	const runs = Array.from(dedupedRunsByChildKey.values());
+	if (runs.length === 0) return { stopped: 0 };
+	const storeCache = /* @__PURE__ */ new Map();
+	const seenChildKeys = /* @__PURE__ */ new Set();
+	let stopped = 0;
+	for (const run of runs) {
+		const childKey = normalizeOptionalString(run.childSessionKey);
+		if (!childKey || seenChildKeys.has(childKey)) continue;
+		seenChildKeys.add(childKey);
+		if (!run.endedAt) {
+			const cleared = clearSessionQueues([childKey]);
+			const parsed = parseAgentSessionKey(childKey);
+			const storePath = resolveStorePath(params.cfg.session?.store, { agentId: parsed?.agentId });
+			let store = storeCache.get(storePath);
+			if (!store) {
+				store = loadSessionStore(storePath);
+				storeCache.set(storePath, store);
+			}
+			const entry = store[childKey];
+			const sessionId = replyRunRegistry.resolveSessionId(childKey) ?? entry?.sessionId;
+			const aborted = (childKey ? replyRunRegistry.abort(childKey) : false) || (sessionId ? abortDeps.abortEmbeddedPiRun(sessionId) : false);
+			if (abortDeps.markSubagentRunTerminated({
+				runId: run.runId,
+				childSessionKey: childKey,
+				reason: "killed"
+			}) > 0 || aborted || cleared.followupCleared > 0 || cleared.laneCleared > 0) stopped += 1;
+		}
+		const cascadeResult = stopSubagentsForRequester({
+			cfg: params.cfg,
+			requesterSessionKey: childKey
+		});
+		stopped += cascadeResult.stopped;
+	}
+	if (stopped > 0) logVerbose(`abort: stopped ${stopped} subagent run(s) for ${requesterKey}`);
+	return { stopped };
+}
+async function tryFastAbortFromMessage(params) {
+	const { ctx, cfg } = params;
+	const targetKey = normalizeOptionalString(ctx.CommandTargetSessionKey) ?? normalizeOptionalString(ctx.SessionKey);
+	const raw = stripStructuralPrefixes(ctx.CommandBody ?? ctx.RawBody ?? ctx.Body ?? "");
+	if (!isAbortRequestText(normalizeOptionalLowercaseString(ctx.ChatType) === "group" ? stripMentions(raw, ctx, cfg, resolveSessionAgentId({
+		sessionKey: targetKey ?? ctx.SessionKey ?? "",
+		config: cfg
+	})) : raw)) return {
+		handled: false,
+		aborted: false
+	};
+	const commandAuthorized = ctx.CommandAuthorized;
+	const auth = resolveCommandAuthorization({
+		ctx,
+		cfg,
+		commandAuthorized
+	});
+	if (!auth.isAuthorizedSender) return {
+		handled: false,
+		aborted: false
+	};
+	const agentId = resolveSessionAgentId({
+		sessionKey: targetKey ?? ctx.SessionKey ?? "",
+		config: cfg
+	});
+	const abortKey = targetKey ?? auth.from ?? auth.to;
+	const requesterSessionKey = targetKey ?? ctx.SessionKey ?? abortKey;
+	if (targetKey) {
+		const storePath = resolveStorePath(cfg.session?.store, { agentId });
+		const store = loadSessionStore(storePath);
+		const { entry, key, legacyKeys } = resolveSessionEntryForKey(store, targetKey);
+		const resolvedTargetKey = key ?? targetKey;
+		const acpManager = abortDeps.getAcpSessionManager();
+		if (acpManager.resolveSession({
+			cfg,
+			sessionKey: resolvedTargetKey
+		}).kind !== "none") try {
+			await acpManager.cancelSession({
+				cfg,
+				sessionKey: resolvedTargetKey,
+				reason: "fast-abort"
+			});
+		} catch (error) {
+			logVerbose(`abort: ACP cancel failed for ${resolvedTargetKey}: ${formatErrorMessage(error)}`);
+		}
+		const sessionId = replyRunRegistry.resolveSessionId(resolvedTargetKey) ?? entry?.sessionId;
+		const aborted = replyRunRegistry.abort(resolvedTargetKey) || (sessionId ? abortDeps.abortEmbeddedPiRun(sessionId) : false);
+		const cleared = clearSessionQueues([resolvedTargetKey, sessionId]);
+		if (cleared.followupCleared > 0 || cleared.laneCleared > 0) logVerbose(`abort: cleared followups=${cleared.followupCleared} lane=${cleared.laneCleared} keys=${cleared.keys.join(",")}`);
+		const abortCutoff = shouldPersistAbortCutoff({
+			commandSessionKey: ctx.SessionKey,
+			targetSessionKey: resolvedTargetKey
+		}) ? resolveAbortCutoffFromContext(ctx) : void 0;
+		if (entry && key) {
+			entry.abortedLastRun = true;
+			applyAbortCutoffToSessionEntry(entry, abortCutoff);
+			entry.updatedAt = Date.now();
+			store[key] = entry;
+			for (const legacyKey of legacyKeys ?? []) if (legacyKey !== key) delete store[legacyKey];
+			await updateSessionStore(storePath, (nextStore) => {
+				const nextEntry = nextStore[key] ?? entry;
+				if (!nextEntry) return;
+				nextEntry.abortedLastRun = true;
+				applyAbortCutoffToSessionEntry(nextEntry, abortCutoff);
+				nextEntry.updatedAt = Date.now();
+				nextStore[key] = nextEntry;
+				for (const legacyKey of legacyKeys ?? []) if (legacyKey !== key) delete nextStore[legacyKey];
+			});
+		} else if (abortKey) setAbortMemory(abortKey, true);
+		const { stopped } = stopSubagentsForRequester({
+			cfg,
+			requesterSessionKey
+		});
+		return {
+			handled: true,
+			aborted,
+			stoppedSubagents: stopped
+		};
+	}
+	if (abortKey) setAbortMemory(abortKey, true);
+	const { stopped } = stopSubagentsForRequester({
+		cfg,
+		requesterSessionKey
+	});
+	return {
+		handled: true,
+		aborted: false,
+		stoppedSubagents: stopped
+	};
+}
+//#endregion
+export { tryFastAbortFromMessage as i, resolveSessionEntryForKey as n, stopSubagentsForRequester as r, formatAbortReplyText as t };

package/dist/abort-cutoff.runtime-CvjKPRCc.js

@@ -0,0 +1,20 @@
+import { c as updateSessionStore } from "./store-BCDEVRXR.js";
+import { n as hasAbortCutoff, t as applyAbortCutoffToSessionEntry } from "./abort-cutoff-BptR8dUG.js";
+//#region src/auto-reply/reply/abort-cutoff.runtime.ts
+async function clearAbortCutoffInSessionRuntime(params) {
+	const { sessionEntry, sessionStore, sessionKey, storePath } = params;
+	if (!sessionEntry || !sessionStore || !sessionKey || !hasAbortCutoff(sessionEntry)) return false;
+	applyAbortCutoffToSessionEntry(sessionEntry, void 0);
+	sessionEntry.updatedAt = Date.now();
+	sessionStore[sessionKey] = sessionEntry;
+	if (storePath) await updateSessionStore(storePath, (store) => {
+		const existing = store[sessionKey] ?? sessionEntry;
+		if (!existing) return;
+		applyAbortCutoffToSessionEntry(existing, void 0);
+		existing.updatedAt = Date.now();
+		store[sessionKey] = existing;
+	});
+	return true;
+}
+//#endregion
+export { clearAbortCutoffInSessionRuntime };

package/dist/abort-cutoff.runtime.js

@@ -1 +1 @@
-export * from "./abort-cutoff.runtime-140Dy9Z_.js";
+export * from "./abort-cutoff.runtime-CvjKPRCc.js";

package/dist/abort.runtime-UZvtDM6M.js

@@ -0,0 +1,2 @@
+import { i as tryFastAbortFromMessage, t as formatAbortReplyText } from "./abort-Bg5O8Yiz.js";
+export { formatAbortReplyText, tryFastAbortFromMessage };

package/dist/abort.runtime.js

@@ -1 +1 @@
-export * from "./abort.runtime-D2xd_Jxq.js";
+export * from "./abort.runtime-UZvtDM6M.js";