@winspan/claude-forge 8.54.3 → 9.2.0

package/dist/daemon/services/task-boundary-classifier.js

@@ -0,0 +1,202 @@
+/**
+ * TaskBoundaryClassifier — async LLM "new task vs continuation" re-attribution.
+ *
+ * decision 265f59d5 (Option A, 2026-06-08). Solves the residual case the
+ * synchronous lexical segmenter cannot: a SHORT, ambiguous follow-up prompt
+ * that is neither a clear ack ("继续"/"好的") nor carries a NEW_TASK_KEYWORD,
+ * e.g. "现在全链路是不是都顺了" vs "文件也看下" — lexically indistinguishable,
+ * yet one is a new task and the other a continuation.
+ *
+ * ── Hot-path contract (NEVER block UserPromptSubmit) ──────────────────────
+ * The synchronous segmenter ALWAYS runs first and gives the prompt a
+ * best-effort task (zero latency). THIS service runs entirely in the
+ * background, fire-and-forget. It spawns `claude` (haiku) only for the ~30%
+ * of prompts the segmenter flagged ambiguous, then LAZILY re-attributes:
+ *   • LLM says NEW_TASK  → move the prompt's event onto a brand-new task row
+ *     (only `task_events.task_id` FK is touched — no event delete, no content
+ *     mutation). See SQLiteStorage.reattributePromptToNewTask.
+ *   • LLM says CONTINUATION → leave the sync best-effort merge untouched, just
+ *     stamp `llm_classified_at` so a replay never re-spawns.
+ *
+ * Failure mode: ANY spawn / timeout / parse error → give up, keep the sync
+ * result, never throw. Mirrors OutcomeClassificationService's fire-and-forget
+ * discipline.
+ */
+import { logger } from '../../core/utils/logger.js';
+import { formatError, truncateString } from '../../core/utils/format.js';
+import { truncateSessionId } from '../../core/utils/session.js';
+import { spawnClaudeCli } from '../../core/utils/claude-cli-spawn.js';
+import { randomUUID } from 'node:crypto';
+/**
+ * Spawn timeout (decision 5266724a, 2026-06-08). Bumped 8s → 30s: live `claude`
+ * classification spawns were measured at 6.8–26s, so an 8s cap timed out the
+ * majority of calls and silently degraded back to the sync lexical path. 30s
+ * comfortably covers the observed tail. Still fire-and-forget / background, so
+ * a slow spawn never blocks UserPromptSubmit.
+ */
+const DEFAULT_TIMEOUT_MS = 30_000;
+/** How many prior prompts of the merged task to hand the LLM as context. */
+const CONTEXT_PROMPT_LIMIT = 3;
+export class TaskBoundaryClassifier {
+    spawnFn;
+    /**
+     * @param spawnFn  optional spawn override (tests). Default spawns the
+     *                 `task-boundary-classifier` agent via claude haiku.
+     */
+    constructor(opts = {}) {
+        const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.spawnFn =
+            opts.spawnFn ??
+                ((prompt) => spawnClaudeCli({
+                    agent: 'task-boundary-classifier',
+                    prompt,
+                    timeoutMs,
+                    claudeBin: opts.claudeBin,
+                    // No tools — pure classification, fastest path. Allowed list empty
+                    // means the agent uses its own frontmatter (which declares none).
+                }));
+    }
+    /**
+     * Classify one ambiguous prompt and, if NEW_TASK, re-attribute it.
+     * Fire-and-forget: never throws. Returns the new task id when it split,
+     * else null (CONTINUATION, idempotent skip, or any failure).
+     */
+    async classify(job, storage) {
+        try {
+            // Idempotency short-circuit BEFORE spending a spawn: if the merged task
+            // is already stamped, a prior run (or replay) handled this prompt.
+            if (storage.isLlmClassified(job.mergedTaskId)) {
+                return null;
+            }
+            // INFO-level entry log so production can finally confirm the classifier
+            // is actually invoked. Before decision 083112fc EVERY branch below was
+            // logger.debug() (invisible at the daemon's default INFO level), so a
+            // classifier that never once spawned looked identical to one that ran
+            // fine — `llm_classified_at` stayed 0/1132 with zero log evidence.
+            logger.info(`[TaskBoundaryClassifier] classify called for session=${truncateSessionId(job.sessionId)} ` +
+                `mergedTask=${truncateString(job.mergedTaskId, 8)} prompt="${truncateString(job.prompt.replace(/\s+/g, ' ').trim(), 60)}"`);
+            const priorPrompts = this.safePriorPrompts(storage, job.mergedTaskId);
+            const agentPrompt = buildBoundaryPrompt(priorPrompts, job.prompt);
+            let raw;
+            try {
+                raw = await this.spawnFn(agentPrompt);
+            }
+            catch (err) {
+                // NEVER swallow spawn failures silently. This is the single most
+                // important observability fix: a launchd PATH miss / exit error /
+                // timeout used to vanish at debug level, so "the classifier never
+                // ran" had no diagnosable cause. warn carries the error reason.
+                logger.warn(`[TaskBoundaryClassifier] spawn FAILED for session=${truncateSessionId(job.sessionId)}: ${formatError(err)} — keeping sync merge`);
+                return null; // conservative: keep sync best-effort merge
+            }
+            const verdict = parseVerdict(raw);
+            if (verdict === null) {
+                logger.warn(`[TaskBoundaryClassifier] unparseable verdict (raw="${truncateString(raw.trim(), 60)}") for ` +
+                    `session=${truncateSessionId(job.sessionId)} — keeping merge`);
+                return null;
+            }
+            logger.info(`[TaskBoundaryClassifier] verdict=${verdict} for session=${truncateSessionId(job.sessionId)} ` +
+                `mergedTask=${truncateString(job.mergedTaskId, 8)}`);
+            const atIso = new Date().toISOString();
+            if (verdict === 'CONTINUATION') {
+                // Correct already — just stamp so we never reprocess this prompt.
+                try {
+                    storage.markLlmClassified(job.mergedTaskId, atIso);
+                }
+                catch (err) {
+                    logger.warn(`[TaskBoundaryClassifier] stamp failed: ${formatError(err)}`);
+                }
+                return null;
+            }
+            // NEW_TASK → lazily re-attribute. reattributePromptToNewTask re-checks
+            // idempotency + the event's current FK inside one transaction (OQ #3).
+            const newTaskId = storage.reattributePromptToNewTask({
+                fromTaskId: job.mergedTaskId,
+                eventId: job.eventId,
+                newTask: {
+                    id: randomUUID(),
+                    session_id: job.sessionId,
+                    title: extractTitle(job.prompt),
+                    start_time: job.timestamp,
+                    task_kind: 'user',
+                },
+                atIso,
+            });
+            if (newTaskId) {
+                logger.info(`[TaskBoundaryClassifier] split ambiguous prompt off ${truncateString(job.mergedTaskId, 8)} ` +
+                    `→ new task ${truncateString(newTaskId, 8)} (session=${truncateSessionId(job.sessionId)})`);
+            }
+            else {
+                // reattribute can no-op if the FK moved under us (concurrent replay) —
+                // surface it so a silent "NEW_TASK verdict but no split" is diagnosable.
+                logger.info(`[TaskBoundaryClassifier] NEW_TASK verdict but reattribute no-op (idempotent skip) for ` +
+                    `session=${truncateSessionId(job.sessionId)}`);
+            }
+            return newTaskId;
+        }
+        catch (err) {
+            logger.warn(`[TaskBoundaryClassifier] classify failed: ${formatError(err)}`);
+            return null;
+        }
+    }
+    safePriorPrompts(storage, taskId) {
+        try {
+            return storage.getTaskUserPrompts(taskId, CONTEXT_PROMPT_LIMIT);
+        }
+        catch (err) {
+            logger.warn(`[TaskBoundaryClassifier] prior-prompt fetch failed: ${formatError(err)}`);
+            return [];
+        }
+    }
+}
+// ── Pure helpers (exported for unit-test reuse) ─────────────────────────────
+/**
+ * Build the bare classification prompt handed to the agent. The agent body
+ * (.claude/agents/task-boundary-classifier.md) instructs it to answer with a
+ * single token; we still keep the contract inline so a bare-prompt spawn
+ * (no agent template synced yet) also works.
+ */
+export function buildBoundaryPrompt(priorPrompts, current) {
+    const prev = priorPrompts.length > 0
+        ? priorPrompts.map((p, i) => `  ${i + 1}. ${truncateString(p.replace(/\s+/g, ' ').trim(), 200)}`).join('\n')
+        : '  (无)';
+    return [
+        '你是 task-boundary 分类器。判断「当前 prompt」是开启一个新任务，还是对上一个任务的追问/续接。',
+        '只输出一个词：NEW_TASK 或 CONTINUATION。不要解释，不要输出其他任何内容。',
+        '',
+        '上一个任务的若干 prompt：',
+        prev,
+        '',
+        `当前 prompt：${current.replace(/\s+/g, ' ').trim()}`,
+    ].join('\n');
+}
+/**
+ * Extract the agent's single-token verdict from raw stdout. Tolerant: the
+ * model may wrap the token in punctuation / markdown / a sentence. We scan for
+ * the first NEW_TASK / CONTINUATION occurrence (case-insensitive). Returns null
+ * when neither token is present (caller keeps the sync merge).
+ */
+export function parseVerdict(raw) {
+    if (!raw)
+        return null;
+    const upper = raw.toUpperCase();
+    const newIdx = upper.indexOf('NEW_TASK');
+    const contIdx = upper.indexOf('CONTINUATION');
+    if (newIdx < 0 && contIdx < 0)
+        return null;
+    if (newIdx < 0)
+        return 'CONTINUATION';
+    if (contIdx < 0)
+        return 'NEW_TASK';
+    // Both present — first one wins.
+    return newIdx < contIdx ? 'NEW_TASK' : 'CONTINUATION';
+}
+/** Title for a re-attributed prompt's new task (mirrors TaskSegmenter). */
+function extractTitle(prompt) {
+    const cleaned = prompt.replace(/\[Image #\d+\]/g, '').trim();
+    const firstLine = cleaned.split('\n')[0].trim();
+    if (firstLine.length <= 60)
+        return firstLine || '(无标题)';
+    return truncateString(firstLine, 60);
+}
+//# sourceMappingURL=task-boundary-classifier.js.map

package/dist/daemon/services/task-boundary-classifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-boundary-classifier.js","sourceRoot":"","sources":["../../../src/daemon/services/task-boundary-classifier.ts"],"names":[],"mappings":"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"}

package/dist/daemon/services/task-segmenter.d.ts

@@ -1,20 +1,238 @@
 import type { SQLiteStorage } from '../../core/storage/sqlite.js';
+/**
+ * Task-tracking overhaul (2026-05-27 spec §3.3 / §R4).
+ *
+ * Bug 3 orphan recovery window. When linkEvent fires without an active
+ * task (e.g. Stop already closed it but sub-agent PostToolUse is still
+ * landing), we attach the event to the most recently completed task on
+ * the session IF it ended within this window. Default 5 min — short
+ * enough to avoid cross-task mis-attribution, long enough to absorb
+ * typical async sub-agent tool flushes (observed 1-4 min in production).
+ *
+ * Exported as `const` (not env-tunable) on purpose: changing it changes
+ * KPI semantics and should be a code review event. R4 mitigation: pure
+ * attachment, end_time is NOT updated by the fallback path (Q3).
+ */
+export declare const ORPHAN_RECOVERY_WINDOW_MS: number;
+/**
+ * decision 265f59d5: result of a boundary decision. When `ambiguous` is set,
+ * the sync path best-effort MERGED `prompt`'s event into `taskId`, but lexical
+ * signals were inconclusive — the daemon should hand this off to the async
+ * {@link TaskBoundaryClassifier} for a possible re-attribution. When undefined,
+ * the decision was unambiguous (clear ack / clear new-task / hard signal) and
+ * no LLM call is warranted.
+ */
+export interface BoundaryDecision {
+    /** The task id the synchronous path assigned the prompt to. */
+    taskId: string;
+    /**
+     * Present only when the prompt was MERGED into an already-active task via the
+     * ambiguous default (no ack token, no NEW_TASK_KEYWORD, no hard signal).
+     */
+    ambiguous?: {
+        sessionId: string;
+        mergedTaskId: string;
+        eventId: string;
+        prompt: string;
+        timestamp: string;
+    };
+}
 export declare class TaskSegmenter {
     private storage;
     private currentTasks;
     constructor(storage: SQLiteStorage);
     processPrompt(sessionId: string, prompt: string, timestamp: string, eventId?: string): string;
-    linkEvent(sessionId: string, eventId: string): void;
+    /**
+     * decision 265f59d5: same synchronous best-effort segmentation as
+     * {@link processPrompt}, but also reports whether the result was an AMBIGUOUS
+     * merge so the daemon can enqueue an async LLM re-attribution. The hot path is
+     * unchanged — this returns immediately; the LLM call (if any) is the caller's
+     * fire-and-forget responsibility.
+     */
+    processPromptWithBoundary(sessionId: string, prompt: string, timestamp: string, eventId?: string): BoundaryDecision;
+    /**
+     * Attach a non-prompt event (PostToolUse / PreToolUse / Stop / spawn …) to the
+     * session's currently-open task and refresh `lastTime`.
+     *
+     * Refreshing `lastTime` here is the critical part of the long-flow fix
+     * (2026-05-25): without it, `shouldStartNewTask` only sees the gap between
+     * user prompts, so a 20-minute background-agent run with hundreds of tool
+     * calls looks identical to the user walking away. The next prompt then trips
+     * `TASK_SWITCH_MINUTES` and the post-spawn work gets re-attributed to a
+     * brand-new task — exactly the symptom seen in task 36471706.
+     *
+     * `timestamp` is optional for backward compatibility; callers that already
+     * know the event timestamp should pass it (we trust hook timestamps more
+     * than wall-clock here because event delivery can be queued/replayed).
+     */
+    linkEvent(sessionId: string, eventId: string, timestamp?: string, opts?: {
+        hookType?: string;
+        toolName?: string;
+    }): void;
     /**
      * 从数据库恢复 session 的 active 任务到内存 Map。
      * 用于 daemon 重启后内存丢失场景的 lazy 恢复。
      * 找不到 active 任务时返回 null（不报错）。
+     *
+     * spec b1480935 (2026-06-01 Option A): only `task_kind='user'` tasks are
+     * eligible — callback / image / system rows MUST NOT be re-installed as
+     * the session's "current task" or every subsequent event would attach
+     * to an envelope row. The legacy `!is_noise` guard is preserved as a
+     * fallback for rows where backfill hasn't yet promoted task_kind.
+     *
+     * Orphan-event robustness fix (2026-06-01): switched from
+     * `queryTasks(limit:5).find(...)` to a DIRECT `getActiveUserTask()` SQL
+     * lookup. The old path took the most-recent 5 rows THEN filtered — on a
+     * high-task-count session a burst of newer agent-callback / completed rows
+     * pushed the active user task out of the top-5, so `.find()` returned null
+     * and every event after it orphaned. The direct query applies the predicate
+     * at the DB layer with no LIMIT truncation.
      */
     private recoverActiveTask;
+    /**
+     * Orphan-event robustness fix (2026-06-01): proactively re-populate the
+     * in-memory `currentTasks` map from the DB at daemon startup.
+     *
+     * Problem: after a daemon restart `currentTasks` is empty, so every event
+     * relies on per-event lazy `recoverActiveTask`. During the restart window a
+     * burst of buffered + replayed events arrives; any whose recovery heuristic
+     * doesn't fire (e.g. the orphan-recovery smart window finds no completed
+     * task) gets dropped. Hydrating up-front means those events hit the fast
+     * `currentTasks.get()` path instead.
+     *
+     * Idempotent + fault-tolerant: safe to call multiple times (it overwrites
+     * with the same DB-derived state) and never throws — a query failure logs
+     * and leaves the map untouched so the daemon still starts.
+     *
+     * @returns number of sessions hydrated (useful for the startup log line).
+     */
+    hydrateActiveTasks(): number;
+    /**
+     * decision c6613590 P0 缺陷 B: trusted map-hit accessor.
+     *
+     * The in-memory `currentTasks` map can hold a DANGLING pointer to a task the
+     * stale-task GC (daemon/index.ts `completeStaleActiveTasks`) already flipped
+     * to status='completed' in the DB. The old code trusted any map hit blindly,
+     * so a new prompt / late event would `linkEventToTask` onto that completed
+     * row — advancing its end_time and merging independent prompts into a stale
+     * task.
+     *
+     * Two defences run together (spec: "两个都修最稳"):
+     *   1. daemon evicts GC'd ids from the map (see {@link evictTasks}); but a
+     *      daemon that never restarts can still race the 5-min GC tick.
+     *   2. THIS guard PK-rechecks `status='active'` before trusting a map hit.
+     *      If the row is no longer active, we drop the stale entry and fall back
+     *      to `recoverActiveTask` (DB-authoritative). This makes the map a cache,
+     *      never an authority, for the active-task invariant.
+     */
+    private getTrustedCurrent;
+    /**
+     * decision c6613590 P0 缺陷 B: evict the given task ids from the in-memory
+     * `currentTasks` map. Called by the daemon's stale-task GC after it flips
+     * those tasks to 'completed' in the DB, so the map never keeps a dangling
+     * pointer that drags a closed task's end_time forward.
+     *
+     * Keyed by sessionId (the map's key), but we also verify the mapped task id
+     * matches before deleting — a session whose active task was already replaced
+     * by a newer one must NOT have its live entry evicted just because an older
+     * task on the same session was GC'd.
+     *
+     * @returns number of map entries actually evicted (for the daemon log line).
+     */
+    evictTasks(closed: Array<{
+        id: string;
+        session_id: string;
+    }>): number;
     getCurrentTaskId(sessionId: string): string | null;
     completeCurrentTask(sessionId: string, timestamp: string): void;
+    /**
+     * Boundary decision for the synchronous path.
+     *
+     * spec 1713 (2026-05-28) introduced the hard-signal boundary
+     * ({@link shouldStartNewTaskHard}); spec b1480935 (2026-06-01) kept the
+     * legacy keyword heuristic for the live daemon. We UNION the two so the
+     * decision is the strictly-more-eager of the pair: a new task starts if
+     * EITHER an explicit hard signal fires (5-min window / RESET_KEYWORDS /
+     * sub-agent return) OR the legacy keyword heuristic asks for it. This keeps
+     * every previously-passing keyword case green while satisfying the spec-1713
+     * hard-signal contract. The async classifier (when wired) corrects any
+     * over- or under-split after the fact.
+     */
     private shouldStartNewTask;
+    /**
+     * spec 1713 §10.2: the hard-signal boundary. Returns true when an OBJECTIVE
+     * marker says "new task":
+     *   1. a sub-agent just returned (agentJustReturned flag) → consumes the flag
+     *   2. gap > HARD_TIME_WINDOW_MIN (5 min)
+     *   3. an explicit RESET_KEYWORD appears in the prompt
+     *
+     * Pure of keyword *heuristics* (NEW_TASK_KEYWORDS) — those live in the legacy
+     * path. Mutates `current.agentJustReturned` (clears it) by design: the flag
+     * is a one-shot that only forces the immediately-following prompt.
+     */
+    private shouldStartNewTaskHard;
     private createTask;
     private extractTitle;
 }
+/**
+ * Task-tracking overhaul (2026-05-27 spec §3.2).
+ *
+ * Compute the is_noise flag for a freshly-extracted task title. Three
+ * heuristics, all conservative — the goal is to drop obvious envelope /
+ * sub-3-char / slash-command noise WITHOUT eating real user prompts:
+ *
+ *   • length(trim(title)) < 3 — sub-3-char titles ('好的'=2, 'ok'=2,
+ *     single CJK char). Note: spec §3.2 lists '好的' as expected-noise
+ *     and '推送吧'=3 as expected-real; this matches.
+ *   • title matches one of NOISE_PROMPT_PREFIXES (envelope tags emitted
+ *     by the framework on UserPromptSubmit).
+ *   • title is a single-word slash command (`/help`, `/login`, …) — the
+ *     user didn't actually start a new task, they fired a CC slash menu.
+ *
+ * What this DOES NOT flag (intentional — spec §3.2):
+ *   - Semantic acknowledgements like '批准' / 'approve' / 'ok' / '可以'.
+ *     Those titles should never reach createTask once SpecGate.handle
+ *     Approval is wired in Step 6. If they DO arrive in the meantime
+ *     (e.g. test seeds, legacy bug, race), Web shows them so the user
+ *     can spot the regression rather than silently dropping them.
+ *
+ * Exported for unit-test reuse; the production caller is
+ * TaskSegmenter.createTask above.
+ */
+export declare function computeIsNoise(title: string): boolean;
+/**
+ * True if the prompt is actually a tool-generated envelope (task-notification,
+ * system-reminder, image attachment, etc.) rather than a real human prompt.
+ *
+ * Thin wrapper over the canonical {@link isNoisePrompt} (core/utils). Kept
+ * as a named export so existing imports stay stable; each consumer's
+ * "what to do with noise" decision still lives at the call site (spec-gate
+ * skips auto-spec, here we skip task creation).
+ */
+export declare function isNoisePromptForSegmenter(prompt: string): boolean;
+/**
+ * True if the prompt is a genuine short continuation / acknowledgement
+ * ("继续" / "好的，这样可以" / "对对对" / "ok" / "批准" …) that should resume
+ * a recently-completed task via the B+ smart-window gate.
+ *
+ * decision c6613590 P0 缺陷 A — the old implementation (and the now-retired
+ * `CONTINUE_KEYWORDS` table) was `CONTINUE_KEYWORDS.some(kw => prompt.includes(kw))`,
+ * a pure SUBSTRING match.
+ * Because the keyword list contained '不是' / '这个' / '那个' / '它' / '不对',
+ * ordinary NEW questions were mis-classified as continuations and merged into
+ * a stale task:
+ *   • "现在全链路是不是都顺了?知识库、skill都正常了吗"  → '不是' matched
+ *   • "这个任务怎么又丢了?老是丢数据不行啊"            → '这个' matched
+ *
+ * The fix has two layers, BOTH must hold:
+ *   1. Length gate — the trimmed prompt must be ≤ ACK_MAX_LEN. A genuine ack
+ *      is short; a multi-clause question is not.
+ *   2. Ack-token presence — an ACK_CONTINUE_KEYWORD (collision-prone tokens
+ *      removed) must appear in the (short) prompt.
+ *
+ * This keeps every real ack a continuation ("继续"/"好的，这样可以"/"对对对"/
+ * "好的可以这样做") while the two real-world merge bugs above now return false
+ * and correctly start a new task. Exported for unit-test reuse.
+ */
+export declare function isContinuationPrompt(prompt: string): boolean;
 //# sourceMappingURL=task-segmenter.d.ts.map

package/dist/daemon/services/task-segmenter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-segmenter.d.ts","sourceRoot":"","sources":["../../../src/daemon/services/task-segmenter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAmBlE,qBAAa,aAAa;IAGZ,OAAO,CAAC,OAAO;IAF3B,OAAO,CAAC,YAAY,CAAuD;gBAEvD,OAAO,EAAE,aAAa;IAE1C,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;IAoB7F,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAOnD;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAezB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIlD,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAU/D,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,YAAY;CAMrB"}
+{"version":3,"file":"task-segmenter.d.ts","sourceRoot":"","sources":["../../../src/daemon/services/task-segmenter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AA0ElE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,yBAAyB,QAAa,CAAC;AAEpD;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,SAAS,CAAC,EAAE;QACV,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED,qBAAa,aAAa;IAGZ,OAAO,CAAC,OAAO;IAF3B,OAAO,CAAC,YAAY,CAAoF;gBAEpF,OAAO,EAAE,aAAa;IAE1C,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;IAI7F;;;;;;OAMG;IACH,yBAAyB,CACvB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,gBAAgB;IA6GnB;;;;;;;;;;;;;;OAcG;IACH,SAAS,CACP,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,EAClB,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAC9C,IAAI;IAuDP;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,iBAAiB;IAczB;;;;;;;;;;;;;;;;OAgBG;IACH,kBAAkB,IAAI,MAAM;IAsB5B;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,MAAM;IAYrE,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIlD,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAU/D;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,kBAAkB;IA4B1B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,sBAAsB;IAe9B,OAAO,CAAC,UAAU;IA6BlB,OAAO,CAAC,YAAY;CAMrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAUrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEjE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAK5D"}