@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/features/magic-context/memory/storage-memory-verifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-memory-verifications.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/storage-memory-verifications.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAE/C,wFAAwF;AACxF,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,wBAAwB,CAAC;AAEtE,MAAM,WAAW,uBAAuB;IACpC,4EAA4E;IAC5E,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,oEAAoE;IACpE,WAAW,EAAE,OAAO,CAAC;IACrB,2DAA2D;IAC3D,aAAa,EAAE,mBAAmB,CAAC;IACnC;uFACmF;IACnF,UAAU,EAAE,MAAM,CAAC;IACnB,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,CAAC;CACpB;AAgBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAC/B,EAAE,EAAE,QAAQ,EACZ,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,SAAS,MAAM,EAAE,EAClC,GAAG,EAAE,MAAM,EACX,aAAa,GAAE,mBAA8B,GAC9C,MAAM,CAWR;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACrC,EAAE,EAAE,QAAQ,EACZ,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,SAAS,MAAM,EAAE,EAClC,GAAG,EAAE,MAAM,GACZ,MAAM,CAWR;AAED;mCACmC;AACnC,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAUzF;AAED,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAE7E;AAED,wBAAgB,sBAAsB,CAClC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,SAAS,MAAM,EAAE,GAC7B,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAuCtC"}

package/dist/features/magic-context/memory/storage-memory.d.ts

@@ -0,0 +1,89 @@
+import type { Database } from "../../../shared/sqlite";
+import type { Memory, MemoryCategory, MemoryInput, MemoryScope, MemoryStatus, VerificationStatus } from "./types";
+export declare const COLUMN_MAP: Record<keyof Memory, string>;
+export interface MemoryCountsByStatus {
+    total: number;
+    active: number;
+    permanent: number;
+    archived: number;
+    merged: number;
+    ids: number[];
+    archivedIds: number[];
+    mergedIds: number[];
+}
+export interface InsertMemoryResult {
+    memory: Memory;
+    inserted: boolean;
+}
+export declare function hasMemoryShareableColumn(db: Database): boolean;
+export declare function hasMemoryClassifiedAtColumn(db: Database): boolean;
+/** Memory ids (from the given set) that have never been classified — the
+ *  classify-memories run-gate + Stage-3 "to-classify" partition. */
+export declare function getUnclassifiedMemoryIds(db: Database, memoryIds: readonly number[]): number[];
+export declare function getMemorySelectColumns(db: Database, tableName?: string): string;
+export declare function isMemoryRow(row: unknown): row is Memory;
+export declare function toMemory(row: Memory): Memory;
+export declare class ModuleMemoryAuthorityError extends Error {
+    readonly projectPath: string;
+    readonly code = "MEMORY_MODULE_AUTHORITY";
+    constructor(projectPath: string);
+}
+export declare function insertMemory(db: Database, input: MemoryInput): Memory;
+/**
+ * Shared-DB callers can race between their exact-hash pre-check and INSERT. When
+ * the unique constraint wins, treat it as the same exact-dedup path the tool uses:
+ * bump seen_count/last_seen_at on the existing row and return it instead of
+ * surfacing a transient write failure.
+ */
+export declare function insertMemoryIdempotent(db: Database, input: MemoryInput): InsertMemoryResult;
+export declare function getMemoryByHash(db: Database, projectPath: string, category: MemoryCategory, normalizedHash: string): Memory | null;
+export declare function getMemoriesByProject(db: Database, projectPath: string, statuses?: MemoryStatus[], expiryCutoff?: number): Memory[];
+/** Read a bounded tool list in the same order and with the same row validation
+ * as the full project reader. Invalid legacy rows must not consume the limit. */
+export declare function getMemoriesForList(db: Database, projectPath: string, categories: readonly string[] | null, limit: number): Memory[];
+export interface WorkspaceMemorySqlFilter {
+    clause: string;
+    params: string[];
+    active: boolean;
+    /** Canonical policy text retained for parity/golden checks across render paths. */
+    predicate: string;
+}
+export declare function buildWorkspaceMemorySqlFilter(args: {
+    identities: readonly string[];
+    ownIdentities?: readonly string[];
+    shareCategories?: readonly string[] | null;
+    tableName?: string;
+    includeClassificationFields?: boolean;
+}): WorkspaceMemorySqlFilter;
+export declare function getMemoriesByProjects(db: Database, projectPaths: readonly string[], statuses?: MemoryStatus[], expiryCutoff?: number, ownIdentities?: readonly string[], shareCategories?: readonly string[] | null): Memory[];
+export declare function getMaxMemoryIdForProjects(db: Database, projectPaths: readonly string[], ownIdentities?: readonly string[], shareCategories?: readonly string[] | null, expiryCutoff?: number): number;
+export declare function readNewMemoriesForM1Union(db: Database, projectPaths: readonly string[], afterId: number, expiryCutoff: number, ownIdentities?: readonly string[], shareCategories?: readonly string[] | null): Memory[];
+export declare function getAllActiveMemoriesForMigration(db: Database, projectPath: string): Memory[];
+export declare function getMemoryById(db: Database, id: number): Memory | null;
+/** Load multiple memories by id in one positional-bind statement.
+ *
+ *  Returns whatever rows exist; missing ids are simply absent from the result.
+ *  Visibility (own project vs foreign workspace + share category) is the
+ *  caller's job — this helper does not enforce it. The tool layer applies the
+ *  same union-read predicate used by every other read path (`memoryVisibleToTool`)
+ *  and reports not-found / not-visible ids with one opaque per-id message, so
+ *  foreign memory existence is never leaked. */
+export declare function getMemoriesByIds(db: Database, ids: readonly number[]): Memory[];
+export declare function updateMemorySeenCount(db: Database, id: number): void;
+export declare function updateMemoryRetrievalCount(db: Database, id: number): void;
+export declare function updateMemoryStatus(db: Database, id: number, status: MemoryStatus): void;
+export declare function updateMemoryVerification(db: Database, id: number, verificationStatus: VerificationStatus): void;
+export declare function updateMemoryContent(db: Database, id: number, content: string, normalizedHash: string): void;
+export interface MemoryClassificationUpdate {
+    importance?: number;
+    scope?: MemoryScope;
+    shareable?: boolean;
+}
+export declare function setMemoryClassification(db: Database, id: number, classification: MemoryClassificationUpdate): boolean;
+export declare function supersededMemory(db: Database, id: number, supersededById: number): void;
+export declare function mergeMemoryStats(db: Database, id: number, seenCount: number, retrievalCount: number, mergedFrom: string, status: MemoryStatus): void;
+export declare function archiveMemory(db: Database, id: number, reason?: string): void;
+export declare function deleteMemory(db: Database, id: number): void;
+export declare function getMemoryCount(db: Database, projectPath?: string): number;
+export declare function getMemoryCountsByStatus(db: Database, projectPath: string): MemoryCountsByStatus;
+//# sourceMappingURL=storage-memory.d.ts.map

package/dist/features/magic-context/memory/storage-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-memory.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/storage-memory.ts"],"names":[],"mappings":"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"}

package/dist/features/magic-context/memory/types.d.ts

@@ -0,0 +1,59 @@
+export type MemoryCategory = "PROJECT_RULES" | "ARCHITECTURE" | "CONFIG_VALUES" | "ARCHITECTURE_DECISIONS" | "CONSTRAINTS" | "CONFIG_DEFAULTS" | "NAMING" | "USER_PREFERENCES" | "USER_DIRECTIVES" | "ENVIRONMENT" | "WORKFLOW_RULES" | "KNOWN_ISSUES";
+export type MemoryStatus = "active" | "permanent" | "archived";
+export type MemoryScope = "project" | "ecosystem" | "universe";
+export type VerificationStatus = "unverified" | "verified" | "stale" | "flagged";
+/**
+ * Provenance of a memory row.
+ *
+ * `"user"` is intentionally RESERVED, not dead: it exists for FUTURE manual
+ * memory entries authored through the dashboard (user-typed rows), which were
+ * designed but never implemented. It must NEVER be written by the agent
+ * (historian/tool) write paths — origin provenance matters to the
+ * agent and historian dedup, so agent-originated memories
+ * must never carry `"user"`. `insertMemory` enforces this at the write
+ * boundary.
+ *
+ * Note: "was this addition user-ignited" is a SEPARATE future concern from
+ * `sourceType`. A prompt-driven agent write made at the user's request is
+ * still `sourceType: "agent"` (or `"tool"`); user-ignition would be carried
+ * by a distinct field if it is ever needed.
+ */
+export type MemorySourceType = "historian" | "agent" | "maintenance" | "user";
+export interface Memory {
+    id: number;
+    projectPath: string;
+    category: MemoryCategory;
+    content: string;
+    normalizedHash: string;
+    importance: number;
+    scope: MemoryScope;
+    /** SQLite INTEGER boolean: 1 = shareable, 0 = private. */
+    shareable: number;
+    sourceSessionId: string | null;
+    sourceType: MemorySourceType;
+    seenCount: number;
+    retrievalCount: number;
+    firstSeenAt: number;
+    createdAt: number;
+    updatedAt: number;
+    lastSeenAt: number;
+    lastRetrievedAt: number | null;
+    status: MemoryStatus;
+    expiresAt: number | null;
+    verificationStatus: VerificationStatus;
+    verifiedAt: number | null;
+    supersededByMemoryId: number | null;
+    mergedFrom: string | null;
+    metadataJson: string | null;
+}
+export interface MemoryInput {
+    projectPath: string;
+    category: MemoryCategory;
+    content: string;
+    importance?: number | null;
+    sourceSessionId?: string;
+    sourceType?: MemorySourceType;
+    expiresAt?: number | null;
+    metadataJson?: string | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/features/magic-context/memory/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAIpB,eAAe,GACf,cAAc,GACd,eAAe,GAIf,wBAAwB,GACxB,aAAa,GACb,iBAAiB,GACjB,QAAQ,GACR,kBAAkB,GAClB,iBAAiB,GACjB,aAAa,GACb,gBAAgB,GAChB,cAAc,CAAC;AAErB,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,CAAC;AAC/D,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAC;AAC/D,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG,UAAU,GAAG,OAAO,GAAG,SAAS,CAAC;AACjF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG,OAAO,GAAG,aAAa,GAAG,MAAM,CAAC;AAE9E,MAAM,WAAW,MAAM;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,cAAc,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,WAAW,CAAC;IACnB,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,MAAM,EAAE,YAAY,CAAC;IACrB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,WAAW;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,cAAc,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC"}

package/dist/features/magic-context/memory/verification-paths.d.ts

@@ -0,0 +1,48 @@
+interface VerificationPathsExecOptions {
+    cwd: string;
+    timeout: number;
+    maxBuffer: number;
+    encoding: BufferEncoding;
+    windowsHide: true;
+}
+type VerificationPathsExecResult = {
+    stdout: string | Buffer;
+    stderr: string | Buffer;
+};
+type VerificationPathsExecFile = (file: string, args: readonly string[], options: VerificationPathsExecOptions) => Promise<VerificationPathsExecResult>;
+export interface NormalizedVerificationFiles {
+    files: string[];
+    warnings: string[];
+    gitRoot: string | null;
+}
+export declare function resolveGitTopLevel(cwd: string): Promise<string | null>;
+export declare function readGitHead(cwd: string): Promise<string | null>;
+export declare function readGitChangedFilesSince(cwd: string, revision: string, knownGitRoot?: string): Promise<Set<string> | null>;
+/**
+ * Map each repo file changed at/after `sinceMs` to its LATEST commit time (ms).
+ * Drives the per-memory verify gate: a memory needs re-verification if any of
+ * its mapped files has a change time newer than that memory's `verified_at`.
+ *
+ * Returns null on any git failure → caller falls back to full verification
+ * (safe direction: re-check rather than skip). Output excludes the working tree;
+ * a file edited but uncommitted is caught separately by `verificationFileExists`
+ * (deletion) — verify reads the live file regardless, so uncommitted edits are
+ * surfaced when the file is opened. The committed-history map is what lets the
+ * gate cheaply SKIP unchanged memories.
+ */
+export declare function readGitFileChangeTimesSince(cwd: string, sinceMs: number, knownGitRoot?: string): Promise<Map<string, number> | null>;
+export declare function verificationFileExists(baseRoot: string, filePath: string): boolean;
+/**
+ * Normalize agent-supplied verification paths into repo-root-relative Git paths.
+ * Non-git projects fall back to cwd-relative existing files; their gate full-runs.
+ */
+export declare function normalizeVerificationFiles(args: {
+    cwd: string;
+    files: readonly string[];
+}): Promise<NormalizedVerificationFiles>;
+export declare function __setVerificationPathsTestHooks(hooks: {
+    execFile?: VerificationPathsExecFile;
+}): void;
+export declare function __resetVerificationPathsForTests(): void;
+export {};
+//# sourceMappingURL=verification-paths.d.ts.map

package/dist/features/magic-context/memory/verification-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-paths.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/verification-paths.ts"],"names":[],"mappings":"AAQA,UAAU,4BAA4B;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,EAAE,IAAI,CAAC;CACrB;AAED,KAAK,2BAA2B,GAAG;IAC/B,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CAC3B,CAAC;AAEF,KAAK,yBAAyB,GAAG,CAC7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,4BAA4B,KACpC,OAAO,CAAC,2BAA2B,CAAC,CAAC;AAc1C,MAAM,WAAW,2BAA2B;IACxC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AA6CD,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAI5E;AAED,wBAAsB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAIrE;AAED,wBAAsB,wBAAwB,CAC1C,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAO7B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,2BAA2B,CAC7C,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,YAAY,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,CA6BrC;AAuBD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAKlF;AAED;;;GAGG;AACH,wBAAsB,0BAA0B,CAAC,IAAI,EAAE;IACnD,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAkHvC;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE;IACnD,QAAQ,CAAC,EAAE,yBAAyB,CAAC;CACxC,GAAG,IAAI,CAKP;AAED,wBAAgB,gCAAgC,IAAI,IAAI,CAEvD"}

package/dist/features/magic-context/memory/visibility.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Canonical foreign-memory visibility predicate. Keep this text byte-identical to
+ * mc-store's FOREIGN_VISIBLE_SQL so render, delta, search, and revocation use one rule.
+ */
+export declare const FOREIGN_VISIBLE_SQL = "status IN ('active','permanent') AND (expires_at IS NULL OR expires_at > :now_ms) AND shareable = 1 AND scope IN ('project','ecosystem','universe') AND category IN (SELECT value FROM json_each(:share_categories)) AND project_path IN (SELECT project_path FROM workspace_members WHERE workspace_id = :workspace_id) AND project_path <> :reader_project";
+//# sourceMappingURL=visibility.d.ts.map

package/dist/features/magic-context/memory/visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory/visibility.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,mBAAmB,iWACkU,CAAC"}

package/dist/features/magic-context/memory-maintainer/apply.d.ts

@@ -0,0 +1,65 @@
+import type { Database } from "../../../shared/sqlite";
+import type { PoolItemRef } from "./coverage";
+import type { ManifestItem } from "./manifest";
+import type { ApplyOutcome } from "./pipeline";
+/**
+ * The REAL host apply for maintenance suggestions (plan 10 §4.5, P3; decision
+ * 23: one shared-core implementation for both hosts). Drop-in replacement for
+ * the P1 {@link makeBookkeepingApplySeam} bookkeeping stub — same seam shape,
+ * same {@link ApplyOutcome} contract — but every applied action actually writes,
+ * audited per decision 17.
+ *
+ * Per-action semantics:
+ *   - EVERY action runs as a SHORT `BEGIN IMMEDIATE` transaction; the semantic
+ *     snapshot check (decision 13: content hash + category + status, never
+ *     `updated_at`) re-reads the row INSIDE the lock, so the check and the
+ *     write are one atomic step. Mismatch → explicit skip reported as
+ *     `concurrent-modification` (the pipeline ledgers it `deferred_concurrent`
+ *     and hands the item to the next round). No LLM work ever sits in a
+ *     transaction.
+ *   - Ownership fencing (§4.5): when the run's lease context is provided, the
+ *     holder + generation are re-validated inside the same lock; a lost lease
+ *     throws (D4 — never record success after losing the claim).
+ *   - UNIQUE(project_path, category, normalized_hash) collisions are caught
+ *     and surfaced as explicit `unique-conflict` skips naming the conflicting
+ *     row — mirroring the OC2 mmc_memory write shape (probe inside the same
+ *     BEGIN IMMEDIATE + `isUniqueConstraintError` catch). The Pi tool's
+ *     out-of-transaction probe without a catch is NOT inherited (§10.4).
+ *   - Auditing (decision 17): each applied action merges a `maintenance` key
+ *     into the row's `metadata_json` (read-modify-write that preserves unknown
+ *     keys; a parse failure resets the base tolerantly) carrying the action,
+ *     runId, reason, evidence, and the full before-image. Merge records the
+ *     complete source group plus the target's before state.
+ *   - m[1] deltas ride `queueMemoryMutation`; the m[0] baseline only moves on
+ *     the next natural HARD fold (automatic maintenance never busts the cache).
+ *
+ * Recovery for these rows lives in `scripts/restore-maintenance-archives.ts`
+ * (decision 21: the restore path must exist BEFORE automatic apply is enabled;
+ * gate-4 M2: archive and update classes are reverted from the before-image,
+ * merge groups follow the manual runbook in the script's --help).
+ */
+/** Lease identity re-validated inside every apply transaction (§4.5 fencing). */
+export interface ValidatingApplyLease {
+    holderId: string;
+    leaseKey: string;
+    generation: number;
+}
+export interface ValidatingApplySeamOptions {
+    /** Round-snapshot lookup (decision 13 fields), as in the bookkeeping seam. */
+    snapshotRef(id: number): PoolItemRef | undefined;
+    /** Run telemetry id recorded into each `maintenance` audit blob. */
+    runId?: number | null;
+    /** Injected clock — never a bare Date.now in tests. */
+    nowMs?: () => number;
+    /** In-lock fencing; omitted by direct unit callers without a live run. */
+    lease?: ValidatingApplyLease;
+}
+/**
+ * Build the audited, snapshot-checked apply seam. Contract-compatible with
+ * the P1 bookkeeping seam (`MaintenanceSeams.applyItems`): one outcome per
+ * manifest item, keyed by the primary id (targetId for merge groups), in item
+ * order. `changedRows` counts rows ACTUALLY written (merge groups: the whole
+ * member set), consumed by the pipeline's anomaly dual gate and telemetry.
+ */
+export declare function makeValidatingApplySeam(db: Database, projectPath: string, options: ValidatingApplySeamOptions): (items: readonly ManifestItem[]) => ApplyOutcome[];
+//# sourceMappingURL=apply.d.ts.map

package/dist/features/magic-context/memory-maintainer/apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory-maintainer/apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAgBvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,iFAAiF;AACjF,MAAM,WAAW,oBAAoB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,0BAA0B;IACvC,8EAA8E;IAC9E,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;IACjD,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;IACrB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAicD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACnC,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,0BAA0B,GACpC,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,KAAK,YAAY,EAAE,CAkBpD"}

package/dist/features/magic-context/memory-maintainer/budget.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Run-level four-dimensional budget meter for the memory maintainer (plan 10,
+ * D9 — this shape is fork-owned; the upstream token-budget.ts only counts
+ * provider-reported prompt tokens). Default initial values follow plan 10
+ * decision 9 (provisional, calibrated in P3/P4).
+ *
+ * Semantics:
+ *   - `finalize` fires the first time ANY dimension reaches >= 80% of its
+ *     budget, and LATCHES (finalizeFired stays true for the rest of the run).
+ *   - `stop` when any dimension reaches >= 100%, or after >= 2 refused tool
+ *     steps, or an explicit forceStop().
+ *
+ * Latch red line (upstream banked=0 incident, plan 10 §3/§4.5): once finalize
+ * has fired, already-completed legal results must NEVER be discarded because
+ * usage later crosses the line. The meter only decides whether NEW work may be
+ * opened (shouldContinue) and whether tool calls get refused; it is a
+ * bookkeeping gate, not an arbiter of finished work. Callers bank completed
+ * results regardless of any later state this meter reports.
+ */
+export interface MaintenanceBudget {
+    /** Input dimension, in the upstream token-budget accounting: input + cacheRead + cacheWrite, summed by the caller. */
+    inputTokens: number;
+    outputTokens: number;
+    toolSteps: number;
+    wallMs: number;
+}
+export interface BudgetUsageDelta {
+    inputTokens?: number;
+    outputTokens?: number;
+}
+export type BudgetDecision = "continue" | "finalize" | "stop";
+export interface BudgetSpent {
+    inputTokens: number;
+    outputTokens: number;
+    toolSteps: number;
+    wallMs: number;
+}
+export interface BudgetState {
+    spent: BudgetSpent;
+    finalizeFired: boolean;
+    hardStopped: boolean;
+}
+export interface ToolStepRefusal {
+    message: string;
+    hardStopped: boolean;
+}
+export declare class BudgetMeter {
+    private readonly budget;
+    private readonly nowMs;
+    private readonly startedAtMs;
+    private spent;
+    private finalizeLatched;
+    private hardStoppedLatch;
+    private forcedStop;
+    private refusedToolSteps;
+    constructor(budget: MaintenanceBudget, nowMs?: () => number);
+    /** Input dimension is caller-summed (input + cacheRead + cacheWrite); this module only adds. */
+    recordUsage(delta: BudgetUsageDelta): void;
+    recordToolStep(): void;
+    /**
+     * Refuse one tool step because the budget no longer admits new work.
+     * The second refusal hard-stops the run (latching): a model that keeps
+     * calling tools past a finalize signal is not winding down.
+     */
+    refuseToolStep(): ToolStepRefusal;
+    /** External kill switch (host teardown, provider circuit breaker, ...). */
+    forceStop(): void;
+    shouldContinue(): BudgetDecision;
+    getState(): BudgetState;
+    private readings;
+    private describeStop;
+}
+/** Provisional run-budget defaults (plan 10 decision 9; P3/P4 calibrate). */
+export declare const DEFAULT_MAINTENANCE_BUDGET: MaintenanceBudget;
+//# sourceMappingURL=budget.d.ts.map

package/dist/features/magic-context/memory-maintainer/budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory-maintainer/budget.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,iBAAiB;IAC9B,sHAAsH;IACtH,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC;AAE9D,MAAM,WAAW,WAAW;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IACxB,KAAK,EAAE,WAAW,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;CACxB;AAWD,qBAAa,WAAW;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;IAC3C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,KAAK,CAA6E;IAC1F,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,gBAAgB,CAAK;gBAEjB,MAAM,EAAE,iBAAiB,EAAE,KAAK,GAAE,MAAM,MAAiB;IAMrE,gGAAgG;IAChG,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAK1C,cAAc,IAAI,IAAI;IAItB;;;;OAIG;IACH,cAAc,IAAI,eAAe;IAQjC,2EAA2E;IAC3E,SAAS,IAAI,IAAI;IAKjB,cAAc,IAAI,cAAc;IAyBhC,QAAQ,IAAI,WAAW;IAQvB,OAAO,CAAC,QAAQ;IAahB,OAAO,CAAC,YAAY;CAcvB;AAED,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B,EAAE,iBAKxC,CAAC"}

package/dist/features/magic-context/memory-maintainer/coverage.d.ts

@@ -0,0 +1,91 @@
+import type { Database } from "../../../shared/sqlite";
+/** One pool item as fixed into the round snapshot (decision 13 semantic fields). */
+export interface PoolItemRef {
+    id: number;
+    /** Normalized content hash at snapshot time — NOT `updated_at` (plan §2). */
+    contentHash: string;
+    category: string;
+    status: string;
+}
+export type ItemStatus = "correct" | "unknown" | "keep" | "actioned" | "deferred_concurrent" | "uncovered" | "skipped";
+/** Statuses that count a snapshot item as processed (decision 20). */
+export declare const PROCESSED_STATUSES: readonly ItemStatus[];
+export declare function isProcessedStatus(status: ItemStatus | undefined): boolean;
+export interface CoverageState {
+    /** Fixed at round start; never re-fixed mid-round (decision 5). */
+    snapshot: PoolItemRef[];
+    /** Per-item progress ledger, keyed by String(id). */
+    ledger: Record<string, ItemStatus>;
+    roundStartedAt: number;
+    /** Set when every snapshot item is processed (decision 14: the 24h gate reads this). */
+    completedAt?: number;
+    /** Consecutive runs that processed no new snapshot items (zero-progress circuit, §4.2). */
+    zeroProgressStreak: number;
+}
+export declare function getCoverageState(db: Database, projectPath: string): CoverageState | undefined;
+/**
+ * Start a round (freeze a new snapshot from the current pool) or resume the
+ * unfinished round's existing snapshot and ledger. A completed round (marked
+ * or vacuously complete) is replaced by a fresh snapshot of the CURRENT pool.
+ */
+export declare function startOrResumeRound(db: Database, projectPath: string, pool: readonly PoolItemRef[], nowMs: number): {
+    state: CoverageState;
+    resumed: boolean;
+};
+/**
+ * Batch-record item statuses. Idempotent: an item already in a processed
+ * (terminal) status is never overwritten. Returns the updated state, or
+ * undefined when no round exists.
+ */
+export declare function markItems(db: Database, projectPath: string, updates: ReadonlyArray<{
+    id: number;
+    status: ItemStatus;
+}>): CoverageState | undefined;
+/** Update the zero-progress streak (diagnostic + §4.2 circuit input). No-op without a round. */
+export declare function setZeroProgressStreak(db: Database, projectPath: string, streak: number): void;
+/** Mark the round completed at `completedAtMs` (the 24h coverage gate starts here). */
+export declare function completeRound(db: Database, projectPath: string, completedAtMs: number): CoverageState | undefined;
+/** Terminate the round without completion (zero-progress circuit): drop the state entirely. */
+export declare function abandonRound(db: Database, projectPath: string): void;
+/** Snapshot items whose ledger status counts as processed (stale ledger keys ignored). */
+export declare function countProcessed(state: CoverageState): number;
+/** Every snapshot item has reached a processed status (empty snapshot → vacuously complete). */
+export declare function isRoundComplete(state: CoverageState): boolean;
+/**
+ * Zero-progress judgement (decision 10): the criterion is the PROCESSED-ITEM
+ * count difference between two states — never the number of memory changes
+ * (an all-correct, zero-action run still counts as progress).
+ */
+export declare function detectZeroProgress(stateBefore: CoverageState, stateAfter: CoverageState): boolean;
+export interface AnomalyThreshold {
+    absoluteRows: number;
+    poolFraction: number;
+}
+export interface AnomalyVerdict {
+    tripped: boolean;
+    /** max(absoluteRows, poolFraction × poolSize) — the effective bound. */
+    bound: number;
+}
+/**
+ * Anomaly dual gate (decision 11): changed rows above EITHER the absolute
+ * bound OR the pool-fraction bound trips the pause-and-report guard. Strictly
+ * greater-than: changedRows == bound does not trip. The absolute floor also
+ * protects small pools (a 4-row pool can never trip at absoluteRows ≥ 10).
+ */
+export declare function checkAnomaly(actionedRowCount: number, poolSize: number, threshold: AnomalyThreshold): AnomalyVerdict;
+export interface MaintenancePause {
+    reason: string;
+    pausedAt: number;
+    /** Human-visible report payload (per-item actions, reasons, threshold state). */
+    report: unknown;
+}
+/**
+ * Enter the anomaly pause state. There is NO automatic clear path anywhere in
+ * this module or its callers — resuming requires an explicit `clearPaused`
+ * (decision 11: the next run must not auto-bypass the pause).
+ */
+export declare function setPaused(db: Database, projectPath: string, pause: MaintenancePause): void;
+export declare function getPaused(db: Database, projectPath: string): MaintenancePause | undefined;
+/** Explicit, human-driven resume (decision 11). */
+export declare function clearPaused(db: Database, projectPath: string): void;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/features/magic-context/memory-maintainer/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory-maintainer/coverage.ts"],"names":[],"mappings":"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"}

package/dist/features/magic-context/memory-maintainer/dream-state.d.ts

@@ -0,0 +1,18 @@
+import type { Database } from "../../../shared/sqlite";
+export declare function getDreamState(db: Database, key: string): string | null;
+export declare function setDreamState(db: Database, key: string, value: string): void;
+export declare function deleteDreamState(db: Database, key: string): void;
+/**
+ * Namespace a maintainer state key for one project: `mmc-maint:<projectPath>:<kind>`.
+ * `dream_state` has no project_path column, so the project path lives in the key
+ * (plan 10 §4.6, decision 14/15). Lease keys use `mmc-maint:<projectPath>` without
+ * a kind suffix — see maintLeaseKey in lease.ts.
+ */
+export declare function maintStateKey(projectPath: string, kind: string): string;
+/** Read a JSON maintainer state value. Missing key or unparseable payload → undefined. */
+export declare function getMaintStateJson<T>(db: Database, projectPath: string, kind: string): T | undefined;
+/** Write a JSON maintainer state value. Storage failures are swallowed: best-effort state must never crash a pass. */
+export declare function setMaintStateJson(db: Database, projectPath: string, kind: string, value: unknown): void;
+/** Delete a maintainer state value by (projectPath, kind). */
+export declare function deleteMaintState(db: Database, projectPath: string, kind: string): void;
+//# sourceMappingURL=dream-state.d.ts.map

package/dist/features/magic-context/memory-maintainer/dream-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dream-state.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory-maintainer/dream-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAkC,MAAM,wBAAwB,CAAC;AAuCvF,wBAAgB,aAAa,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGtE;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAE5E;AAED,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAAC,CAAC,EAC/B,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,GACb,CAAC,GAAG,SAAS,CASf;AAED,sHAAsH;AACtH,wBAAgB,iBAAiB,CAC7B,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,GACf,IAAI,CAMN;AAED,8DAA8D;AAC9D,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAEtF"}

package/dist/features/magic-context/memory-maintainer/launcher.d.ts

@@ -0,0 +1,119 @@
+import type { Database } from "../../../shared/sqlite";
+/**
+ * Host-agnostic launcher for the automatic memory-maintenance task (plan 10
+ * §4.2, P2/F4a). Host adapters (OC2 transform tail, Pi context-handler) call
+ * {@link MaintenanceLauncher.maybeLaunch} once per pass with cheaply gathered
+ * signals; the launcher evaluates eligibility (schedule.evaluateEligibility
+ * over one schedule row + the coverage/pause KV state + an in-process
+ * in-flight flag) and, when eligible, fires the run factory WITHOUT awaiting
+ * it — a transform pass never blocks on maintenance work and the wire never
+ * sees a byte from here.
+ *
+ * Concurrency layering (plan §4.3): the launcher owns ONLY the in-process
+ * mutex ("run-in-flight-local"); cross-process mutual exclusion is the
+ * pipeline's lease (`lease.ts`) — deliberately not duplicated here. The
+ * historian-avoidance, session-shape and compaction gates arrive as host
+ * signals (decisions 6/7/25); the launcher never judges them itself.
+ */
+/** Cheap per-pass host signals (the adapter gathers these without fresh I/O). */
+export interface MaintenanceLaunchSignals {
+    /** This session's project is the active one (plan §4.2: 项目活跃). */
+    projectActive: boolean;
+    /** Host-side historian in-flight signal (decision 25 avoidance). */
+    historianInFlight: boolean;
+    /**
+     * Decision 7: compaction-off sessions never trigger. Explicit gate — the
+     * transform hook still RUNS in compaction-off sessions, so the adapter
+     * must pass the session's compaction state through.
+     */
+    compactionEnabled: boolean;
+    /** Decision 6: child / hidden sessions never trigger (recursion guard). */
+    isChildSession: boolean;
+    /** Non-archived pool count the host collected cheaply this pass. */
+    poolCount: number;
+    /**
+     * Run context, captured AT THE PROBE MOMENT and carried to the run
+     * factory through this object (gate-4 M1). The factory consumes only
+     * these per-launch fields — never a shared closure slot, which a
+     * concurrent session's pass could overwrite between launch and
+     * consumption. OC2 fills all three (`hostSystemText` is the probe-time
+     * host system-prompt snapshot, the round's authoritative AGENTS text);
+     * Pi fills `parentSessionId` + `directory` (it reads the project root
+     * AGENTS.md itself).
+     */
+    parentSessionId?: string;
+    directory?: string;
+    hostSystemText?: string;
+}
+/** The M1 run-context subset a manual launch passes explicitly. */
+export type MaintenanceLaunchRunContext = Pick<MaintenanceLaunchSignals, "parentSessionId" | "directory" | "hostSystemText">;
+/** Config slice the launcher consults: the `maintenance.enabled` master switch (decision 1). */
+export interface MaintenanceLauncherConfig {
+    maintenance: {
+        enabled: boolean;
+    };
+}
+/** Minimal per-run outcome for host status views / future RPC. */
+export interface MaintenanceRunSummary {
+    startedAtMs: number;
+    finishedAtMs: number;
+    /** False when runFactory rejected; the launcher never rethrows. */
+    ok: boolean;
+    /** runFactory's resolved payload (e.g. the pipeline's MaintenanceRunResult). */
+    result?: unknown;
+    /** Rejection message when !ok. */
+    error?: string;
+}
+export type MaintenanceRunFactory = (signals: MaintenanceLaunchSignals) => Promise<MaintenanceRunSummary>;
+export interface MaintenanceLauncherDeps {
+    db: Database;
+    projectPath: string;
+    /** Cheap config read; only `maintenance.enabled` is consulted. */
+    getConfig: () => MaintenanceLauncherConfig;
+    /** Injected clock — never a bare Date.now (test determinism). */
+    nowMs: () => number;
+    /** Production wires pipeline.runMaintenanceRun; tests inject fakes. */
+    runFactory: MaintenanceRunFactory;
+}
+export interface MaintenanceLaunchVerdict {
+    launched: boolean;
+    /**
+     * "launched", "maintenance-disabled", "run-in-flight-local", or the first
+     * failing evaluateEligibility clause (stable, greppable identifiers).
+     */
+    reason: string;
+}
+export declare class MaintenanceLauncher {
+    private readonly deps;
+    private runInFlight;
+    private lastSummary;
+    constructor(deps: MaintenanceLauncherDeps);
+    /**
+     * Synchronous, zero-await, cheap eligibility probe (plan §4.2: 触发检查
+     * 全为廉价读). Eligible → fire-and-forget the run factory and return
+     * immediately; the calling pass moves on while the run executes.
+     */
+    maybeLaunch(signals: MaintenanceLaunchSignals): MaintenanceLaunchVerdict;
+    /**
+     * Manual trigger (/mmc-memory-maintain run, decision 22): one run NOW on
+     * an explicit human request. The SCHEDULING gates — the 24h coverage
+     * spacing and next-due backoff — are overridden by that request; every
+     * safety gate stays on: the master switch, the in-process in-flight
+     * mutex, the anomaly pause (explicit resume only, decision 11 — a manual
+     * run never auto-bypasses a pause), and a non-empty pool. The pipeline's
+     * own lease / budget / anomaly doors downstream are untouched.
+     */
+    launchManual(signals: MaintenanceLaunchSignals): MaintenanceLaunchVerdict;
+    /** Fire-and-forget the run factory; both settle paths re-arm and record. */
+    private fire;
+    /** Last run's outcome, or null before the first launch settles. */
+    getLastRunSummary(): MaintenanceRunSummary | null;
+}
+/**
+ * One launcher per project per process, keyed by projectPath (storage-db
+ * hands out a single Database per path, so the db bound at first creation is
+ * the canonical one). Later calls for the same project return the existing
+ * instance — deps passed again are ignored (first construction wins).
+ */
+export declare function getMaintenanceLauncher(db: Database, projectPath: string, deps: Omit<MaintenanceLauncherDeps, "db" | "projectPath">): MaintenanceLauncher;
+//# sourceMappingURL=launcher.d.ts.map

package/dist/features/magic-context/memory-maintainer/launcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/memory-maintainer/launcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAKvD;;;;;;;;;;;;;;;GAeG;AAEH,iFAAiF;AACjF,MAAM,WAAW,wBAAwB;IACrC,kEAAkE;IAClE,aAAa,EAAE,OAAO,CAAC;IACvB,oEAAoE;IACpE,iBAAiB,EAAE,OAAO,CAAC;IAC3B;;;;OAIG;IACH,iBAAiB,EAAE,OAAO,CAAC;IAC3B,2EAA2E;IAC3E,cAAc,EAAE,OAAO,CAAC;IACxB,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;;OASG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,mEAAmE;AACnE,MAAM,MAAM,2BAA2B,GAAG,IAAI,CAC1C,wBAAwB,EACxB,iBAAiB,GAAG,WAAW,GAAG,gBAAgB,CACrD,CAAC;AAEF,gGAAgG;AAChG,MAAM,WAAW,yBAAyB;IACtC,WAAW,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CACrC;AAED,kEAAkE;AAClE,MAAM,WAAW,qBAAqB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,mEAAmE;IACnE,EAAE,EAAE,OAAO,CAAC;IACZ,gFAAgF;IAChF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,kCAAkC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,qBAAqB,GAAG,CAChC,OAAO,EAAE,wBAAwB,KAChC,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAEpC,MAAM,WAAW,uBAAuB;IACpC,EAAE,EAAE,QAAQ,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,kEAAkE;IAClE,SAAS,EAAE,MAAM,yBAAyB,CAAC;IAC3C,iEAAiE;IACjE,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,uEAAuE;IACvE,UAAU,EAAE,qBAAqB,CAAC;CACrC;AAED,MAAM,WAAW,wBAAwB;IACrC,QAAQ,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,mBAAmB;IAC5B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA0B;IAC/C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAsC;gBAE7C,IAAI,EAAE,uBAAuB;IAIzC;;;;OAIG;IACH,WAAW,CAAC,OAAO,EAAE,wBAAwB,GAAG,wBAAwB;IAqCxE;;;;;;;;OAQG;IACH,YAAY,CAAC,OAAO,EAAE,wBAAwB,GAAG,wBAAwB;IAiBzE,4EAA4E;IAC5E,OAAO,CAAC,IAAI;IAkCZ,mEAAmE;IACnE,iBAAiB,IAAI,qBAAqB,GAAG,IAAI;CAGpD;AAID;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAClC,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,IAAI,CAAC,uBAAuB,EAAE,IAAI,GAAG,aAAa,CAAC,GAC1D,mBAAmB,CAOrB"}