harnery 0.0.1 → 0.2.0

package/dist/core/agents/rules/stop-hook.js

@@ -0,0 +1,161 @@
+/**
+ * Stop-hook verdict: rule 1/3, 2/3, 3/3 enforcement evaluated
+ * from the canonical event stream alone (no transcript scan).
+ *
+ * Rule 1/3: `state.status_checked` event with matching turn boundary exists.
+ * Rule 2/3: latest `turn.stop` event has `status_box_present: true` (or the
+ *            stop currently firing carries that field via the in-flight event
+ *            agent-hook emits before the stop hook runs).
+ * Rule 3/3: `state.task_set` event with matching turn boundary exists.
+ *
+ * Pure-prose-turn exemption: when zero `tool.pre_use` events fire in
+ * the current turn, rules 1/3 and 3/3 do not apply. Rule 2/3 still applies
+ * as a user-visible mobile cue.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveBinName } from "../../config.js";
+function ackSignalFor(harness) {
+    return harness === "cursor" ? "status_checked" : "status_box_present";
+}
+const RECENT_EVENT_WINDOW_LINES = 5_000;
+/**
+ * Evaluate the Stop-hook verdict. Returns the first failing rule (or allow
+ * when all three pass). Soft-fails open when the event stream isn't
+ * readable, fail-open posture on a verdict failure.
+ */
+export function evaluateStopHook(coordRoot, req) {
+    if (req.bypass) {
+        return {
+            allow: true,
+            exit_code: 0,
+            rule: "stop-hook.bypass",
+            reason: "HARNERY_AGENT_COORD_BYPASS_STOP=1",
+        };
+    }
+    let events;
+    try {
+        events = readRecentEvents(coordRoot, RECENT_EVENT_WINDOW_LINES);
+    }
+    catch {
+        return {
+            allow: true,
+            exit_code: 0,
+            rule: "stop-hook.fail_open",
+            reason: "events.ndjson not readable; failing open",
+        };
+    }
+    const ownerEvents = events.filter((e) => e.instance_id === req.instance_id);
+    if (ownerEvents.length === 0) {
+        return {
+            allow: true,
+            exit_code: 0,
+            rule: "stop-hook.no_history",
+            reason: "no canonical events for this owner; defer to legacy or skip",
+        };
+    }
+    // Turn window: from the most recent user_prompt.submit (this owner) up to
+    // either the explicit now_ms or the last event we see. Fall back to a
+    // 5-minute window when no user_prompt.submit is in scope (fresh wiring,
+    // out-of-window prompt, etc.) so a stale stream doesn't silently pass.
+    const nowMs = req.now_ms ?? Date.now();
+    const lastUserPrompt = [...ownerEvents]
+        .reverse()
+        .find((e) => e.event_type === "user_prompt.submit");
+    const startMs = lastUserPrompt ? Date.parse(lastUserPrompt.ts) : nowMs - 5 * 60 * 1000;
+    const inTurn = ownerEvents.filter((e) => {
+        const t = Date.parse(e.ts);
+        return Number.isFinite(t) && t >= startMs && t <= nowMs;
+    });
+    const toolPreUseInTurn = inTurn.some((e) => e.event_type === "tool.pre_use");
+    const statusChecked = inTurn.some((e) => e.event_type === "state.status_checked");
+    const taskSet = inTurn.some((e) => e.event_type === "state.task_set");
+    // Rule 2/3: status_box_present on the most recent turn.stop for this owner.
+    // The turn.stop event fires from agent-hook stop, which is wired BEFORE
+    // the stop-hook verdict, so by the time we evaluate, the just-
+    // fired turn.stop is already in the stream.
+    const latestTurnStop = [...inTurn].reverse().find((e) => e.event_type === "turn.stop");
+    const boxPresent = latestTurnStop ? Boolean(latestTurnStop.data.status_box_present) : false;
+    // Harness-aware end-of-turn ack signal (see `ackSignalFor`). On Cursor the
+    // ack is `status_checked` (running `harn agents status` shows the box inline);
+    // on Claude Code / Codex it's the transcript-scanned `status_box_present`.
+    // The matching block helper carries the right "how to fix" message.
+    const ackSignal = ackSignalFor(req.harness);
+    const ackPresent = ackSignal === "status_checked" ? statusChecked : boxPresent;
+    const ackBlock = ackSignal === "status_checked" ? rule13Block : rule23Block;
+    // Pure-prose-turn exemption: only the ack signal applies. Parity
+    // across harnesses: CC requires the box; Cursor requires status_checked.
+    if (!toolPreUseInTurn) {
+        if (!ackPresent) {
+            return ackBlock();
+        }
+        return {
+            allow: true,
+            exit_code: 0,
+            rule: "stop-hook.pure_prose_pass",
+            reason: "no tool calls this turn; rules 1/3 + 3/3 skipped",
+        };
+    }
+    if (!statusChecked)
+        return rule13Block();
+    // On Cursor `ackPresent === statusChecked` (already true here), so this is a
+    // no-op and rule 2/3 is not enforced; on CC/Codex it's the box-paste check.
+    if (!ackPresent)
+        return ackBlock();
+    if (!taskSet)
+        return rule33Block();
+    return {
+        allow: true,
+        exit_code: 0,
+        rule: "stop-hook.pass",
+    };
+}
+function rule13Block() {
+    return {
+        allow: false,
+        exit_code: 2,
+        rule: "stop-hook.rule_1_3",
+        reason: `End-of-turn rule (1/3): no state.status_checked event found in this turn; run \`${resolveBinName()} agents status\` as your last tool call.`,
+    };
+}
+function rule23Block() {
+    return {
+        allow: false,
+        exit_code: 2,
+        rule: "stop-hook.rule_2_3",
+        reason: `End-of-turn rule (2/3): turn.stop did not see the agent-status box in your reply text. Paste the \`${resolveBinName()} agents status\` output verbatim as a fenced code block (the \`┌─ agent-\` prefix is the detection signal).`,
+    };
+}
+function rule33Block() {
+    return {
+        allow: false,
+        exit_code: 2,
+        rule: "stop-hook.rule_3_3",
+        reason: `End-of-turn rule (3/3): no state.task_set event found in this turn; run \`${resolveBinName()} agents set-task "<short focus>"\` to declare what you're working on. Pass an empty string if the turn was purely conversational.`,
+    };
+}
+/**
+ * Read the last N JSON lines from events.ndjson. The Stop-hook verdict needs
+ * just the most recent turn so we tail-read aggressively.
+ */
+function readRecentEvents(coordRoot, maxLines) {
+    const path = join(coordRoot, ".harnery", "events.ndjson");
+    if (!existsSync(path))
+        return [];
+    const raw = readFileSync(path, "utf8");
+    const lines = raw.split("\n");
+    const start = Math.max(0, lines.length - maxLines);
+    const out = [];
+    for (let i = start; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line?.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            /* skip malformed */
+        }
+    }
+    return out;
+}

package/dist/core/agents/session-events.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Command/narration event emitter for the coordination layer.
+ *
+ * `writeSessionEvent` emits command + narration events straight to the
+ * **canonical** `.harnery/events.ndjson` (alongside the hook events), which the
+ * `/live` web viewer reads. The exported surface (`writeSessionEvent`,
+ * `newCmdId`, `clampField`, `readLastIntent`) is stable so the session-tee
+ * middleware callers need no edits.
+ */
+/** Event types accepted by `writeSessionEvent`. Only the command stream +
+ * narration are emitted canonically; the coord/state types are accepted for
+ * call-site compatibility but are no-ops (the agents CLI emits those itself). */
+export type SessionEventType = "command_start" | "output" | "command_end" | "end_of_turn" | "hook_event" | "set_task" | "file_claim" | "file_release" | "peer_change" | "narration";
+/**
+ * Resolved path of the ndjson sidecar file. Lives inside `.harnery/` so a
+ * containerized reader can pick it up through a single bind mount.
+ */
+export declare function sessionEventsPath(): string;
+/** Random 8-char hex id for grouping output lines under a single command. */
+export declare function newCmdId(): string;
+/**
+ * Read the model's most recent `<intent>...</intent>` declaration from the
+ * intent-stamp file written by the PreToolUse hook. Returns null when the
+ * file is missing, empty, or contains the explicit `(no intent)` sentinel.
+ * Callers fall back to whatever default they want in that case.
+ *
+ * Path: `.harnery/.last-intent.<instance_id>` next to the agent's heartbeat.
+ */
+export declare function readLastIntent(instanceId?: string): string | null;
+/**
+ * Emit a session event. Command + narration events
+ * are written to the canonical `.harnery/events.ndjson`; the coord/state types
+ * are accepted for call-site compatibility but are no-ops here (the agents CLI
+ * emits those itself). Best-effort, never throws into the caller; a command
+ * must never break or slow on telemetry. The `agentName` arg is retained for
+ * the stable call signature (canonical events key on instance_id, not name).
+ */
+export declare function writeSessionEvent(type: SessionEventType, _agentName: string, fields?: Record<string, unknown>): void;
+/** Trim long values to keep individual events small. */
+export declare function clampField(v: string, max?: number): string;
+//# sourceMappingURL=session-events.d.ts.map

package/dist/core/agents/session-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-events.d.ts","sourceRoot":"","sources":["../../../src/core/agents/session-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AASH;;iFAEiF;AACjF,MAAM,MAAM,gBAAgB,GACxB,eAAe,GACf,QAAQ,GACR,aAAa,GACb,aAAa,GACb,YAAY,GACZ,UAAU,GACV,YAAY,GACZ,cAAc,GACd,aAAa,GACb,WAAW,CAAC;AAEhB;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAwB1C;AAED,6EAA6E;AAC7E,wBAAgB,QAAQ,IAAI,MAAM,CAEjC;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA8BjE;AAsGD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACnC,IAAI,CAEN;AAED,wDAAwD;AACxD,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAAO,GAAG,MAAM,CAGxD"}

package/dist/core/agents/session-events.js

@@ -0,0 +1,205 @@
+/**
+ * Command/narration event emitter for the coordination layer.
+ *
+ * `writeSessionEvent` emits command + narration events straight to the
+ * **canonical** `.harnery/events.ndjson` (alongside the hook events), which the
+ * `/live` web viewer reads. The exported surface (`writeSessionEvent`,
+ * `newCmdId`, `clampField`, `readLastIntent`) is stable so the session-tee
+ * middleware callers need no edits.
+ */
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+// Kept dependency-light: vendored verbatim into a downstream consumer, so no coordEnv import.
+import { normalizeHarness } from "./canonical-emit.js";
+import { emit } from "./events/emit.js";
+/**
+ * Resolved path of the ndjson sidecar file. Lives inside `.harnery/` so a
+ * containerized reader can pick it up through a single bind mount.
+ */
+export function sessionEventsPath() {
+    // Explicit override (tests + non-monorepo invocations).
+    const explicit = process.env.HARNERY_OUTPUT_SESSION_EVENTS;
+    if (explicit)
+        return explicit;
+    // Walk up looking for an EXISTING .harnery/ directory; only match dirs
+    // (submodule .git is a file/gitlink, and CLAUDE.md / AGENTS.md can
+    // proliferate per-subdirectory in many monorepos, so neither is a safe
+    // anchor). Don't reintroduce CLAUDE.md / .git as anchors, which creates
+    // stray .harnery/ dirs under submodule subtrees.
+    let dir = process.cwd();
+    for (let i = 0; i < 10; i++) {
+        const candidate = resolve(dir, ".harnery");
+        try {
+            if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+                return resolve(candidate, "session-events.ndjson");
+            }
+        }
+        catch {
+            /* keep walking */
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return resolve(process.env.HOME || "/tmp", ".harnery", "session-events.ndjson");
+}
+/** Random 8-char hex id for grouping output lines under a single command. */
+export function newCmdId() {
+    return randomBytes(4).toString("hex");
+}
+/**
+ * Read the model's most recent `<intent>...</intent>` declaration from the
+ * intent-stamp file written by the PreToolUse hook. Returns null when the
+ * file is missing, empty, or contains the explicit `(no intent)` sentinel.
+ * Callers fall back to whatever default they want in that case.
+ *
+ * Path: `.harnery/.last-intent.<instance_id>` next to the agent's heartbeat.
+ */
+export function readLastIntent(instanceId) {
+    if (!instanceId)
+        return null;
+    // Walk up from cwd looking for .harnery/, same resolution as
+    // sessionEventsPath() (only match existing directories).
+    let dir = process.cwd();
+    let agentsDir = null;
+    for (let i = 0; i < 10; i++) {
+        const candidate = resolve(dir, ".harnery");
+        try {
+            if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+                agentsDir = candidate;
+                break;
+            }
+        }
+        catch {
+            /* keep walking */
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    if (!agentsDir)
+        return null;
+    const intentPath = resolve(agentsDir, `.last-intent.${instanceId}`);
+    if (!existsSync(intentPath))
+        return null;
+    try {
+        const raw = readFileSync(intentPath, "utf8").trim();
+        if (!raw || raw === "(no intent)")
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Dual-write: mirror command/narration session-events
+ * into the canonical `.harnery/events.ndjson` stream so the legacy
+ * session-events.ndjson writer + its web consumers can be retired.
+ * Only the command-stream + narration types migrate; the coord/state types
+ * (`set_task`, `file_claim`, `peer_change`, …) are already emitted canonically
+ * by the agents CLI, so re-emitting them here would double-count.
+ */
+const CANONICAL_TYPE = {
+    command_start: "command.start",
+    output: "command.output",
+    command_end: "command.end",
+    narration: "narration",
+};
+/** Cache heartbeat-derived envelope fields per instance_id so a burst of
+ * `output` lines (one event per stdout line) doesn't re-read + re-parse the
+ * heartbeat JSON each time. Short TTL: picks up platform/session changes
+ * within a few seconds without hammering the disk on a chatty command. */
+const enrichCache = new Map();
+const ENRICH_TTL_MS = 5000;
+function enrichFromHeartbeat(coordRoot, instanceId) {
+    const now = Date.now();
+    const cached = enrichCache.get(instanceId);
+    if (cached && now - cached.at < ENRICH_TTL_MS)
+        return cached;
+    try {
+        const hbPath = resolve(coordRoot, ".harnery", "active", `${instanceId}.json`);
+        if (!existsSync(hbPath))
+            return null;
+        const hb = JSON.parse(readFileSync(hbPath, "utf8"));
+        const enrichment = {
+            session_id: hb.session_id || instanceId,
+            harness: normalizeHarness(hb.platform),
+            at: now,
+        };
+        enrichCache.set(instanceId, enrichment);
+        return enrichment;
+    }
+    catch {
+        return null;
+    }
+}
+/** Project the flat legacy `fields` into the canonical event's `data` shape.
+ * Unknown types never reach here, guarded by CANONICAL_TYPE. */
+function canonicalData(type, fields) {
+    switch (type) {
+        case "command_start":
+            return { cmd_id: fields.cmd_id, intent: fields.intent, cmd: fields.cmd };
+        case "output":
+            return { cmd_id: fields.cmd_id, stream: fields.stream, line: fields.line };
+        case "command_end":
+            return {
+                cmd_id: fields.cmd_id,
+                exit: fields.exit,
+                duration_ms: fields.duration_ms,
+                ...(fields.signal ? { signal: fields.signal } : {}),
+            };
+        case "narration":
+            return { message: fields.message };
+        default:
+            return {};
+    }
+}
+/** Emit a command/narration event to the canonical stream. Swallows every
+ * error and skips when identity can't be resolved: telemetry must never break
+ * (or slow down) a command. Non-command types return early. */
+function emitCanonicalCommand(type, fields) {
+    const eventType = CANONICAL_TYPE[type];
+    if (!eventType)
+        return;
+    const instanceId = typeof fields.instance_id === "string" ? fields.instance_id : undefined;
+    if (!instanceId)
+        return;
+    try {
+        // coordRoot = the dir containing `.harnery/`; sessionEventsPath() anchors it.
+        const coordRoot = dirname(dirname(sessionEventsPath()));
+        const enrich = enrichFromHeartbeat(coordRoot, instanceId);
+        if (!enrich)
+            return;
+        emit(coordRoot, {
+            event_type: eventType,
+            instance_id: instanceId,
+            session_id: enrich.session_id,
+            harness: enrich.harness,
+            data: canonicalData(type, fields),
+        });
+    }
+    catch {
+        /* telemetry only, never break the command */
+    }
+}
+/**
+ * Emit a session event. Command + narration events
+ * are written to the canonical `.harnery/events.ndjson`; the coord/state types
+ * are accepted for call-site compatibility but are no-ops here (the agents CLI
+ * emits those itself). Best-effort, never throws into the caller; a command
+ * must never break or slow on telemetry. The `agentName` arg is retained for
+ * the stable call signature (canonical events key on instance_id, not name).
+ */
+export function writeSessionEvent(type, _agentName, fields = {}) {
+    emitCanonicalCommand(type, fields);
+}
+/** Trim long values to keep individual events small. */
+export function clampField(v, max = 1024) {
+    if (v.length <= max)
+        return v;
+    return `${v.slice(0, max - 1)}…`;
+}

package/dist/core/agents/state/activity-log.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Display-name resolution for the coord layer.
+ *
+ * This module once housed `coordLog`, the writer for a human-readable
+ * activity log. That log has been retired; the canonical
+ * `.harnery/events.ndjson` stream is the single source of truth, and the
+ * per-event telemetry that had consumers (heals → health.*, councils →
+ * council.*, shell-mutation candidates → decision.warn) is emitted there
+ * directly. `coordLog` and its call sites are gone; only `resolveShortName`
+ * remains (still used for display-name resolution).
+ */
+/**
+ * Resolve `agent-<name>` display string. Looks up the heartbeat's `name`
+ * field; falls back to `agent-<8-char-hex>` if name is empty (mirrors bash
+ * coord_owner_short). Returns `agent-unknown` when instanceId is null.
+ */
+export declare function resolveShortName(coordRoot: string, instanceId: string | null): string;
+//# sourceMappingURL=activity-log.d.ts.map

package/dist/core/agents/state/activity-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-log.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/state/activity-log.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAYrF"}

package/dist/core/agents/state/activity-log.js

@@ -0,0 +1,34 @@
+/**
+ * Display-name resolution for the coord layer.
+ *
+ * This module once housed `coordLog`, the writer for a human-readable
+ * activity log. That log has been retired; the canonical
+ * `.harnery/events.ndjson` stream is the single source of truth, and the
+ * per-event telemetry that had consumers (heals → health.*, councils →
+ * council.*, shell-mutation candidates → decision.warn) is emitted there
+ * directly. `coordLog` and its call sites are gone; only `resolveShortName`
+ * remains (still used for display-name resolution).
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Resolve `agent-<name>` display string. Looks up the heartbeat's `name`
+ * field; falls back to `agent-<8-char-hex>` if name is empty (mirrors bash
+ * coord_owner_short). Returns `agent-unknown` when instanceId is null.
+ */
+export function resolveShortName(coordRoot, instanceId) {
+    if (!instanceId)
+        return "agent-unknown";
+    const path = join(coordRoot, ".harnery", "active", `${instanceId}.json`);
+    if (existsSync(path)) {
+        try {
+            const hb = JSON.parse(readFileSync(path, "utf8"));
+            if (hb.name && hb.name.length > 0)
+                return `agent-${hb.name}`;
+        }
+        catch {
+            /* fall through to short-id */
+        }
+    }
+    return `agent-${instanceId.slice(0, 8)}`;
+}

package/dist/core/agents/state/council.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Council manifest mutations: lifecycle helpers for the council-* actions.
+ *
+ * A council is a multi-round debate among agents recorded at
+ * `.harnery/councils/<id>.json` (manifest) plus `.harnery/councils/<id>/round-N/<member>.md`
+ * (contributions). Archive moves both into `.harnery/councils/archive/`.
+ *
+ * This module owns: lifecycle (advance, close, archive, unarchive, delete)
+ * and steward reassignment. Council CREATION + contribution writes stay
+ * separate (operator-side, harness-agnostic).
+ */
+export declare function advanceCouncil(coordRoot: string, councilId: string, opts?: {
+    force?: boolean;
+}): {
+    ok: boolean;
+    reason?: string;
+    pendingMember?: string;
+};
+export declare function closeCouncil(coordRoot: string, councilId: string): {
+    ok: boolean;
+    reason?: string;
+};
+export declare function archiveCouncil(coordRoot: string, councilId: string): {
+    ok: boolean;
+    reason?: string;
+};
+export declare function unarchiveCouncil(coordRoot: string, councilId: string): {
+    ok: boolean;
+    reason?: string;
+};
+export declare function deleteCouncil(coordRoot: string, councilId: string): {
+    ok: boolean;
+    reason?: string;
+};
+export declare function setCouncilSteward(coordRoot: string, councilId: string, newSteward: string, newStewardId: string): {
+    ok: boolean;
+    reason?: string;
+};
+//# sourceMappingURL=council.d.ts.map

package/dist/core/agents/state/council.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"council.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/state/council.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAwDH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAC7B;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,CAuC1D;AAED,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAalC;AAED,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAoClC;AAED,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAqClC;AAED,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAmBlC;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,GACnB;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAuBlC"}