@aigne/agent-runtime 1.12.0-beta.5

package/dist/agent-runners/memory-archive.cjs

@@ -0,0 +1,263 @@
+let ufo = require("ufo");
+let _aigne_afs_index = require("@aigne/afs-index");
+
+//#region src/agent-runners/memory-archive.ts
+/** Upper bound on per-entry `content` payload (chars). Matches design §5. */
+const ARCHIVE_CONTENT_LIMIT = 2048;
+/**
+* Stable 16-char hex hash (two interleaved FNV-1a 32-bit streams). Used by
+* reflection archive to bind reviewer verdicts to the actor output they
+* reviewed via `meta.target_hash`; same primitive is reused by forthcoming
+* G1/G2 wirings for args-hashing.
+*/
+function contentHash(s) {
+	let a = -2128831035;
+	let b = 461845907;
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		a = Math.imul(a ^ c, 16777619);
+		b = Math.imul(b ^ c + i, 2246822507);
+	}
+	const toHex = (n) => (n >>> 0).toString(16).padStart(8, "0");
+	return toHex(a) + toHex(b);
+}
+/**
+* Stringify a value for archival `content`, bounding the output at
+* `ARCHIVE_CONTENT_LIMIT` chars (truncated with `…` when over).
+*/
+function toContentString(v) {
+	const s = typeof v === "string" ? v : JSON.stringify(v ?? "");
+	return s.length > ARCHIVE_CONTENT_LIMIT ? `${s.slice(0, ARCHIVE_CONTENT_LIMIT - 1)}…` : s;
+}
+/**
+* Fire-and-forget call to `/memory/.actions/remember`. Silent when `afs`
+* is absent or when the archive dispatch throws / returns non-success —
+* by design, archive failures must never break the surrounding agent
+* flow.
+*/
+async function tryRemember(afs, args) {
+	if (!afs?.exec) return;
+	try {
+		await afs.exec("/memory/.actions/remember", args, {});
+	} catch {}
+}
+/** Upper bound on per-tool-call archived `content` (chars). */
+const TOOL_CALL_CONTENT_LIMIT = 300;
+/** Paths whose invocations must NEVER be archived (recursion guard). */
+const MEMORY_SELF_ACTION_PREFIX = "/memory/.actions/";
+/**
+* Decides whether `wrapToolProgress` should archive calls for this
+* manifest's `memory` field. Default-on when memory is enabled; only
+* `archiveTools: false` opts out.
+*/
+function isMemoryArchiveEnabled(memory) {
+	if (memory === true) return true;
+	if (memory && typeof memory === "object") return memory.archiveTools !== false;
+	return false;
+}
+/**
+* Single-call archive: maps a `ToolCallRecord` to `/memory/.actions/remember`
+* args per design §3.2. Double-guard against self-calls; fire-and-forget.
+*
+* The anchors emitted are a union of three sources:
+*
+*   1. The tool name (`afs_exec`, `custom_tool`, …) — generic but
+*      always present.
+*   2. The literal `tool_call` topic — lets cross-session recall
+*      filter to "any past tool call" without naming a specific
+*      tool.
+*   3. Path-derived topics from `extractPathTopicAnchors(call.path)`
+*      — pulls the same tier-1 retrieval signal that lifts R@1 from
+*      13% → 100% on the docs/ corpus into tool-call observations.
+*      A run that called `/blocklets/runtime-demos/.actions/
+*      s12-memory-recall-run` becomes recallable by topic
+*      "s12-memory-recall-run", "runtime-demos", or "memory-recall-run"
+*      — not just by the generic "afs_exec".
+*
+* All three coalesce into a single `topic`-typed anchor with deduped
+* `values` so the index keeps the lookup table compact.
+*/
+async function archiveToolCall(afs, call) {
+	if (!afs?.exec) return;
+	if (call.path.startsWith(MEMORY_SELF_ACTION_PREFIX)) return;
+	const argsStr = toContentString(call.args);
+	const content = argsStr.slice(0, TOOL_CALL_CONTENT_LIMIT);
+	const args_hash = contentHash(argsStr);
+	const duration_ms = Math.max(0, call.endTs - call.startTs);
+	const meta = {
+		tool: call.tool,
+		path: call.path,
+		status: call.status,
+		args_hash,
+		role: "tool",
+		round: call.round,
+		session: call.session,
+		duration_ms
+	};
+	if (call.error !== void 0) meta.error = call.error;
+	const pathValues = (0, _aigne_afs_index.extractPathTopicAnchors)(call.path).flatMap((a) => a.values);
+	await tryRemember(afs, {
+		content,
+		level: "observation",
+		layer: "execution",
+		anchors: [{
+			type: "topic",
+			values: [...new Set([
+				call.tool,
+				"tool_call",
+				...pathValues
+			])],
+			confidence: 1
+		}],
+		meta
+	});
+}
+const ORPHAN_TTL_MS = 6e4;
+function asString(v) {
+	return typeof v === "string" ? v : "";
+}
+function asRound(v) {
+	return typeof v === "number" ? v : 0;
+}
+/**
+* Wrap a user-supplied `_on_tool_progress` callback so each completed
+* (non-self, non-pending) tool call fires a fire-and-forget archive to
+* the scope-local memory provider. See design §3.2.
+*
+* Always passes every event through to `userCallback` first — archive is
+* a side channel and must be transparent to the caller.
+*/
+function wrapToolProgress(userCallback, ctx) {
+	const now = ctx.now ?? (() => Date.now());
+	const startMap = /* @__PURE__ */ new Map();
+	const wrapped = (event) => {
+		try {
+			userCallback?.(event);
+		} catch {}
+		const currentNow = now();
+		const cutoff = currentNow - ORPHAN_TTL_MS;
+		for (const [id, entry] of startMap) if (entry.startTs < cutoff) startMap.delete(id);
+		const calls = Array.isArray(event?.calls) ? event.calls : [];
+		const eventRound = asRound(event?.round);
+		if (event?.type === "tool_start") {
+			for (const call of calls) if (call?.id) startMap.set(call.id, {
+				startTs: currentNow,
+				round: eventRound,
+				args: call.args
+			});
+			return;
+		}
+		if (event?.type !== "tool_result") return;
+		for (const call of calls) {
+			if (!call?.id) continue;
+			const path = asString(call.path);
+			if (path.startsWith(MEMORY_SELF_ACTION_PREFIX)) continue;
+			if (call.status === "pending") continue;
+			const start = startMap.get(call.id);
+			startMap.delete(call.id);
+			archiveToolCall(ctx.afs, {
+				id: call.id,
+				tool: asString(call.tool),
+				path,
+				status: call.status === "error" ? "error" : "ok",
+				args: call.args ?? start?.args,
+				error: typeof call.error === "string" ? call.error : void 0,
+				startTs: start?.startTs ?? currentNow,
+				endTs: currentNow,
+				round: start?.round ?? eventRound,
+				session: ctx.session
+			});
+		}
+	};
+	Object.defineProperty(wrapped, "__pendingSize", {
+		value: () => startMap.size,
+		enumerable: false,
+		configurable: true
+	});
+	return wrapped;
+}
+const HANDOFF_CONTENT_LIMIT = 200;
+const HANDOFF_DEFAULT_LIMIT = 3;
+/**
+* Opt-in flag: only `{ handoffReadThrough: true }` turns on the appendix.
+* Boolean-form `memory: true` does NOT enable handoff read-through — it
+* stays archive-only by default.
+*/
+function isHandoffReadThroughEnabled(memory) {
+	if (!memory || typeof memory !== "object") return false;
+	return memory.handoffReadThrough === true;
+}
+/**
+* Linear scan of `/memory/${domain}/observations` → top-N execution-layer
+* entries sorted by createdAt DESC. Fire-and-forget on read: every failure
+* mode (missing provider, list rejection, missing path) collapses to `[]`.
+*
+* Intentionally does not filter by anchors/memberName — memory provider
+* stores anchors in the index, not in `meta`, so linear scan can't see
+* them. See design §2.2.2.
+*/
+async function recallForHandoff(opts) {
+	if (!opts.afs?.list) return [];
+	try {
+		const path = (0, ufo.joinURL)("/memory", opts.domain, "observations");
+		return ((await opts.afs.list(path))?.data ?? []).filter((e) => e.meta?.layer === "execution").sort((a, b) => toEpoch(b.createdAt) - toEpoch(a.createdAt)).slice(0, opts.limit ?? HANDOFF_DEFAULT_LIMIT).map((e) => ({
+			content: typeof e.content === "string" ? e.content : JSON.stringify(e.content ?? ""),
+			meta: e.meta ?? {},
+			createdAt: toEpoch(e.createdAt)
+		}));
+	} catch {
+		return [];
+	}
+}
+function toEpoch(v) {
+	if (v instanceof Date) return v.getTime();
+	if (typeof v === "string" || typeof v === "number") return +new Date(v);
+	return 0;
+}
+/**
+* Render recalled entries as a `## 相关历史经验` appendix suitable for
+* appending to a child agent's `_system_append`. Empty input → `""`
+* (no header-only dangle). Each content is defanged against six
+* injection vectors (see design §5.2) and truncated to 200 chars.
+*/
+function formatRecallForPrompt(entries) {
+	if (entries.length === 0) return "";
+	return [
+		"## 相关历史经验",
+		"",
+		"以下是团队最近的 top-3 执行记录，仅供参考；如果与当前任务无关请忽略。",
+		"",
+		...entries.map((e, i) => {
+			const { round, role } = e.meta ?? {};
+			const safe = truncate(defangForPrompt(e.content ?? ""), HANDOFF_CONTENT_LIMIT);
+			return `${i + 1}. [${renderRoundLabel(round)}/${renderRoleLabel(role)}] ${safe}`;
+		})
+	].join("\n");
+}
+const SAFE_ROLE_LABEL = /^[a-zA-Z0-9_-]{1,32}$/;
+function renderRoundLabel(round) {
+	return typeof round === "number" && Number.isFinite(round) ? String(round) : "?";
+}
+function renderRoleLabel(role) {
+	return typeof role === "string" && SAFE_ROLE_LABEL.test(role) ? role : "entry";
+}
+/** Unicode ranges that can reorder / hide visible text. */
+const UNICODE_INVISIBLES = /[​‎‏‪-‮]/g;
+/** Neutralize the 6 injection vectors from design §5.2. Heading rule collapses
+* any `#+` level to `  # ` so all depths produce the same neutralized form. */
+function defangForPrompt(text) {
+	return text.replace(UNICODE_INVISIBLES, "").replace(/<\|/g, "‹|").replace(/\|>/g, "|›").replace(/^#+\s+/gm, "  # ").replace(/^```+/gm, "  ```").replace(/^---\s*$/gm, "  ---");
+}
+function truncate(text, limit) {
+	return text.length > limit ? `${text.slice(0, limit - 1)}…` : text;
+}
+
+//#endregion
+exports.contentHash = contentHash;
+exports.formatRecallForPrompt = formatRecallForPrompt;
+exports.isHandoffReadThroughEnabled = isHandoffReadThroughEnabled;
+exports.isMemoryArchiveEnabled = isMemoryArchiveEnabled;
+exports.recallForHandoff = recallForHandoff;
+exports.toContentString = toContentString;
+exports.tryRemember = tryRemember;
+exports.wrapToolProgress = wrapToolProgress;

package/dist/agent-runners/memory-archive.d.cts

@@ -0,0 +1,47 @@
+import { AFSRoot } from "@aigne/afs";
+
+//#region src/agent-runners/memory-archive.d.ts
+/**
+ * Decides whether `wrapToolProgress` should archive calls for this
+ * manifest's `memory` field. Default-on when memory is enabled; only
+ * `archiveTools: false` opts out.
+ */
+declare function isMemoryArchiveEnabled(memory: unknown): boolean;
+/**
+ * Opt-in flag: only `{ handoffReadThrough: true }` turns on the appendix.
+ * Boolean-form `memory: true` does NOT enable handoff read-through — it
+ * stays archive-only by default.
+ */
+declare function isHandoffReadThroughEnabled(memory: unknown): boolean;
+interface RecalledEntry {
+  content: string;
+  meta: Record<string, unknown>;
+  createdAt: number;
+}
+interface HandoffRecallOptions {
+  afs: AFSRoot | undefined;
+  /** Resolved domain from `scope.memoryDomain` — NOT from the manifest. */
+  domain: string;
+  /** Default 3. */
+  limit?: number;
+}
+/**
+ * Linear scan of `/memory/${domain}/observations` → top-N execution-layer
+ * entries sorted by createdAt DESC. Fire-and-forget on read: every failure
+ * mode (missing provider, list rejection, missing path) collapses to `[]`.
+ *
+ * Intentionally does not filter by anchors/memberName — memory provider
+ * stores anchors in the index, not in `meta`, so linear scan can't see
+ * them. See design §2.2.2.
+ */
+declare function recallForHandoff(opts: HandoffRecallOptions): Promise<ReadonlyArray<RecalledEntry>>;
+/**
+ * Render recalled entries as a `## 相关历史经验` appendix suitable for
+ * appending to a child agent's `_system_append`. Empty input → `""`
+ * (no header-only dangle). Each content is defanged against six
+ * injection vectors (see design §5.2) and truncated to 200 chars.
+ */
+declare function formatRecallForPrompt(entries: ReadonlyArray<RecalledEntry>): string;
+//#endregion
+export { RecalledEntry, formatRecallForPrompt, isHandoffReadThroughEnabled, isMemoryArchiveEnabled, recallForHandoff };
+//# sourceMappingURL=memory-archive.d.cts.map

package/dist/agent-runners/memory-archive.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-archive.d.cts","names":[],"sources":["../../src/agent-runners/memory-archive.ts"],"mappings":";;;AAoTA;;;;;AAAA,iBAzOgB,sBAAA,CAAuB,MAAA;;;;;;iBA6MvB,2BAAA,CAA4B,MAAA;AAAA,UAK3B,aAAA;EACf,OAAA;EACA,IAAA,EAAM,MAAA;EACN,SAAA;AAAA;AAAA,UAGe,oBAAA;EACf,GAAA,EAAK,OAAA;;EAEL,MAAA;;EAEA,KAAA;AAAA;;;;;;;;;;iBAYoB,gBAAA,CACpB,IAAA,EAAM,oBAAA,GACL,OAAA,CAAQ,aAAA,CAAc,aAAA;;;;;;;iBAiCT,qBAAA,CAAsB,OAAA,EAAS,aAAA,CAAc,aAAA"}

package/dist/agent-runners/memory-archive.d.mts

@@ -0,0 +1,47 @@
+import { AFSRoot } from "@aigne/afs";
+
+//#region src/agent-runners/memory-archive.d.ts
+/**
+ * Decides whether `wrapToolProgress` should archive calls for this
+ * manifest's `memory` field. Default-on when memory is enabled; only
+ * `archiveTools: false` opts out.
+ */
+declare function isMemoryArchiveEnabled(memory: unknown): boolean;
+/**
+ * Opt-in flag: only `{ handoffReadThrough: true }` turns on the appendix.
+ * Boolean-form `memory: true` does NOT enable handoff read-through — it
+ * stays archive-only by default.
+ */
+declare function isHandoffReadThroughEnabled(memory: unknown): boolean;
+interface RecalledEntry {
+  content: string;
+  meta: Record<string, unknown>;
+  createdAt: number;
+}
+interface HandoffRecallOptions {
+  afs: AFSRoot | undefined;
+  /** Resolved domain from `scope.memoryDomain` — NOT from the manifest. */
+  domain: string;
+  /** Default 3. */
+  limit?: number;
+}
+/**
+ * Linear scan of `/memory/${domain}/observations` → top-N execution-layer
+ * entries sorted by createdAt DESC. Fire-and-forget on read: every failure
+ * mode (missing provider, list rejection, missing path) collapses to `[]`.
+ *
+ * Intentionally does not filter by anchors/memberName — memory provider
+ * stores anchors in the index, not in `meta`, so linear scan can't see
+ * them. See design §2.2.2.
+ */
+declare function recallForHandoff(opts: HandoffRecallOptions): Promise<ReadonlyArray<RecalledEntry>>;
+/**
+ * Render recalled entries as a `## 相关历史经验` appendix suitable for
+ * appending to a child agent's `_system_append`. Empty input → `""`
+ * (no header-only dangle). Each content is defanged against six
+ * injection vectors (see design §5.2) and truncated to 200 chars.
+ */
+declare function formatRecallForPrompt(entries: ReadonlyArray<RecalledEntry>): string;
+//#endregion
+export { RecalledEntry, formatRecallForPrompt, isHandoffReadThroughEnabled, isMemoryArchiveEnabled, recallForHandoff };
+//# sourceMappingURL=memory-archive.d.mts.map

package/dist/agent-runners/memory-archive.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-archive.d.mts","names":[],"sources":["../../src/agent-runners/memory-archive.ts"],"mappings":";;;AAoTA;;;;;AAAA,iBAzOgB,sBAAA,CAAuB,MAAA;;;;;;iBA6MvB,2BAAA,CAA4B,MAAA;AAAA,UAK3B,aAAA;EACf,OAAA;EACA,IAAA,EAAM,MAAA;EACN,SAAA;AAAA;AAAA,UAGe,oBAAA;EACf,GAAA,EAAK,OAAA;;EAEL,MAAA;;EAEA,KAAA;AAAA;;;;;;;;;;iBAYoB,gBAAA,CACpB,IAAA,EAAM,oBAAA,GACL,OAAA,CAAQ,aAAA,CAAc,aAAA;;;;;;;iBAiCT,qBAAA,CAAsB,OAAA,EAAS,aAAA,CAAc,aAAA"}

package/dist/agent-runners/memory-archive.mjs

@@ -0,0 +1,257 @@
+import { joinURL } from "ufo";
+import { extractPathTopicAnchors } from "@aigne/afs-index";
+
+//#region src/agent-runners/memory-archive.ts
+/** Upper bound on per-entry `content` payload (chars). Matches design §5. */
+const ARCHIVE_CONTENT_LIMIT = 2048;
+/**
+* Stable 16-char hex hash (two interleaved FNV-1a 32-bit streams). Used by
+* reflection archive to bind reviewer verdicts to the actor output they
+* reviewed via `meta.target_hash`; same primitive is reused by forthcoming
+* G1/G2 wirings for args-hashing.
+*/
+function contentHash(s) {
+	let a = -2128831035;
+	let b = 461845907;
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		a = Math.imul(a ^ c, 16777619);
+		b = Math.imul(b ^ c + i, 2246822507);
+	}
+	const toHex = (n) => (n >>> 0).toString(16).padStart(8, "0");
+	return toHex(a) + toHex(b);
+}
+/**
+* Stringify a value for archival `content`, bounding the output at
+* `ARCHIVE_CONTENT_LIMIT` chars (truncated with `…` when over).
+*/
+function toContentString(v) {
+	const s = typeof v === "string" ? v : JSON.stringify(v ?? "");
+	return s.length > ARCHIVE_CONTENT_LIMIT ? `${s.slice(0, ARCHIVE_CONTENT_LIMIT - 1)}…` : s;
+}
+/**
+* Fire-and-forget call to `/memory/.actions/remember`. Silent when `afs`
+* is absent or when the archive dispatch throws / returns non-success —
+* by design, archive failures must never break the surrounding agent
+* flow.
+*/
+async function tryRemember(afs, args) {
+	if (!afs?.exec) return;
+	try {
+		await afs.exec("/memory/.actions/remember", args, {});
+	} catch {}
+}
+/** Upper bound on per-tool-call archived `content` (chars). */
+const TOOL_CALL_CONTENT_LIMIT = 300;
+/** Paths whose invocations must NEVER be archived (recursion guard). */
+const MEMORY_SELF_ACTION_PREFIX = "/memory/.actions/";
+/**
+* Decides whether `wrapToolProgress` should archive calls for this
+* manifest's `memory` field. Default-on when memory is enabled; only
+* `archiveTools: false` opts out.
+*/
+function isMemoryArchiveEnabled(memory) {
+	if (memory === true) return true;
+	if (memory && typeof memory === "object") return memory.archiveTools !== false;
+	return false;
+}
+/**
+* Single-call archive: maps a `ToolCallRecord` to `/memory/.actions/remember`
+* args per design §3.2. Double-guard against self-calls; fire-and-forget.
+*
+* The anchors emitted are a union of three sources:
+*
+*   1. The tool name (`afs_exec`, `custom_tool`, …) — generic but
+*      always present.
+*   2. The literal `tool_call` topic — lets cross-session recall
+*      filter to "any past tool call" without naming a specific
+*      tool.
+*   3. Path-derived topics from `extractPathTopicAnchors(call.path)`
+*      — pulls the same tier-1 retrieval signal that lifts R@1 from
+*      13% → 100% on the docs/ corpus into tool-call observations.
+*      A run that called `/blocklets/runtime-demos/.actions/
+*      s12-memory-recall-run` becomes recallable by topic
+*      "s12-memory-recall-run", "runtime-demos", or "memory-recall-run"
+*      — not just by the generic "afs_exec".
+*
+* All three coalesce into a single `topic`-typed anchor with deduped
+* `values` so the index keeps the lookup table compact.
+*/
+async function archiveToolCall(afs, call) {
+	if (!afs?.exec) return;
+	if (call.path.startsWith(MEMORY_SELF_ACTION_PREFIX)) return;
+	const argsStr = toContentString(call.args);
+	const content = argsStr.slice(0, TOOL_CALL_CONTENT_LIMIT);
+	const args_hash = contentHash(argsStr);
+	const duration_ms = Math.max(0, call.endTs - call.startTs);
+	const meta = {
+		tool: call.tool,
+		path: call.path,
+		status: call.status,
+		args_hash,
+		role: "tool",
+		round: call.round,
+		session: call.session,
+		duration_ms
+	};
+	if (call.error !== void 0) meta.error = call.error;
+	const pathValues = extractPathTopicAnchors(call.path).flatMap((a) => a.values);
+	await tryRemember(afs, {
+		content,
+		level: "observation",
+		layer: "execution",
+		anchors: [{
+			type: "topic",
+			values: [...new Set([
+				call.tool,
+				"tool_call",
+				...pathValues
+			])],
+			confidence: 1
+		}],
+		meta
+	});
+}
+const ORPHAN_TTL_MS = 6e4;
+function asString(v) {
+	return typeof v === "string" ? v : "";
+}
+function asRound(v) {
+	return typeof v === "number" ? v : 0;
+}
+/**
+* Wrap a user-supplied `_on_tool_progress` callback so each completed
+* (non-self, non-pending) tool call fires a fire-and-forget archive to
+* the scope-local memory provider. See design §3.2.
+*
+* Always passes every event through to `userCallback` first — archive is
+* a side channel and must be transparent to the caller.
+*/
+function wrapToolProgress(userCallback, ctx) {
+	const now = ctx.now ?? (() => Date.now());
+	const startMap = /* @__PURE__ */ new Map();
+	const wrapped = (event) => {
+		try {
+			userCallback?.(event);
+		} catch {}
+		const currentNow = now();
+		const cutoff = currentNow - ORPHAN_TTL_MS;
+		for (const [id, entry] of startMap) if (entry.startTs < cutoff) startMap.delete(id);
+		const calls = Array.isArray(event?.calls) ? event.calls : [];
+		const eventRound = asRound(event?.round);
+		if (event?.type === "tool_start") {
+			for (const call of calls) if (call?.id) startMap.set(call.id, {
+				startTs: currentNow,
+				round: eventRound,
+				args: call.args
+			});
+			return;
+		}
+		if (event?.type !== "tool_result") return;
+		for (const call of calls) {
+			if (!call?.id) continue;
+			const path = asString(call.path);
+			if (path.startsWith(MEMORY_SELF_ACTION_PREFIX)) continue;
+			if (call.status === "pending") continue;
+			const start = startMap.get(call.id);
+			startMap.delete(call.id);
+			archiveToolCall(ctx.afs, {
+				id: call.id,
+				tool: asString(call.tool),
+				path,
+				status: call.status === "error" ? "error" : "ok",
+				args: call.args ?? start?.args,
+				error: typeof call.error === "string" ? call.error : void 0,
+				startTs: start?.startTs ?? currentNow,
+				endTs: currentNow,
+				round: start?.round ?? eventRound,
+				session: ctx.session
+			});
+		}
+	};
+	Object.defineProperty(wrapped, "__pendingSize", {
+		value: () => startMap.size,
+		enumerable: false,
+		configurable: true
+	});
+	return wrapped;
+}
+const HANDOFF_CONTENT_LIMIT = 200;
+const HANDOFF_DEFAULT_LIMIT = 3;
+/**
+* Opt-in flag: only `{ handoffReadThrough: true }` turns on the appendix.
+* Boolean-form `memory: true` does NOT enable handoff read-through — it
+* stays archive-only by default.
+*/
+function isHandoffReadThroughEnabled(memory) {
+	if (!memory || typeof memory !== "object") return false;
+	return memory.handoffReadThrough === true;
+}
+/**
+* Linear scan of `/memory/${domain}/observations` → top-N execution-layer
+* entries sorted by createdAt DESC. Fire-and-forget on read: every failure
+* mode (missing provider, list rejection, missing path) collapses to `[]`.
+*
+* Intentionally does not filter by anchors/memberName — memory provider
+* stores anchors in the index, not in `meta`, so linear scan can't see
+* them. See design §2.2.2.
+*/
+async function recallForHandoff(opts) {
+	if (!opts.afs?.list) return [];
+	try {
+		const path = joinURL("/memory", opts.domain, "observations");
+		return ((await opts.afs.list(path))?.data ?? []).filter((e) => e.meta?.layer === "execution").sort((a, b) => toEpoch(b.createdAt) - toEpoch(a.createdAt)).slice(0, opts.limit ?? HANDOFF_DEFAULT_LIMIT).map((e) => ({
+			content: typeof e.content === "string" ? e.content : JSON.stringify(e.content ?? ""),
+			meta: e.meta ?? {},
+			createdAt: toEpoch(e.createdAt)
+		}));
+	} catch {
+		return [];
+	}
+}
+function toEpoch(v) {
+	if (v instanceof Date) return v.getTime();
+	if (typeof v === "string" || typeof v === "number") return +new Date(v);
+	return 0;
+}
+/**
+* Render recalled entries as a `## 相关历史经验` appendix suitable for
+* appending to a child agent's `_system_append`. Empty input → `""`
+* (no header-only dangle). Each content is defanged against six
+* injection vectors (see design §5.2) and truncated to 200 chars.
+*/
+function formatRecallForPrompt(entries) {
+	if (entries.length === 0) return "";
+	return [
+		"## 相关历史经验",
+		"",
+		"以下是团队最近的 top-3 执行记录，仅供参考；如果与当前任务无关请忽略。",
+		"",
+		...entries.map((e, i) => {
+			const { round, role } = e.meta ?? {};
+			const safe = truncate(defangForPrompt(e.content ?? ""), HANDOFF_CONTENT_LIMIT);
+			return `${i + 1}. [${renderRoundLabel(round)}/${renderRoleLabel(role)}] ${safe}`;
+		})
+	].join("\n");
+}
+const SAFE_ROLE_LABEL = /^[a-zA-Z0-9_-]{1,32}$/;
+function renderRoundLabel(round) {
+	return typeof round === "number" && Number.isFinite(round) ? String(round) : "?";
+}
+function renderRoleLabel(role) {
+	return typeof role === "string" && SAFE_ROLE_LABEL.test(role) ? role : "entry";
+}
+/** Unicode ranges that can reorder / hide visible text. */
+const UNICODE_INVISIBLES = /[​‎‏‪-‮]/g;
+/** Neutralize the 6 injection vectors from design §5.2. Heading rule collapses
+* any `#+` level to `  # ` so all depths produce the same neutralized form. */
+function defangForPrompt(text) {
+	return text.replace(UNICODE_INVISIBLES, "").replace(/<\|/g, "‹|").replace(/\|>/g, "|›").replace(/^#+\s+/gm, "  # ").replace(/^```+/gm, "  ```").replace(/^---\s*$/gm, "  ---");
+}
+function truncate(text, limit) {
+	return text.length > limit ? `${text.slice(0, limit - 1)}…` : text;
+}
+
+//#endregion
+export { contentHash, formatRecallForPrompt, isHandoffReadThroughEnabled, isMemoryArchiveEnabled, recallForHandoff, toContentString, tryRemember, wrapToolProgress };
+//# sourceMappingURL=memory-archive.mjs.map

package/dist/agent-runners/memory-archive.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-archive.mjs","names":[],"sources":["../../src/agent-runners/memory-archive.ts"],"sourcesContent":["/**\n * Shared helpers for archiving agent observations to the scope-local\n * `/memory/.actions/remember` endpoint. Extracted from reflection.ts so\n * forthcoming wirings (G1 tool-call archive, G2 handoff read-through, …)\n * can share the same content-bounding + hashing + fire-and-forget policy.\n *\n * Phase 0 is a pure move — semantics must remain byte-identical to the\n * versions that previously lived alongside the reflection loop.\n */\n\nimport type { AFSEntry, AFSRoot } from \"@aigne/afs\";\nimport { extractPathTopicAnchors } from \"@aigne/afs-index\";\nimport { joinURL } from \"ufo\";\n\n/** Upper bound on per-entry `content` payload (chars). Matches design §5. */\nexport const ARCHIVE_CONTENT_LIMIT = 2048;\n\n/**\n * Stable 16-char hex hash (two interleaved FNV-1a 32-bit streams). Used by\n * reflection archive to bind reviewer verdicts to the actor output they\n * reviewed via `meta.target_hash`; same primitive is reused by forthcoming\n * G1/G2 wirings for args-hashing.\n */\nexport function contentHash(s: string): string {\n  let a = 0x811c9dc5 | 0;\n  let b = 0x1b873593 | 0;\n  for (let i = 0; i < s.length; i++) {\n    const c = s.charCodeAt(i);\n    a = Math.imul(a ^ c, 0x01000193);\n    b = Math.imul(b ^ (c + i), 0x85ebca6b);\n  }\n  const toHex = (n: number) => (n >>> 0).toString(16).padStart(8, \"0\");\n  return toHex(a) + toHex(b);\n}\n\n/**\n * Stringify a value for archival `content`, bounding the output at\n * `ARCHIVE_CONTENT_LIMIT` chars (truncated with `…` when over).\n */\nexport function toContentString(v: unknown): string {\n  const s = typeof v === \"string\" ? v : JSON.stringify(v ?? \"\");\n  return s.length > ARCHIVE_CONTENT_LIMIT ? `${s.slice(0, ARCHIVE_CONTENT_LIMIT - 1)}…` : s;\n}\n\n/**\n * Fire-and-forget call to `/memory/.actions/remember`. Silent when `afs`\n * is absent or when the archive dispatch throws / returns non-success —\n * by design, archive failures must never break the surrounding agent\n * flow.\n */\nexport async function tryRemember(\n  afs: AFSRoot | undefined,\n  args: Record<string, unknown>,\n): Promise<void> {\n  if (!afs?.exec) return;\n  try {\n    await afs.exec(\"/memory/.actions/remember\", args, {});\n  } catch {\n    // Fire-and-forget: archive failures must never propagate.\n  }\n}\n\n// ─── G1: Tool call archive ──────────────────────────────────────────────\n\n/** Upper bound on per-tool-call archived `content` (chars). */\nexport const TOOL_CALL_CONTENT_LIMIT = 300;\n\n/** Paths whose invocations must NEVER be archived (recursion guard). */\nconst MEMORY_SELF_ACTION_PREFIX = \"/memory/.actions/\";\n\n/**\n * Decides whether `wrapToolProgress` should archive calls for this\n * manifest's `memory` field. Default-on when memory is enabled; only\n * `archiveTools: false` opts out.\n */\nexport function isMemoryArchiveEnabled(memory: unknown): boolean {\n  if (memory === true) return true;\n  if (memory && typeof memory === \"object\") {\n    return (memory as { archiveTools?: boolean }).archiveTools !== false;\n  }\n  return false;\n}\n\nexport interface ToolCallRecord {\n  id: string;\n  tool: string;\n  path: string;\n  status: \"ok\" | \"error\";\n  args?: unknown;\n  error?: string;\n  startTs: number;\n  endTs: number;\n  round: number;\n  session: string;\n}\n\n/**\n * Single-call archive: maps a `ToolCallRecord` to `/memory/.actions/remember`\n * args per design §3.2. Double-guard against self-calls; fire-and-forget.\n *\n * The anchors emitted are a union of three sources:\n *\n *   1. The tool name (`afs_exec`, `custom_tool`, …) — generic but\n *      always present.\n *   2. The literal `tool_call` topic — lets cross-session recall\n *      filter to \"any past tool call\" without naming a specific\n *      tool.\n *   3. Path-derived topics from `extractPathTopicAnchors(call.path)`\n *      — pulls the same tier-1 retrieval signal that lifts R@1 from\n *      13% → 100% on the docs/ corpus into tool-call observations.\n *      A run that called `/blocklets/runtime-demos/.actions/\n *      s12-memory-recall-run` becomes recallable by topic\n *      \"s12-memory-recall-run\", \"runtime-demos\", or \"memory-recall-run\"\n *      — not just by the generic \"afs_exec\".\n *\n * All three coalesce into a single `topic`-typed anchor with deduped\n * `values` so the index keeps the lookup table compact.\n */\nexport async function archiveToolCall(\n  afs: AFSRoot | undefined,\n  call: ToolCallRecord,\n): Promise<void> {\n  if (!afs?.exec) return;\n  if (call.path.startsWith(MEMORY_SELF_ACTION_PREFIX)) return;\n\n  const argsStr = toContentString(call.args);\n  const content = argsStr.slice(0, TOOL_CALL_CONTENT_LIMIT);\n  const args_hash = contentHash(argsStr);\n  const duration_ms = Math.max(0, call.endTs - call.startTs);\n\n  const meta: Record<string, unknown> = {\n    tool: call.tool,\n    path: call.path,\n    status: call.status,\n    args_hash,\n    role: \"tool\",\n    round: call.round,\n    session: call.session,\n    duration_ms,\n  };\n  if (call.error !== undefined) meta.error = call.error;\n\n  const pathAnchors = extractPathTopicAnchors(call.path);\n  const pathValues = pathAnchors.flatMap((a) => a.values);\n  const dedupedValues = [...new Set([call.tool, \"tool_call\", ...pathValues])];\n\n  await tryRemember(afs, {\n    content,\n    level: \"observation\",\n    layer: \"execution\",\n    anchors: [{ type: \"topic\", values: dedupedValues, confidence: 1 }],\n    meta,\n  });\n}\n\n/** Shape of the events `agent-run` emits via `_on_tool_progress`. */\nexport interface ToolProgressEvent {\n  type?: string;\n  round?: number;\n  calls?: Array<{\n    id?: string;\n    tool?: string;\n    path?: string;\n    status?: string;\n    args?: unknown;\n    result?: unknown;\n    error?: string;\n  }>;\n  [key: string]: unknown;\n}\n\nexport interface WrapToolProgressContext {\n  afs: AFSRoot | undefined;\n  session: string;\n  /** Injectable clock for deterministic orphan-cleanup tests. */\n  now?: () => number;\n}\n\nconst ORPHAN_TTL_MS = 60_000;\n\nfunction asString(v: unknown): string {\n  return typeof v === \"string\" ? v : \"\";\n}\n\nfunction asRound(v: unknown): number {\n  return typeof v === \"number\" ? v : 0;\n}\n\n/**\n * Wrap a user-supplied `_on_tool_progress` callback so each completed\n * (non-self, non-pending) tool call fires a fire-and-forget archive to\n * the scope-local memory provider. See design §3.2.\n *\n * Always passes every event through to `userCallback` first — archive is\n * a side channel and must be transparent to the caller.\n */\nexport function wrapToolProgress(\n  userCallback: ((event: ToolProgressEvent) => void) | undefined,\n  ctx: WrapToolProgressContext,\n): (event: ToolProgressEvent) => void {\n  const now = ctx.now ?? (() => Date.now());\n  // ash's `tool_result` events do not carry the original `args` (only id /\n  // tool / path / status / result|error). Pair them with `tool_start` here\n  // by call.id so archived records preserve the input that was actually run.\n  const startMap = new Map<string, { startTs: number; round: number; args: unknown }>();\n\n  const wrapped = (event: ToolProgressEvent): void => {\n    // Always passthrough first; user callback errors must not break archive.\n    try {\n      userCallback?.(event);\n    } catch {\n      // Swallow — archive side-channel must remain transparent.\n    }\n\n    const currentNow = now();\n    const cutoff = currentNow - ORPHAN_TTL_MS;\n    for (const [id, entry] of startMap) {\n      if (entry.startTs < cutoff) startMap.delete(id);\n    }\n\n    const calls = Array.isArray(event?.calls) ? event.calls : [];\n    const eventRound = asRound(event?.round);\n\n    if (event?.type === \"tool_start\") {\n      for (const call of calls) {\n        if (call?.id) {\n          startMap.set(call.id, {\n            startTs: currentNow,\n            round: eventRound,\n            args: call.args,\n          });\n        }\n      }\n      return;\n    }\n\n    if (event?.type !== \"tool_result\") return;\n\n    for (const call of calls) {\n      if (!call?.id) continue;\n      const path = asString(call.path);\n      if (path.startsWith(MEMORY_SELF_ACTION_PREFIX)) continue;\n      if (call.status === \"pending\") continue;\n\n      const start = startMap.get(call.id);\n      startMap.delete(call.id);\n      void archiveToolCall(ctx.afs, {\n        id: call.id,\n        tool: asString(call.tool),\n        path,\n        status: call.status === \"error\" ? \"error\" : \"ok\",\n        args: call.args ?? start?.args,\n        error: typeof call.error === \"string\" ? call.error : undefined,\n        startTs: start?.startTs ?? currentNow,\n        endTs: currentNow,\n        round: start?.round ?? eventRound,\n        session: ctx.session,\n      });\n    }\n  };\n\n  Object.defineProperty(wrapped, \"__pendingSize\", {\n    value: () => startMap.size,\n    enumerable: false,\n    configurable: true,\n  });\n\n  return wrapped;\n}\n\n// ─── G2: Handoff read-through ──────────────────────────────────────────\n\nconst HANDOFF_CONTENT_LIMIT = 200;\nconst HANDOFF_DEFAULT_LIMIT = 3;\n\n/**\n * Opt-in flag: only `{ handoffReadThrough: true }` turns on the appendix.\n * Boolean-form `memory: true` does NOT enable handoff read-through — it\n * stays archive-only by default.\n */\nexport function isHandoffReadThroughEnabled(memory: unknown): boolean {\n  if (!memory || typeof memory !== \"object\") return false;\n  return (memory as { handoffReadThrough?: boolean }).handoffReadThrough === true;\n}\n\nexport interface RecalledEntry {\n  content: string;\n  meta: Record<string, unknown>;\n  createdAt: number;\n}\n\nexport interface HandoffRecallOptions {\n  afs: AFSRoot | undefined;\n  /** Resolved domain from `scope.memoryDomain` — NOT from the manifest. */\n  domain: string;\n  /** Default 3. */\n  limit?: number;\n}\n\n/**\n * Linear scan of `/memory/${domain}/observations` → top-N execution-layer\n * entries sorted by createdAt DESC. Fire-and-forget on read: every failure\n * mode (missing provider, list rejection, missing path) collapses to `[]`.\n *\n * Intentionally does not filter by anchors/memberName — memory provider\n * stores anchors in the index, not in `meta`, so linear scan can't see\n * them. See design §2.2.2.\n */\nexport async function recallForHandoff(\n  opts: HandoffRecallOptions,\n): Promise<ReadonlyArray<RecalledEntry>> {\n  if (!opts.afs?.list) return [];\n  try {\n    const path = joinURL(\"/memory\", opts.domain, \"observations\");\n    const result = await opts.afs.list(path);\n    const entries = (result?.data ?? []) as AFSEntry[];\n\n    return entries\n      .filter((e) => (e.meta as { layer?: string } | undefined)?.layer === \"execution\")\n      .sort((a, b) => toEpoch(b.createdAt) - toEpoch(a.createdAt))\n      .slice(0, opts.limit ?? HANDOFF_DEFAULT_LIMIT)\n      .map((e) => ({\n        content: typeof e.content === \"string\" ? e.content : JSON.stringify(e.content ?? \"\"),\n        meta: (e.meta ?? {}) as Record<string, unknown>,\n        createdAt: toEpoch(e.createdAt),\n      }));\n  } catch {\n    return [];\n  }\n}\n\nfunction toEpoch(v: unknown): number {\n  if (v instanceof Date) return v.getTime();\n  if (typeof v === \"string\" || typeof v === \"number\") return +new Date(v);\n  return 0;\n}\n\n/**\n * Render recalled entries as a `## 相关历史经验` appendix suitable for\n * appending to a child agent's `_system_append`. Empty input → `\"\"`\n * (no header-only dangle). Each content is defanged against six\n * injection vectors (see design §5.2) and truncated to 200 chars.\n */\nexport function formatRecallForPrompt(entries: ReadonlyArray<RecalledEntry>): string {\n  if (entries.length === 0) return \"\";\n  const lines = entries.map((e, i) => {\n    const { round, role } = (e.meta ?? {}) as { round?: unknown; role?: unknown };\n    const safe = truncate(defangForPrompt(e.content ?? \"\"), HANDOFF_CONTENT_LIMIT);\n    return `${i + 1}. [${renderRoundLabel(round)}/${renderRoleLabel(role)}] ${safe}`;\n  });\n  return [\n    \"## 相关历史经验\",\n    \"\",\n    \"以下是团队最近的 top-3 执行记录，仅供参考；如果与当前任务无关请忽略。\",\n    \"\",\n    ...lines,\n  ].join(\"\\n\");\n}\n\nconst SAFE_ROLE_LABEL = /^[a-zA-Z0-9_-]{1,32}$/;\n\nfunction renderRoundLabel(round: unknown): string {\n  return typeof round === \"number\" && Number.isFinite(round) ? String(round) : \"?\";\n}\n\nfunction renderRoleLabel(role: unknown): string {\n  return typeof role === \"string\" && SAFE_ROLE_LABEL.test(role) ? role : \"entry\";\n}\n\n/** Unicode ranges that can reorder / hide visible text. */\nconst UNICODE_INVISIBLES = /[​‎‏‪-‮]/g;\n\n/** Neutralize the 6 injection vectors from design §5.2. Heading rule collapses\n * any `#+` level to `  # ` so all depths produce the same neutralized form. */\nfunction defangForPrompt(text: string): string {\n  return text\n    .replace(UNICODE_INVISIBLES, \"\")\n    .replace(/<\\|/g, \"‹|\")\n    .replace(/\\|>/g, \"|›\")\n    .replace(/^#+\\s+/gm, \"  # \")\n    .replace(/^```+/gm, \"  ```\")\n    .replace(/^---\\s*$/gm, \"  ---\");\n}\n\nfunction truncate(text: string, limit: number): string {\n  return text.length > limit ? `${text.slice(0, limit - 1)}…` : text;\n}\n"],"mappings":";;;;;AAeA,MAAa,wBAAwB;;;;;;;AAQrC,SAAgB,YAAY,GAAmB;CAC7C,IAAI,IAAI;CACR,IAAI,IAAI;AACR,MAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;EACjC,MAAM,IAAI,EAAE,WAAW,EAAE;AACzB,MAAI,KAAK,KAAK,IAAI,GAAG,SAAW;AAChC,MAAI,KAAK,KAAK,IAAK,IAAI,GAAI,WAAW;;CAExC,MAAM,SAAS,OAAe,MAAM,GAAG,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI;AACpE,QAAO,MAAM,EAAE,GAAG,MAAM,EAAE;;;;;;AAO5B,SAAgB,gBAAgB,GAAoB;CAClD,MAAM,IAAI,OAAO,MAAM,WAAW,IAAI,KAAK,UAAU,KAAK,GAAG;AAC7D,QAAO,EAAE,SAAS,wBAAwB,GAAG,EAAE,MAAM,GAAG,wBAAwB,EAAE,CAAC,KAAK;;;;;;;;AAS1F,eAAsB,YACpB,KACA,MACe;AACf,KAAI,CAAC,KAAK,KAAM;AAChB,KAAI;AACF,QAAM,IAAI,KAAK,6BAA6B,MAAM,EAAE,CAAC;SAC/C;;;AAQV,MAAa,0BAA0B;;AAGvC,MAAM,4BAA4B;;;;;;AAOlC,SAAgB,uBAAuB,QAA0B;AAC/D,KAAI,WAAW,KAAM,QAAO;AAC5B,KAAI,UAAU,OAAO,WAAW,SAC9B,QAAQ,OAAsC,iBAAiB;AAEjE,QAAO;;;;;;;;;;;;;;;;;;;;;;;;AAsCT,eAAsB,gBACpB,KACA,MACe;AACf,KAAI,CAAC,KAAK,KAAM;AAChB,KAAI,KAAK,KAAK,WAAW,0BAA0B,CAAE;CAErD,MAAM,UAAU,gBAAgB,KAAK,KAAK;CAC1C,MAAM,UAAU,QAAQ,MAAM,GAAG,wBAAwB;CACzD,MAAM,YAAY,YAAY,QAAQ;CACtC,MAAM,cAAc,KAAK,IAAI,GAAG,KAAK,QAAQ,KAAK,QAAQ;CAE1D,MAAM,OAAgC;EACpC,MAAM,KAAK;EACX,MAAM,KAAK;EACX,QAAQ,KAAK;EACb;EACA,MAAM;EACN,OAAO,KAAK;EACZ,SAAS,KAAK;EACd;EACD;AACD,KAAI,KAAK,UAAU,OAAW,MAAK,QAAQ,KAAK;CAGhD,MAAM,aADc,wBAAwB,KAAK,KAAK,CACvB,SAAS,MAAM,EAAE,OAAO;AAGvD,OAAM,YAAY,KAAK;EACrB;EACA,OAAO;EACP,OAAO;EACP,SAAS,CAAC;GAAE,MAAM;GAAS,QANP,CAAC,GAAG,IAAI,IAAI;IAAC,KAAK;IAAM;IAAa,GAAG;IAAW,CAAC,CAAC;GAMvB,YAAY;GAAG,CAAC;EAClE;EACD,CAAC;;AA0BJ,MAAM,gBAAgB;AAEtB,SAAS,SAAS,GAAoB;AACpC,QAAO,OAAO,MAAM,WAAW,IAAI;;AAGrC,SAAS,QAAQ,GAAoB;AACnC,QAAO,OAAO,MAAM,WAAW,IAAI;;;;;;;;;;AAWrC,SAAgB,iBACd,cACA,KACoC;CACpC,MAAM,MAAM,IAAI,cAAc,KAAK,KAAK;CAIxC,MAAM,2BAAW,IAAI,KAAgE;CAErF,MAAM,WAAW,UAAmC;AAElD,MAAI;AACF,kBAAe,MAAM;UACf;EAIR,MAAM,aAAa,KAAK;EACxB,MAAM,SAAS,aAAa;AAC5B,OAAK,MAAM,CAAC,IAAI,UAAU,SACxB,KAAI,MAAM,UAAU,OAAQ,UAAS,OAAO,GAAG;EAGjD,MAAM,QAAQ,MAAM,QAAQ,OAAO,MAAM,GAAG,MAAM,QAAQ,EAAE;EAC5D,MAAM,aAAa,QAAQ,OAAO,MAAM;AAExC,MAAI,OAAO,SAAS,cAAc;AAChC,QAAK,MAAM,QAAQ,MACjB,KAAI,MAAM,GACR,UAAS,IAAI,KAAK,IAAI;IACpB,SAAS;IACT,OAAO;IACP,MAAM,KAAK;IACZ,CAAC;AAGN;;AAGF,MAAI,OAAO,SAAS,cAAe;AAEnC,OAAK,MAAM,QAAQ,OAAO;AACxB,OAAI,CAAC,MAAM,GAAI;GACf,MAAM,OAAO,SAAS,KAAK,KAAK;AAChC,OAAI,KAAK,WAAW,0BAA0B,CAAE;AAChD,OAAI,KAAK,WAAW,UAAW;GAE/B,MAAM,QAAQ,SAAS,IAAI,KAAK,GAAG;AACnC,YAAS,OAAO,KAAK,GAAG;AACxB,GAAK,gBAAgB,IAAI,KAAK;IAC5B,IAAI,KAAK;IACT,MAAM,SAAS,KAAK,KAAK;IACzB;IACA,QAAQ,KAAK,WAAW,UAAU,UAAU;IAC5C,MAAM,KAAK,QAAQ,OAAO;IAC1B,OAAO,OAAO,KAAK,UAAU,WAAW,KAAK,QAAQ;IACrD,SAAS,OAAO,WAAW;IAC3B,OAAO;IACP,OAAO,OAAO,SAAS;IACvB,SAAS,IAAI;IACd,CAAC;;;AAIN,QAAO,eAAe,SAAS,iBAAiB;EAC9C,aAAa,SAAS;EACtB,YAAY;EACZ,cAAc;EACf,CAAC;AAEF,QAAO;;AAKT,MAAM,wBAAwB;AAC9B,MAAM,wBAAwB;;;;;;AAO9B,SAAgB,4BAA4B,QAA0B;AACpE,KAAI,CAAC,UAAU,OAAO,WAAW,SAAU,QAAO;AAClD,QAAQ,OAA4C,uBAAuB;;;;;;;;;;;AA0B7E,eAAsB,iBACpB,MACuC;AACvC,KAAI,CAAC,KAAK,KAAK,KAAM,QAAO,EAAE;AAC9B,KAAI;EACF,MAAM,OAAO,QAAQ,WAAW,KAAK,QAAQ,eAAe;AAI5D,WAHe,MAAM,KAAK,IAAI,KAAK,KAAK,GACf,QAAQ,EAAE,EAGhC,QAAQ,MAAO,EAAE,MAAyC,UAAU,YAAY,CAChF,MAAM,GAAG,MAAM,QAAQ,EAAE,UAAU,GAAG,QAAQ,EAAE,UAAU,CAAC,CAC3D,MAAM,GAAG,KAAK,SAAS,sBAAsB,CAC7C,KAAK,OAAO;GACX,SAAS,OAAO,EAAE,YAAY,WAAW,EAAE,UAAU,KAAK,UAAU,EAAE,WAAW,GAAG;GACpF,MAAO,EAAE,QAAQ,EAAE;GACnB,WAAW,QAAQ,EAAE,UAAU;GAChC,EAAE;SACC;AACN,SAAO,EAAE;;;AAIb,SAAS,QAAQ,GAAoB;AACnC,KAAI,aAAa,KAAM,QAAO,EAAE,SAAS;AACzC,KAAI,OAAO,MAAM,YAAY,OAAO,MAAM,SAAU,QAAO,CAAC,IAAI,KAAK,EAAE;AACvE,QAAO;;;;;;;;AAST,SAAgB,sBAAsB,SAA+C;AACnF,KAAI,QAAQ,WAAW,EAAG,QAAO;AAMjC,QAAO;EACL;EACA;EACA;EACA;EACA,GAVY,QAAQ,KAAK,GAAG,MAAM;GAClC,MAAM,EAAE,OAAO,SAAU,EAAE,QAAQ,EAAE;GACrC,MAAM,OAAO,SAAS,gBAAgB,EAAE,WAAW,GAAG,EAAE,sBAAsB;AAC9E,UAAO,GAAG,IAAI,EAAE,KAAK,iBAAiB,MAAM,CAAC,GAAG,gBAAgB,KAAK,CAAC,IAAI;IAC1E;EAOD,CAAC,KAAK,KAAK;;AAGd,MAAM,kBAAkB;AAExB,SAAS,iBAAiB,OAAwB;AAChD,QAAO,OAAO,UAAU,YAAY,OAAO,SAAS,MAAM,GAAG,OAAO,MAAM,GAAG;;AAG/E,SAAS,gBAAgB,MAAuB;AAC9C,QAAO,OAAO,SAAS,YAAY,gBAAgB,KAAK,KAAK,GAAG,OAAO;;;AAIzE,MAAM,qBAAqB;;;AAI3B,SAAS,gBAAgB,MAAsB;AAC7C,QAAO,KACJ,QAAQ,oBAAoB,GAAG,CAC/B,QAAQ,QAAQ,KAAK,CACrB,QAAQ,QAAQ,KAAK,CACrB,QAAQ,YAAY,OAAO,CAC3B,QAAQ,WAAW,QAAQ,CAC3B,QAAQ,cAAc,QAAQ;;AAGnC,SAAS,SAAS,MAAc,OAAuB;AACrD,QAAO,KAAK,SAAS,QAAQ,GAAG,KAAK,MAAM,GAAG,QAAQ,EAAE,CAAC,KAAK"}