@aitne/daemon 0.1.3 → 0.1.6

package/dist/core/routine-acquisition-plan.js

@@ -0,0 +1,367 @@
+/**
+ * `<acquisition-plan>` block assembly for the routine pre-pass fetcher.
+ *
+ * ROUTINE_DATA_ACQUISITION_DESIGN.md §6.4 / F5 — pure helper that the
+ * routine dispatchers (Phase 4) call to render the XML block the
+ * `routine.fetch_window` session reads. Stays I/O-free so it can be
+ * tested in isolation against synthetic integration state.
+ *
+ * The block lists one `<fetch>` element per (integration × mode × account)
+ * combination implied by `ROUTINE_WINDOWS[routine]` and the current
+ * integration state. Disabled integrations, unmapped query cells, and
+ * native bindings whose backend does not match the session are skipped.
+ *
+ * Output shape (§6.4 example, but with substituted timestamps and the
+ * resolved mode-suffix the partial filters on):
+ *
+ * ```xml
+ * <acquisition-plan routine="morning_routine" agent_day="2026-05-11">
+ *   <fetch integration="gmail" mode="direct" window="inbox_today"
+ *          account="alice@gmail.com" query="?days=1&amp;limit=20" />
+ *   ...
+ * </acquisition-plan>
+ * ```
+ */
+import { INTEGRATION_KEYS, getAgentDayBoundsUtc, getIntegrationDescriptor, parseSqliteUtcMs, } from "@aitne/shared";
+import { ROUTINE_WINDOWS, WINDOW_QUERIES, } from "./routine-windows.js";
+/**
+ * Compute the timestamp set the assembly helper uses. Anchors to the
+ * agent-day boundary `dayBoundaryHour` (configurable; the daemon's
+ * config default is 4 = 04:00 local per CLAUDE.md), so
+ * `day_start_iso` matches the same UTC instant `getAgentDayBoundsUtc`
+ * uses everywhere else in the daemon.
+ *
+ * The parameter has no built-in default — callers MUST thread
+ * `config.dayBoundaryHour` through so a future config change does not
+ * silently desync this layer from the rest of the daemon. Tests can
+ * pass `0` for stable arithmetic against a UTC fixture.
+ */
+export function buildAcquisitionTimestamps(now, timezone, dayBoundaryHour) {
+    const bounds = getAgentDayBoundsUtc(timezone, dayBoundaryHour, now);
+    const dayStartMs = parseSqliteUtcMs(bounds.start);
+    const dayEndMs = dayStartMs + 24 * 60 * 60 * 1000;
+    const day48Ms = dayStartMs + 48 * 60 * 60 * 1000;
+    const weekStartMs = dayStartMs - 7 * 24 * 60 * 60 * 1000;
+    const weekEndMs = dayStartMs + 7 * 24 * 60 * 60 * 1000;
+    const monthEndMs = dayStartMs + 30 * 24 * 60 * 60 * 1000;
+    const nowMs = now.getTime();
+    const hourStartMs = nowMs - (nowMs % (60 * 60 * 1000));
+    const plus2hMs = nowMs + 2 * 60 * 60 * 1000;
+    const dateOnly = (ms) => new Date(ms).toISOString().slice(0, 10);
+    return {
+        now_iso: new Date(nowMs).toISOString(),
+        hour_start_iso: new Date(hourStartMs).toISOString(),
+        day_start_iso: new Date(dayStartMs).toISOString(),
+        day_end_iso: new Date(dayEndMs).toISOString(),
+        day_plus_24h: new Date(dayEndMs).toISOString(),
+        day_plus_48h: new Date(day48Ms).toISOString(),
+        day_plus_2h: new Date(plus2hMs).toISOString(),
+        week_start_iso: new Date(weekStartMs).toISOString(),
+        week_end_iso: new Date(weekEndMs).toISOString(),
+        month_end_iso: new Date(monthEndMs).toISOString(),
+        day_start_date: dateOnly(dayStartMs),
+        week_start_date: dateOnly(weekStartMs),
+        now_date: dateOnly(nowMs),
+    };
+}
+// ── Internal helpers ───────────────────────────────────────────────────────
+/**
+ * The integrations a window symbol applies to. Used to map a routine's
+ * `RoutineWindowSpec.kind` onto concrete integration keys. Walking
+ * `WINDOW_QUERIES[symbol]` keeps the catalog as the single source of
+ * truth — no hardcoded "mail → gmail+outlook_mail" mapping here.
+ */
+function integrationsForWindow(symbol) {
+    return Object.keys(WINDOW_QUERIES[symbol] ?? {});
+}
+/**
+ * Resolve the integration's runtime mode to the predicate string the
+ * partial filters on. Returns `null` when the row should be skipped
+ * (disabled, missing state, native binding on a different backend).
+ *
+ * §6.8 / §3 glossary — for `userManagedConnector` integrations
+ * (today: `outlook_mail`, `outlook_calendar`) the daemon ships no
+ * `/api/integrations/<key>/exec` proxy, so `delegated-cross` is
+ * unreachable. The dispatcher MUST collapse cross-backend delegated to
+ * `delegated-same` for these descriptors — the only viable path is
+ * the session backend's own MCP, identical to same-backend. Without
+ * this collapse, the partial's `delegated-cross` defensive guard
+ * fires every tick instead of remaining dormant.
+ */
+function resolveFetchMode(integration, state, sessionBackend) {
+    if (!state)
+        return null;
+    switch (state.mode) {
+        case "direct":
+            return "direct";
+        case "delegated":
+            if (state.delegatedBackend === sessionBackend) {
+                return "delegated-same";
+            }
+            // Cross-backend delegated requires a non-null `delegatedBackend`.
+            // Missing binding ≈ misconfiguration → skip.
+            if (state.delegatedBackend !== null
+                && state.delegatedBackend !== undefined) {
+                // User-managed integrations have no daemon proxy; collapse to
+                // same-backend so the partial body's main delegated-same prose
+                // runs instead of its defensive delegated-cross fallback.
+                if (getIntegrationDescriptor(integration).userManagedConnector === true) {
+                    return "delegated-same";
+                }
+                return "delegated-cross";
+            }
+            return null;
+        case "native":
+            // Native binding must match the session backend. Otherwise the
+            // partial's `mode:native:<key>` block would be filtered out by
+            // `applyIntegrationModeFilter` anyway — skip the row to avoid
+            // emitting a `<fetch>` that no branch can handle.
+            if (state.nativeBackend === sessionBackend)
+                return "native";
+            return null;
+        case "disabled":
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * Resolve the WINDOW_QUERIES cell for a (symbol, integration, mode)
+ * tuple. delegated-same / delegated-cross both look up "delegated" in
+ * the catalog; the predicate distinction is only meaningful at the
+ * partial-filtering layer.
+ */
+function lookupQuery(symbol, integration, fetchMode) {
+    const catalog = WINDOW_QUERIES[symbol]?.[integration];
+    if (!catalog)
+        return undefined;
+    if (fetchMode === "delegated-same" || fetchMode === "delegated-cross") {
+        return catalog.delegated;
+    }
+    return catalog[fetchMode];
+}
+/**
+ * Substitute `{token}` placeholders in a query string with the
+ * pre-computed timestamps. Unknown tokens are left verbatim — they will
+ * surface as `{foo}` in the rendered prompt, which is visible failure
+ * (the partial author can grep for `{` in their query).
+ */
+export function substituteAcquisitionTokens(query, timestamps) {
+    return query.replace(/\{([a-z_][a-z0-9_]*)\}/g, (match, name) => {
+        const value = timestamps[name];
+        return value ?? match;
+    });
+}
+/**
+ * Attribute escaping for non-query `<fetch>` attribute values
+ * (`integration`, `mode`, `window`, `account`, `label`, and the
+ * block's `routine` / `agent_day`). These are short tokens drawn
+ * from controlled vocabularies; the conventional XML escape set
+ * keeps them robust against future authors who slip a special
+ * character in.
+ */
+function xmlAttr(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/"/g, "&quot;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+/**
+ * Escaping for the `<fetch query='…'>` attribute, which uses
+ * single-quote delimiters so URL query strings can be rendered
+ * verbatim.
+ *
+ * The consumer of this block is the LLM, not an XML parser — the
+ * agent is told to use the `query` attribute literally as a URL
+ * query string (`GET .../messages<query>`) or as MCP-tool arguments
+ * (`q="newer_than:1d"`). Two characters in our catalog would
+ * otherwise need entity-decode steps the agent must remember:
+ *  - `&` separates URL query parameters (`?a=1&b=2`),
+ *  - `"` wraps Gmail / Calendar MCP query expressions
+ *    (`q="newer_than:1d"`, `timeMin="…"`).
+ *
+ * Single-quote delimiters let us keep both literal. The only
+ * character that would now break the attribute structure is `'`,
+ * which no query in `WINDOW_QUERIES` uses today. We escape `'` and
+ * `<` / `>` defensively for any future catalog author who uses
+ * them.
+ */
+function xmlQueryAttr(value) {
+    return value
+        .replace(/'/g, "&apos;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+function renderFetchRow(row) {
+    const parts = [
+        `integration="${xmlAttr(row.integration)}"`,
+        `mode="${xmlAttr(row.mode)}"`,
+        `window="${xmlAttr(row.window)}"`,
+    ];
+    if (row.accountId !== undefined) {
+        parts.push(`account="${xmlAttr(row.accountId)}"`);
+    }
+    if (row.label !== undefined) {
+        parts.push(`label="${xmlAttr(row.label)}"`);
+    }
+    // Single-quote delimiter on `query=` — see `xmlQueryAttr` rationale.
+    parts.push(`query='${xmlQueryAttr(row.query)}'`);
+    return `  <fetch ${parts.join(" ")} />`;
+}
+// ── Row collection (shared by buildAcquisitionPlan + splitAcquisitionPlanByIntegration) ──
+/**
+ * Resolve every `<fetch>` row implied by `input` from the routine
+ * catalog + integration state. Pure, deterministic, ordering-stable —
+ * the loop walks `ROUTINE_WINDOWS[routine]` in spec order, then
+ * `WINDOW_QUERIES[symbol]` key order. Both consumers (`buildAcquisitionPlan`
+ * and `splitAcquisitionPlanByIntegration`) share this so the rendered
+ * monolithic block and the union of per-integration sub-plan blocks
+ * carry bit-identical row sequences.
+ */
+function collectFetchRows(input) {
+    const rows = [];
+    const specs = ROUTINE_WINDOWS[input.routine];
+    for (const spec of specs) {
+        const integrations = integrationsForWindow(spec.window);
+        for (const integration of integrations) {
+            const state = input.integrations[integration];
+            const fetchMode = resolveFetchMode(integration, state, input.sessionBackend);
+            if (fetchMode === null)
+                continue;
+            const queryTemplate = lookupQuery(spec.window, integration, fetchMode);
+            if (queryTemplate === undefined)
+                continue;
+            const query = substituteAcquisitionTokens(queryTemplate, input.timestamps);
+            // perAccount fan-out is meaningful only in `direct` mode, where the
+            // daemon stores per-account OAuth tokens and polls each. In
+            // `delegated-same` / `delegated-cross` / `native` the integration's
+            // bound MCP authenticates as a single user, and `mail_accounts` in
+            // the daemon DB is intentionally empty — fanning out would produce
+            // zero rows and silently skip the pre-pass entirely (the failure
+            // mode that left Sonnet doing both fetch and synthesis in one run
+            // and hitting `routine.morning_routine`'s $1 budget cap). Emit one
+            // shared row for non-direct modes; the partial body substitutes
+            // `"default"` for the missing `<accountId>` in the observation
+            // contract. Same pattern as the userManagedConnector
+            // delegated-cross → delegated-same collapse in `resolveFetchMode`:
+            // the dispatcher folds away configurations that have no real wire
+            // surface so the partials never need to defend against them.
+            if (spec.perAccount && fetchMode === "direct") {
+                const accountRows = input.accounts.filter((a) => a.integration === integration);
+                for (const account of accountRows) {
+                    rows.push({
+                        integration,
+                        mode: fetchMode,
+                        window: spec.window,
+                        accountId: account.accountId,
+                        label: account.label,
+                        query,
+                    });
+                }
+            }
+            else {
+                rows.push({
+                    integration,
+                    mode: fetchMode,
+                    window: spec.window,
+                    query,
+                });
+            }
+        }
+    }
+    return rows;
+}
+/**
+ * Render the `<acquisition-plan>` wrapper around a row sequence.
+ * `scoped` is an optional fan-out debugging affordance — when set, the
+ * block's element carries a `scoped="<key>"` attribute so a sub-plan is
+ * visually distinguishable from a full plan in the daemon log and in
+ * test fixtures. The partials ignore the attribute.
+ */
+function renderAcquisitionPlanBlock(routine, agentDay, rows, scoped) {
+    // Strip the `routine.` prefix in the attribute for compactness; the
+    // surrounding daemon log carries the full ProcessKey.
+    const routineAttr = routine.replace(/^routine\./, "");
+    const openParts = [
+        `routine="${xmlAttr(routineAttr)}"`,
+        `agent_day="${xmlAttr(agentDay)}"`,
+    ];
+    if (scoped !== undefined) {
+        openParts.push(`scoped="${xmlAttr(scoped)}"`);
+    }
+    const lines = [
+        `<acquisition-plan ${openParts.join(" ")}>`,
+        ...rows.map(renderFetchRow),
+        "</acquisition-plan>",
+    ];
+    return lines.join("\n");
+}
+// ── Public entry point ────────────────────────────────────────────────────
+/**
+ * Build the `<acquisition-plan>` block string for a routine.
+ *
+ * Pure function: deterministic for a given input. Returns the rendered
+ * XML even when no rows survive — an empty plan still gives the
+ * pre-pass an explicit "nothing to do" signal rather than the absence
+ * of a block.
+ */
+export function buildAcquisitionPlan(input) {
+    const rows = collectFetchRows(input);
+    return renderAcquisitionPlanBlock(input.routine, input.agentDay, rows);
+}
+/**
+ * Partition a routine's acquisition plan into one sub-plan per active
+ * `IntegrationKey`. Pure helper consumed by the fan-out coordinator
+ * (Phase 1). Returns:
+ *
+ *  - An empty array when no integration is active for the routine
+ *    (every cell skipped — caller short-circuits to `status="skipped"`).
+ *  - One `AcquisitionSubPlan` per integration that contributes ≥ 1 row.
+ *
+ * **Ordering invariant.** Sub-plans are sorted by `INTEGRATION_KEYS`
+ * enumeration order regardless of the order rows appear in
+ * `ROUTINE_WINDOWS`. The coordinator's `Promise.all` + `mergeSubReports`
+ * pipeline preserves the ordering downstream so daemon logs and test
+ * fixtures are stable across runs.
+ *
+ * **Row preservation.** Each sub-plan's `block` is rendered through the
+ * same `renderAcquisitionPlanBlock` helper that backs `buildAcquisitionPlan`,
+ * so the union of sub-plan rows equals `buildAcquisitionPlan(input)`'s
+ * rows row-for-row (same attribute order, same query substitution, same
+ * perAccount fan-out). The only differences are the per-block wrapper's
+ * `scoped="<key>"` attribute and the partition itself.
+ */
+export function splitAcquisitionPlanByIntegration(input) {
+    const rows = collectFetchRows(input);
+    if (rows.length === 0)
+        return [];
+    // Group rows by integration while keeping insertion order inside each
+    // group (the `ROUTINE_WINDOWS` walk order from `collectFetchRows`).
+    const groups = new Map();
+    for (const row of rows) {
+        const existing = groups.get(row.integration);
+        if (existing) {
+            existing.push(row);
+        }
+        else {
+            groups.set(row.integration, [row]);
+        }
+    }
+    // Emit sub-plans in `INTEGRATION_KEYS` enumeration order — deterministic
+    // resolution order per §4.6.
+    const out = [];
+    for (const key of INTEGRATION_KEYS) {
+        const groupRows = groups.get(key);
+        if (!groupRows || groupRows.length === 0)
+            continue;
+        out.push({
+            integrationKey: key,
+            block: renderAcquisitionPlanBlock(input.routine, input.agentDay, groupRows, key),
+            fetchRowCount: groupRows.length,
+            rowsHaveAccount: groupRows.some((r) => r.accountId !== undefined),
+        });
+    }
+    return out;
+}
+//# sourceMappingURL=routine-acquisition-plan.js.map

package/dist/core/routine-acquisition-plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routine-acquisition-plan.js","sourceRoot":"","sources":["../../src/core/routine-acquisition-plan.ts"],"names":[],"mappings":"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"}

package/dist/core/routine-fetch-window-retry.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Retry-policy helpers for the pre-pass fan-out coordinator.
+ *
+ * PRE_PASS_FAN_OUT_DESIGN.md §4.4 — the coordinator spawns a fresh Haiku
+ * sub-session per attempt and consults `defaultRetryDecision` (or any
+ * `RetryDecisionFn`) between attempts to choose whether to spawn the
+ * next one. Keeping the policy as pure data (decision matrix in
+ * TypeScript, not in agent prose) makes the loop deterministic,
+ * testable, and free of per-model variance.
+ *
+ * Phase 0 ships these helpers + their unit tests. The fan-out
+ * coordinator that consumes them lands in Phase 1.
+ */
+import type { IntegrationKey } from "@aitne/shared";
+import type { SubAttemptRecord } from "./routine-fetch-window-runner.js";
+/**
+ * One pre-pass retry chain's policy. The runner constructs this from
+ * `AgentConfig.prePass*` knobs (Phase 1) and passes it through every
+ * `defaultRetryDecision` call.
+ */
+export interface RetryPolicy {
+    /** Cap on attempts per integration. Default 3 per §6 config table. */
+    maxAttempts: number;
+    /**
+     * Backoff between attempts, indexed by attempt number minus 1.
+     * Length MUST equal `maxAttempts - 1`. Default `[1000, 2000, 4000]`.
+     */
+    backoffMs: readonly number[];
+    /** Per-integration cumulative cost cap across attempts. Default 0.60 USD. */
+    perIntegrationBudgetUsd: number;
+    /**
+     * Optional decision override. The coordinator passes this through to
+     * unit tests / fixtures; production code uses `defaultRetryDecision`.
+     */
+    retryOn?: RetryDecisionFn;
+    /**
+     * Runtime knob for the partial-with-no-post branch. Defaults to true
+     * when omitted so existing tests and callers keep the §4.4 matrix.
+     */
+    retryOnPartial?: boolean;
+}
+/**
+ * Decision returned by a `RetryDecisionFn`. `reason` flows into the
+ * `agent_actions.detail.prePass.retryReason` field so the audit feed
+ * carries a human-grokkable trail of why each attempt fired (or didn't).
+ */
+export interface RetryDecision {
+    retry: boolean;
+    /** Short, stable identifier — used in audit rows, not user-facing prose. */
+    reason: string;
+}
+/**
+ * Decision-function signature. The coordinator invokes this AFTER
+ * recording the latest attempt and BEFORE applying backoff for the next
+ * attempt. `priorAttempts` excludes the current `report` so callers
+ * computing cumulative cost can include `report.costUsd` themselves.
+ */
+export type RetryDecisionFn = (report: SubAttemptRecord, attempt: number, policy: RetryPolicy, priorAttempts: readonly SubAttemptRecord[]) => RetryDecision;
+/**
+ * Stable reason identifiers. Centralised so the dashboard / audit feed
+ * can render them consistently and so test assertions don't drift from
+ * runtime values.
+ */
+export declare const RETRY_REASONS: {
+    readonly MAX_ATTEMPTS: "max-attempts-reached";
+    readonly BUDGET_CAP: "per-integration-budget-cap";
+    readonly FLIP_LOCKED: "flip-locked";
+    readonly BUDGET_EXHAUSTED: "budget-exhausted";
+    readonly AUTH_FAILED: "auth-failed";
+    readonly FAILED_STATUS: "failed-status";
+    readonly UPSTREAM_5XX: "upstream-5xx";
+    readonly PARTIAL_NO_POST: "partial-no-post";
+    readonly SUCCESS: "success";
+    readonly PARTIAL_WITH_POST: "partial-with-progress";
+    readonly SKIPPED: "skipped";
+    readonly NO_PROGRESS: "no-progress";
+};
+/**
+ * Sum the cost across `priorAttempts` + the current `report`. Pure;
+ * exported for unit testing the budget-cap branch in isolation.
+ */
+export declare function cumulativeAttemptCost(report: SubAttemptRecord, priorAttempts: readonly SubAttemptRecord[]): number;
+/**
+ * Default retry policy from §4.4. Pure: decision is fully determined by
+ * the inputs, no side effects, no shared state. Decision order:
+ *
+ *  1. Attempts cap (no retry, reason `max-attempts-reached`).
+ *  2. Per-integration cumulative budget cap.
+ *  3. Terminal error classes — flip-lock, budget-exhausted, auth (401/403).
+ *  4. Retry-worthy outcomes — failed status, upstream 5xx, partial-no-post.
+ *  5. Non-retry-by-default — success, partial-with-progress, skipped, no-progress.
+ *
+ * The motivating §1.1 failure ("Unknown name "limit"") lands
+ * as `status="partial"` with `fetched > 0`, `posted === 0` and a
+ * `fetch-failed` error — rule (4)'s `partial-no-post` branch catches it.
+ */
+export declare const defaultRetryDecision: RetryDecisionFn;
+/**
+ * Render the `<prior_attempt_error>` block sequence injected into a
+ * sub-session's prompt on attempt > 1. Returns the empty string when
+ * `attempts` is empty so callers can unconditionally concatenate the
+ * result.
+ *
+ * **Ordering.** Newest first — attempt N (most recent) appears before
+ * attempt N-1, etc. The model reads the most-recent failure top of
+ * page; deeper history is context-only.
+ */
+export declare function buildPriorAttemptHintBlock(attempts: readonly SubAttemptRecord[], integrationKey?: IntegrationKey): string;
+//# sourceMappingURL=routine-fetch-window-retry.d.ts.map

package/dist/core/routine-fetch-window-retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routine-fetch-window-retry.d.ts","sourceRoot":"","sources":["../../src/core/routine-fetch-window-retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAIzE;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,6EAA6E;IAC7E,uBAAuB,EAAE,MAAM,CAAC;IAChC;;;OAGG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,OAAO,CAAC;IACf,4EAA4E;IAC5E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,CAC5B,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,SAAS,gBAAgB,EAAE,KACvC,aAAa,CAAC;AAInB;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;CAahB,CAAC;AAEX;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,gBAAgB,EACxB,aAAa,EAAE,SAAS,gBAAgB,EAAE,GACzC,MAAM,CAIR;AAmBD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,EAAE,eAmElC,CAAC;AA+EF;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EACrC,cAAc,CAAC,EAAE,cAAc,GAC9B,MAAM,CAMR"}