@ftai/dsh-plugin-acn 0.0.0-stage → 0.1.1

package/lib/session-binding-zCSuizHs.js

@@ -0,0 +1,342 @@
+import { c as AgentIdSchema } from "./claim-DOAGe8ZK.js";
+import { n as agentHomePath } from "./paths-B7NI9Ano.js";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import { appendPluginRecord, pluginRecordOf } from "@deepseek-ai/dsh-session";
+//#region src/config.ts
+const positive = () => z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const nonnegative = () => z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const endpoint = z.string().refine((value) => {
+	if (value === "") return true;
+	try {
+		const url = new URL(value);
+		return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password && !url.search && !url.hash;
+	} catch {
+		return false;
+	}
+});
+const UpstreamNameSchema = z.string().regex(/^[a-z0-9_-]+$/).refine((value) => ![
+	"data",
+	"skills",
+	"config.toml",
+	"acn.md",
+	"logs",
+	"tmp",
+	".git"
+].includes(value));
+const UpstreamSchema = z.strictObject({
+	name: z.string().trim().max(80).default(""),
+	agentId: AgentIdSchema,
+	enabled: z.boolean().default(true),
+	routerEndpoint: endpoint.default(""),
+	maintainerEndpoint: endpoint.default(""),
+	keyEnv: z.string().regex(/^(?:[A-Za-z_][A-Za-z0-9_]*)?$/).default(""),
+	timeoutMs: positive().default(15e3)
+}).superRefine((value, ctx) => {
+	if (Boolean(value.routerEndpoint) !== Boolean(value.maintainerEndpoint)) ctx.addIssue({
+		code: "custom",
+		path: ["routerEndpoint"],
+		message: "Configure both team endpoints or neither."
+	});
+});
+const ConnectionSchema = z.strictObject({
+	id: z.string().regex(/^[a-zA-Z0-9_-]{1,80}$/).refine((id) => !["personal", "legacy"].includes(id)),
+	name: z.string().trim().min(1).max(80),
+	enabled: z.boolean().default(true),
+	agentId: AgentIdSchema,
+	routerEndpoint: endpoint.refine(Boolean),
+	maintainerEndpoint: endpoint.refine(Boolean),
+	keyEnv: z.string().regex(/^(?:[A-Za-z_][A-Za-z0-9_]*)?$/).default(""),
+	timeoutMs: positive().default(15e3)
+});
+const ConfigSchema = z.strictObject({
+	upstream: z.string().default(""),
+	upstreams: z.record(UpstreamNameSchema, UpstreamSchema).optional(),
+	agentId: z.union([z.literal(""), AgentIdSchema]).default(""),
+	home: z.string().trim().min(1).default("~/.acn-dsh"),
+	sessionEpoch: nonnegative().default(0),
+	connections: z.array(ConnectionSchema).max(50).default([]),
+	defaultConnection: z.string().default(""),
+	legacyEnabled: z.boolean().default(true),
+	showCompletion: z.boolean().default(true),
+	team: z.strictObject({
+		routerEndpoint: endpoint.default(""),
+		maintainerEndpoint: endpoint.default(""),
+		keyEnv: z.string().regex(/^(?:[A-Za-z_][A-Za-z0-9_]*)?$/).default(""),
+		timeoutMs: positive().default(15e3),
+		routerTimeoutMs: positive().default(5e4),
+		retryCount: nonnegative().default(3),
+		retryBaseDelayMs: positive().default(500),
+		retryMaxDelayMs: positive().default(8e3)
+	}).prefault({}),
+	llm: z.strictObject({
+		provider: z.string().default(""),
+		model: z.string().default(""),
+		maxOutputTokens: positive().default(32768),
+		timeoutMs: positive().default(6e5),
+		structuredRetries: positive().default(5)
+	}).prefault({}),
+	catalog: z.strictObject({
+		maxClaims: positive().default(20),
+		maxChars: positive().default(24e3)
+	}).prefault({}),
+	formation: z.strictObject({
+		recapOnCompaction: z.boolean().default(true),
+		idleRecap: z.boolean().default(true),
+		recapMinTurns: positive().default(10),
+		recapMinTokens: positive().default(1e5),
+		recapBatchIdleMinutes: positive().default(5),
+		recapTailIdleMinutes: positive().default(60),
+		recapScanSeconds: positive().default(30),
+		finalizeIdleMinutes: nonnegative().default(0),
+		finalizeOnDispose: z.boolean().default(false)
+	}).prefault({}),
+	inbox: z.strictObject({
+		pullOnSessionStart: z.boolean().default(true),
+		processingStaleAfterSecs: positive().default(600)
+	}).prefault({}),
+	dream: z.strictObject({
+		enabled: z.boolean().default(true),
+		minIntervalHours: positive().default(24),
+		minChangedClaims: positive().default(5),
+		checkIntervalHours: positive().default(4),
+		evidenceCalibration: z.boolean().default(false),
+		maxModelSteps: positive().max(128).default(24),
+		maxWrapUpSteps: positive().max(8).default(3),
+		evidenceMaxCalls: positive().max(256).default(32),
+		evidenceMaxSteps: positive().max(128).default(24),
+		evidenceMaxBytes: positive().max(16777216).default(1048576),
+		evidenceMaxChars: positive().max(64e3).default(16e3),
+		evidenceMaxFiles: positive().max(4096).default(256)
+	}).prefault({})
+}).superRefine((config, ctx) => {
+	if (config.upstreams !== void 0) {
+		if (config.upstream !== "" && config.upstreams[config.upstream]?.enabled !== true) ctx.addIssue({
+			code: "custom",
+			path: ["upstream"],
+			message: "Select an enabled upstream."
+		});
+	}
+	if (new Set(config.connections.map((item) => item.id)).size !== config.connections.length) ctx.addIssue({
+		code: "custom",
+		path: ["connections"],
+		message: "Connection identifiers must be unique."
+	});
+	if (config.defaultConnection !== "" && config.defaultConnection !== "legacy" && !config.connections.some((item) => item.id === config.defaultConnection && item.enabled)) ctx.addIssue({
+		code: "custom",
+		path: ["defaultConnection"],
+		message: "Default connection must be enabled."
+	});
+	if (Boolean(config.team.routerEndpoint) !== Boolean(config.team.maintainerEndpoint)) ctx.addIssue({
+		code: "custom",
+		path: ["team"],
+		message: "Configure both team endpoints or neither."
+	});
+	if (Boolean(config.llm.provider.trim()) !== Boolean(config.llm.model.trim())) ctx.addIssue({
+		code: "custom",
+		path: ["llm"],
+		message: "Configure both provider and model or neither."
+	});
+	if (config.team.retryMaxDelayMs < config.team.retryBaseDelayMs) ctx.addIssue({
+		code: "custom",
+		path: ["team", "retryMaxDelayMs"],
+		message: "Maximum retry delay must not be smaller than the base delay."
+	});
+});
+var ConfigError = class extends Error {
+	fields;
+	kind = "config";
+	constructor(fields) {
+		super(`Invalid ACN configuration: ${fields.join(", ")}`);
+		this.fields = fields;
+		this.name = "ConfigError";
+	}
+};
+function resolveConfig(input) {
+	let value = input;
+	if (typeof input === "object" && input !== null && !Array.isArray(input)) {
+		const compatible = { ...input };
+		delete compatible["projectUpstreams"];
+		delete compatible["memory"];
+		value = compatible;
+	}
+	const parsed = ConfigSchema.safeParse(value);
+	if (!parsed.success) throw new ConfigError([...new Set(parsed.error.issues.map((issue) => issue.path.join(".") || "config"))]);
+	return parsed.data;
+}
+function upstreamsOf(config) {
+	if (config.upstreams !== void 0) return config.upstreams;
+	const items = {};
+	if (config.agentId !== "") items["personal"] = UpstreamSchema.parse({
+		name: config.team.routerEndpoint ? "团队" : "个人知识",
+		agentId: config.agentId,
+		enabled: config.legacyEnabled,
+		routerEndpoint: config.team.routerEndpoint,
+		maintainerEndpoint: config.team.maintainerEndpoint,
+		keyEnv: config.team.keyEnv,
+		timeoutMs: config.team.timeoutMs
+	});
+	for (const connection of config.connections) {
+		const { id, ...value } = connection;
+		let key = id.toLowerCase();
+		while (items[key] !== void 0 || [
+			"data",
+			"skills",
+			"logs",
+			"tmp"
+		].includes(key)) key = `${key}_copy`;
+		items[key] = UpstreamSchema.parse(value);
+	}
+	return items;
+}
+function activeUpstream(config) {
+	return config.upstream || "personal";
+}
+//#endregion
+//#region src/dsh-adapter/session-binding.ts
+const BindingSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	identity: z.string().regex(/^[0-9a-f]{64}$/)
+});
+const EligibilitySchema = z.strictObject({ schemaVersion: z.literal(1) });
+const emptyIdentity = createHash("sha256").update("").digest("hex");
+const SelectionSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	key: z.string(),
+	identity: z.string().regex(/^[0-9a-f]{64}$/),
+	prepared: z.boolean().optional()
+});
+const bindings = /* @__PURE__ */ new WeakMap();
+const identityOf = (config) => createHash("sha256").update(config.agentId === "" ? "" : agentHomePath(config.home, config.agentId, activeUpstream(config))).digest("hex");
+const selections = /* @__PURE__ */ new WeakMap();
+const runningConfigurations = /* @__PURE__ */ new WeakMap();
+const activations = /* @__PURE__ */ new WeakMap();
+let activationSequence = 0;
+const configurationActivation = (header) => activations.get(header) ?? 0;
+function runningConfiguration(header) {
+	return runningConfigurations.get(header);
+}
+function rememberConfiguration(header, config) {
+	runningConfigurations.set(header, config);
+	activations.set(header, ++activationSequence);
+}
+function forgetConfiguration(header) {
+	runningConfigurations.delete(header);
+	activations.delete(header);
+}
+function decodeSelection(value) {
+	const parsed = SelectionSchema.safeParse(value);
+	return parsed.success ? parsed.data : {
+		schemaVersion: 1,
+		key: "invalid",
+		identity: "0".repeat(64)
+	};
+}
+function observeSelection(header, event) {
+	const record = pluginRecordOf(event);
+	if (record?.type === "plugin:acn/team-selection") selections.set(header, decodeSelection(record.data));
+}
+function restoreSessionBinding(header, events) {
+	const records = events.map(pluginRecordOf);
+	const values = records.filter((record) => record?.type === "plugin:acn/session-binding").map((record) => BindingSchema.safeParse(record?.data));
+	const first = values[0];
+	bindings.set(header, first?.success && values.every((value) => value.success && value.data.identity === first.data.identity) ? first.data.identity : null);
+	const selected = records.filter((record) => record?.type === "plugin:acn/team-selection").at(-1);
+	selections.set(header, selected === void 0 ? void 0 : decodeSelection(selected.data));
+}
+function sessionSelection(ctx, header) {
+	if (selections.has(header)) return selections.get(header);
+	const last = (ctx.sessions.get(header.id)?.snapshotEvents().map(pluginRecordOf).filter((record) => record?.type === "plugin:acn/team-selection") ?? []).at(-1);
+	const value = last === void 0 ? void 0 : decodeSelection(last.data);
+	selections.set(header, value);
+	return value;
+}
+function sessionHasWork(events) {
+	return events.some((event) => event.type === "request/header" || event.type === "assistant/message" || event.type === "tool/result" || event.type === "turn/start" || event.type === "user/message" && event.data.source.kind === "user");
+}
+function sessionEligible(ctx, header, events = ctx.sessions.get(header.id)?.snapshotEvents()) {
+	return events?.some((event) => {
+		const record = pluginRecordOf(event);
+		return record?.type === "plugin:acn/session-eligibility" && EligibilitySchema.safeParse(record.data).success || record?.type === "plugin:acn/session-binding" && BindingSchema.safeParse(record.data).data?.identity === emptyIdentity;
+	}) ?? false;
+}
+function markSessionEligible(ctx, header) {
+	const session = ctx.sessions.get(header.id);
+	if (session === void 0 || session.firstLiveSeq > 0 || header.isSeeded || header.parentSession !== void 0 || sessionHasWork(session.snapshotEvents()) || sessionEligible(ctx, header)) return;
+	appendPluginRecord(session, "plugin:acn/session-eligibility", { schemaVersion: 1 });
+}
+function sessionUnbound(ctx, header, events) {
+	const seen = /* @__PURE__ */ new Set();
+	let current = header;
+	while (current !== void 0) {
+		if (seen.has(current.id)) return false;
+		seen.add(current.id);
+		const history = current === header && events !== void 0 ? events : ctx.sessions.get(current.id)?.snapshotEvents();
+		if (history === void 0) return current !== header;
+		for (const event of history) {
+			const record = pluginRecordOf(event);
+			if (record?.type === "plugin:acn/team-selection") return false;
+			if (record?.type === "plugin:acn/session-binding" && BindingSchema.safeParse(record.data).data?.identity !== emptyIdentity) return false;
+		}
+		current = current.parentSession === void 0 ? void 0 : ctx.sessions.get(current.parentSession)?.header;
+	}
+	return true;
+}
+function bindSession(ctx, config, header) {
+	if (config.agentId === "") return;
+	if (bindings.has(header)) return;
+	const session = ctx.sessions.get(header.id);
+	if (session === void 0) {
+		bindings.set(header, null);
+		return;
+	}
+	const records = session.snapshotEvents().map(pluginRecordOf).filter((record) => record?.type === "plugin:acn/session-binding");
+	if (records.length > 0) {
+		const values = records.map((record) => BindingSchema.safeParse(record?.data));
+		const first = values[0];
+		bindings.set(header, first?.success && values.every((value) => value.success && value.data.identity === first.data.identity) ? first.data.identity : null);
+		return;
+	}
+	const parent = header.parentSession === void 0 ? void 0 : ctx.sessions.get(header.parentSession);
+	const parentSelection = parent === void 0 ? void 0 : sessionSelection(ctx, parent.header);
+	if (session.firstLiveSeq === 0 && sessionSelection(ctx, header) === void 0 && parentSelection !== void 0) appendPluginRecord(session, "plugin:acn/team-selection", parentSelection);
+	const verifiedParent = parent !== void 0 && sessionAllowed(ctx, config, parent.header);
+	if (session.firstLiveSeq > 0 || !verifiedParent && (!sessionEligible(ctx, header) || sessionHasWork(session.snapshotEvents()) || header.parentSession !== void 0 || header.isSeeded)) {
+		bindings.set(header, null);
+		return;
+	}
+	const identity = identityOf(config);
+	bindings.set(header, identity);
+	try {
+		appendPluginRecord(session, "plugin:acn/session-binding", {
+			schemaVersion: 1,
+			identity
+		});
+	} catch (error) {
+		bindings.set(header, null);
+		throw error;
+	}
+}
+const sessionChanged = "ACN 会话身份与当前配置不一致，或缺少可验证的历史身份记录，请新建会话。旧会话不能访问当前身份的知识。";
+const configurationBusy = "ACN 配置正在应用，请稍后重试。";
+const unboundSession = "本会话未启用 ACN，聊天仍可继续。只有安装插件后新建且尚未发送消息的会话可选择工作配置；如需使用 ACN，请新建会话。";
+function sessionAllowed(ctx, config, header) {
+	if (config.agentId === "") return true;
+	if (config.team.routerEndpoint && !config.legacyEnabled) return false;
+	const identity = identityOf(config);
+	const selected = sessionSelection(ctx, header);
+	if (selected !== void 0) return selected.identity === identity;
+	if (bindings.get(header) !== identity) return false;
+	if (config.sessionEpoch === 0) return true;
+	const seen = /* @__PURE__ */ new Set();
+	let current = header;
+	while (current !== void 0) {
+		if (current.createdAt <= config.sessionEpoch || seen.has(current.id)) return false;
+		seen.add(current.id);
+		if (current.parentSession === void 0) return true;
+		current = ctx.sessions.get(current.parentSession)?.header;
+	}
+	return false;
+}
+//#endregion
+export { resolveConfig as C, activeUpstream as S, unboundSession as _, identityOf as a, UpstreamNameSchema as b, rememberConfiguration as c, sessionAllowed as d, sessionChanged as f, sessionUnbound as g, sessionSelection as h, forgetConfiguration as i, restoreSessionBinding as l, sessionHasWork as m, configurationActivation as n, markSessionEligible as o, sessionEligible as p, configurationBusy as r, observeSelection as s, bindSession as t, runningConfiguration as u, ConfigError as v, upstreamsOf as w, UpstreamSchema as x, ConnectionSchema as y };

package/lib/session-state-CYqUhC95.js

@@ -0,0 +1,38 @@
+import { c as readYamlOr, l as writeYamlAtomic, n as withFileLock } from "./lock-DbmlKOoX.js";
+import { z } from "zod";
+//#region src/store/session-state.ts
+const VersionedDocumentSchema = z.object({ schemaVersion: z.literal(1) }).catchall(z.json());
+var VersionedFileStore = class {
+	context;
+	resolvePath;
+	constructor(context, resolvePath) {
+		this.context = context;
+		this.resolvePath = resolvePath;
+	}
+	read(id) {
+		return readYamlOr(this.resolvePath(id), VersionedDocumentSchema, () => null);
+	}
+	write(id, value) {
+		const path = this.resolvePath(id);
+		return withFileLock(`${path}.lock`, () => writeYamlAtomic(path, value, VersionedDocumentSchema, this.context.logger), { timeoutMs: this.context.lockTimeoutMs });
+	}
+};
+var SessionStateStore = class extends VersionedFileStore {
+	constructor(context) {
+		super(context, (id) => context.paths.sessionState(id));
+	}
+	async update(id, change, signal) {
+		const path = this.context.paths.sessionState(id);
+		return withFileLock(`${path}.lock`, async () => {
+			const next = VersionedDocumentSchema.parse(await change(await this.read(id)));
+			signal?.throwIfAborted();
+			await writeYamlAtomic(path, next, VersionedDocumentSchema, this.context.logger);
+			return next;
+		}, {
+			timeoutMs: this.context.lockTimeoutMs,
+			signal
+		});
+	}
+};
+//#endregion
+export { VersionedDocumentSchema as n, VersionedFileStore as r, SessionStateStore as t };

package/lib/sessions-C2xuPFQv.js

@@ -0,0 +1,218 @@
+import { n as ClaimStatusSchema, x as nowSeconds } from "./claim-DOAGe8ZK.js";
+import { n as claimRevision } from "./revision-DeoL_IUN.js";
+import { S as LockTimeoutError } from "./lock-DbmlKOoX.js";
+import { r as KnowledgeBusy } from "./alignment-CwH0nBf-.js";
+import { n as VersionedDocumentSchema, t as SessionStateStore } from "./session-state-CYqUhC95.js";
+import { i as sortClaims, t as boundedText } from "./pages-BEWC3kmZ.js";
+import { z } from "zod";
+//#region src/knowledge/catalog.ts
+function renderCatalog(claims, budget) {
+	const active = sortClaims(claims.filter((claim) => claim.status !== "deprecated"));
+	const lines = [];
+	for (const claim of active.slice(0, budget.maxClaims)) {
+		const line = `${claim.id} | ${JSON.stringify(boundedText(claim.name, 120).text)} | ${JSON.stringify(boundedText(claim.scope, 240).text)} | ${claim.confidence} | ${claim.status}`;
+		const omitted = active.length - lines.length - 1;
+		const candidate = [
+			...lines,
+			line,
+			...omitted > 0 ? [`另有 ${omitted} 条，用 claim 工具搜索。`] : []
+		].join("\n");
+		if (Array.from(candidate).length > budget.maxChars) break;
+		lines.push(line);
+	}
+	const omitted = active.length - lines.length;
+	if (omitted > 0) lines.push(`另有 ${omitted} 条，用 claim 工具搜索。`);
+	if (active.length === 0) lines.push("暂无 active/stale Claim。");
+	return boundedText(lines.join("\n"), budget.maxChars).text;
+}
+//#endregion
+//#region src/knowledge/changes.ts
+const ClaimIdentitySchema = z.object({
+	name: z.string(),
+	scope: z.string(),
+	status: ClaimStatusSchema,
+	revision: z.string()
+});
+const ClaimIndexSchema = z.record(z.string(), ClaimIdentitySchema);
+function claimIndex(claims) {
+	return Object.fromEntries([...claims].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0).map((claim) => [claim.id, {
+		name: claim.name,
+		scope: claim.scope,
+		status: claim.status,
+		revision: claimRevision(claim)
+	}]));
+}
+function claimChanges(baseline, current, known) {
+	const changes = [];
+	for (const [id, item] of Object.entries(current)) {
+		if (baseline[id]?.revision === item.revision) continue;
+		changes.push({
+			change: item.status === "deprecated" ? "deprecated" : baseline[id] === void 0 ? "created" : "updated",
+			id,
+			name: item.name,
+			scope: item.scope,
+			status: item.status
+		});
+	}
+	for (const [id, item] of Object.entries({
+		...baseline,
+		...known
+	})) if (current[id] === void 0) changes.push({
+		change: "removed",
+		id,
+		name: item.name,
+		scope: item.scope,
+		status: item.status
+	});
+	return changes.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+function changeNotice(revision, baseline, current, known) {
+	const payload = {
+		revision,
+		refresh_all: false,
+		changes: claimChanges(baseline, current, known)
+	};
+	return `claim_changes_since_system_prompt: ${JSON.stringify(payload)}\nThis cumulative identity snapshot supersedes earlier claim notices. Assess relevance from name/scope; use claim action="read" for current content only when the current task needs to cite or rely on that Claim. Do not read every changed Claim merely because it is listed. Deprecated/removed entries must not be relied on; no content read is needed to stop using them.`;
+}
+//#endregion
+//#region src/knowledge/sessions.ts
+const VersionSchema = z.object({ claimsDigest: z.string() });
+const CatalogSchema = z.object({
+	text: z.string(),
+	knowledgeVersion: VersionSchema,
+	createdAt: z.string(),
+	baseline: ClaimIndexSchema
+});
+const KnowledgeSessionStateSchema = z.object({
+	schemaVersion: z.literal(1),
+	catalog: CatalogSchema.optional(),
+	lastNotifiedVersion: VersionSchema.optional(),
+	knownClaims: ClaimIndexSchema.optional(),
+	seenSourceIds: z.array(z.string()).optional()
+});
+var KnowledgeSessions = class {
+	knowledge;
+	store;
+	states = /* @__PURE__ */ new Map();
+	writes = /* @__PURE__ */ new Map();
+	constructor(knowledge) {
+		this.knowledge = knowledge;
+		this.store = new SessionStateStore(knowledge.context());
+	}
+	async freeze(id, source, parentId, fetchOverview = true, signal) {
+		signal?.throwIfAborted();
+		await this.flush(id);
+		const stored = await this.store.read(id);
+		let state = KnowledgeSessionStateSchema.parse(stored ?? { schemaVersion: 1 });
+		if (state.catalog === void 0 && parentId !== void 0 && source !== "clear") {
+			await this.flush(parentId);
+			const parent = KnowledgeSessionStateSchema.parse(await this.store.read(parentId) ?? { schemaVersion: 1 });
+			if (parent.catalog !== void 0) {
+				state = {
+					...state,
+					catalog: parent.catalog,
+					knownClaims: parent.knownClaims ?? parent.catalog.baseline,
+					seenSourceIds: parent.seenSourceIds ?? []
+				};
+				delete state.lastNotifiedVersion;
+			}
+		}
+		if (state.catalog === void 0 || source === "clear" || source === "startup" && parentId === void 0) {
+			if (source === "resume" || source === "compact") this.knowledge.logger.warn("Missing session Claim catalog; creating a new baseline.");
+			const snapshot = await this.knowledge.snapshot(signal);
+			const baseline = claimIndex(snapshot.claims);
+			state = {
+				...state,
+				catalog: {
+					text: renderCatalog(snapshot.claims, this.knowledge.config.catalog),
+					knowledgeVersion: snapshot.version,
+					createdAt: nowSeconds(),
+					baseline
+				},
+				lastNotifiedVersion: snapshot.version,
+				knownClaims: baseline,
+				seenSourceIds: source === "clear" ? [] : state.seenSourceIds ?? []
+			};
+			const team = this.knowledge.team;
+			if (fetchOverview && team !== null && state.catalog !== void 0) try {
+				const overviewText = `\n\nTeam scope overview (discovery only):\n${(await team.request("router", () => team.router.overview(signal))).scopes.map((item) => `${JSON.stringify(item.scope)} | active=${item.active_claims} | stale=${item.stale_claims} | open_disputes=${item.open_disputes} | resolved_disputes=${item.resolved_disputes}`).join("\n") || "(empty)"}`;
+				const total = this.knowledge.config.catalog.maxChars;
+				const overviewBudget = Math.min(Math.floor(total / 2), Array.from(overviewText).length);
+				state.catalog.text = renderCatalog(snapshot.claims, {
+					...this.knowledge.config.catalog,
+					maxChars: Math.max(1, total - overviewBudget)
+				});
+				const remaining = Math.max(0, total - Array.from(state.catalog.text).length);
+				state.catalog.text += Array.from(overviewText).slice(0, remaining).join("");
+			} catch {
+				signal?.throwIfAborted();
+				state.catalog.text = Array.from(`${state.catalog.text}\n\n团队概览不可用。可调用 consult_router，参数为 {"mode":"overview"}，重新获取概览。`).slice(0, this.knowledge.config.catalog.maxChars).join("");
+			}
+		}
+		signal?.throwIfAborted();
+		const saved = await this.store.update(id, (current) => VersionedDocumentSchema.parse({
+			...current,
+			...state
+		}), signal);
+		this.states.set(id, KnowledgeSessionStateSchema.parse(saved));
+	}
+	catalog(id) {
+		return this.states.get(id)?.catalog?.text ?? "";
+	}
+	async prepare(id, signal) {
+		signal?.throwIfAborted();
+		await this.flush(id);
+		const state = this.states.get(id);
+		if (state?.catalog === void 0) return null;
+		for (let attempt = 0; attempt < 2; attempt += 1) {
+			signal?.throwIfAborted();
+			try {
+				const snapshot = await this.knowledge.snapshot(signal, 0);
+				signal?.throwIfAborted();
+				if (snapshot.version.claimsDigest === state.lastNotifiedVersion?.claimsDigest) return null;
+				const current = claimIndex(snapshot.claims);
+				return {
+					text: changeNotice(snapshot.version.claimsDigest, state.catalog.baseline, current, state.knownClaims ?? state.catalog.baseline),
+					version: snapshot.version,
+					knownClaims: {
+						...state.knownClaims,
+						...current
+					}
+				};
+			} catch (error) {
+				signal?.throwIfAborted();
+				if (!(error instanceof KnowledgeBusy || error instanceof LockTimeoutError)) throw error;
+			}
+		}
+		this.knowledge.logger.debug("Knowledge refresh deferred while a local commit is busy.");
+		return null;
+	}
+	admitted(id, notice) {
+		const write = (this.writes.get(id) ?? Promise.resolve()).then(async () => {
+			const saved = await this.store.update(id, (current) => ({
+				...current,
+				schemaVersion: 1,
+				lastNotifiedVersion: notice.version,
+				knownClaims: notice.knownClaims
+			}));
+			this.states.set(id, KnowledgeSessionStateSchema.parse(saved));
+		}).catch(() => {
+			this.knowledge.logger.warn("Could not persist the session Claim notice cursor; it will be retried.");
+		});
+		this.writes.set(id, write);
+	}
+	async flush(id) {
+		if (id !== void 0) await this.writes.get(id);
+		else await Promise.all(this.writes.values());
+	}
+	clear(id) {
+		this.states.delete(id);
+		this.writes.delete(id);
+	}
+	async forget(id) {
+		await this.flush(id);
+		this.clear(id);
+	}
+};
+//#endregion
+export { KnowledgeSessions as t };

package/lib/store.js

@@ -0,0 +1,16 @@
+import { C as StoreError, S as LockTimeoutError, a as encodeJson, c as readYamlOr, d as removeFile, f as writeTextAtomic, i as decodeYaml, l as writeYamlAtomic, n as withFileLock, o as encodeYaml, p as writeTextAtomicIfAbsent, r as withFileLocks, s as readYaml, t as acquireFileLease, u as cleanupAtomicTemps, w as hasCode } from "./lock-DbmlKOoX.js";
+import { a as EntityStore, i as ClaimStore, n as ReportedSetsSchema, r as reportedClaimSetKey, t as ReportedSetStore } from "./reported-sets-DdEKdeVb.js";
+import { t as TraceStore } from "./traces-CHBo8y1z.js";
+import { n as PendingUploadsSchema, r as UploadStore, t as ConsolidationDeliverySchema } from "./uploads-BCA2p92b.js";
+import { n as VersionedDocumentSchema, r as VersionedFileStore, t as SessionStateStore } from "./session-state-CYqUhC95.js";
+import { i as safeKey, n as agentHomePath, r as expandHomePath, t as AgentPaths } from "./paths-B7NI9Ano.js";
+import { n as ClaimEditStore, r as PendingClaimEditSchema, t as DisputeStore } from "./disputes-ByEmi43j.js";
+import { t as InboxStore } from "./inbox-2CugZZQm.js";
+//#region src/store/jobs.ts
+var JobStore = class extends VersionedFileStore {
+	constructor(context) {
+		super(context, (id) => context.paths.job(id));
+	}
+};
+//#endregion
+export { AgentPaths, ClaimEditStore, ClaimStore, ConsolidationDeliverySchema, DisputeStore, EntityStore, InboxStore, JobStore, LockTimeoutError, PendingClaimEditSchema, PendingUploadsSchema, ReportedSetStore, ReportedSetsSchema, SessionStateStore, StoreError, TraceStore, UploadStore, VersionedDocumentSchema, VersionedFileStore, acquireFileLease, agentHomePath, cleanupAtomicTemps, decodeYaml, encodeJson, encodeYaml, expandHomePath, hasCode, readYaml, readYamlOr, removeFile, reportedClaimSetKey, safeKey, withFileLock, withFileLocks, writeTextAtomic, writeTextAtomicIfAbsent, writeYamlAtomic };