pi-mega-compact 0.4.5 → 0.4.6

package/dist/src/adapt.js

@@ -0,0 +1,106 @@
+/**
+ * adapt.ts — the adapter between pi's runtime message types and the engine's
+ * pi-agnostic `EngineMessage` shape.
+ *
+ * The engine (src/compact.ts, supersede.ts, boundary.ts, vectorStore.ts) only
+ * ever reasons about EngineMessage, so it stays unit-testable without a pi
+ * runtime. This module is the single conversion boundary. The conversion is
+ * 1:1 and index-aligned: every output EngineMessage corresponds to exactly one
+ * input AgentMessage at the same index, which lets the extension apply
+ * drop-range indices computed on the engine view straight back onto the real
+ * message array.
+ */
+import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
+import { computeDropRange } from "./boundary.js";
+/** Map a pi AgentMessage role to the engine's coarse role. */
+export function messageRole(m) {
+    if (m.role === "toolResult")
+        return "tool";
+    if (m.role === "user" || m.role === "assistant")
+        return m.role;
+    // custom / bashExecution / branchSummary / compactionSummary — all non-LLM
+    // bookkeeping as far as the engine is concerned.
+    return "custom";
+}
+/** Extract a tool name from a message, if it carries a tool call/result. */
+export function messageToolName(m) {
+    if (m.role === "toolResult")
+        return m.toolName;
+    if (m.role === "assistant") {
+        const tc = m.content.find((c) => c.type === "toolCall");
+        return tc?.name;
+    }
+    return undefined;
+}
+/** Pull the text out of a string-or-blocks content field. */
+function contentText(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((c) => c.type === "text" && typeof c.text === "string")
+        .map((c) => c.text)
+        .join("\n");
+}
+/** Project any AgentMessage into a single text blob the engine can reason on. */
+function messageText(m) {
+    switch (m.role) {
+        case "toolResult":
+        case "user":
+        case "assistant":
+        case "custom":
+            return contentText(m.content);
+        case "bashExecution":
+            return `${m.command}\n${m.output}`;
+        case "branchSummary":
+        case "compactionSummary":
+            return m.summary;
+    }
+}
+/**
+ * Convert a pi message array into the engine's EngineMessage view, keeping
+ * index alignment (output[i] corresponds to input[i]).
+ */
+export function toEngineMessages(messages) {
+    return messages.map((m) => {
+        const role = messageRole(m);
+        const toolName = messageToolName(m);
+        const text = messageText(m);
+        if (m.role === "toolResult") {
+            return { role, text, toolName, output: text };
+        }
+        if (m.role === "assistant") {
+            const blocks = m.content;
+            const callBlock = blocks.find((c) => c.type === "toolCall");
+            const input = callBlock
+                ? typeof callBlock.arguments === "string"
+                    ? callBlock.arguments
+                    : JSON.stringify(callBlock.arguments ?? {})
+                : undefined;
+            return { role, text, toolName, input };
+        }
+        return { role, text, toolName };
+    });
+}
+/**
+ * Project session entries into the engine view. Reuses pi's own
+ * sessionEntryToContextMessages so branching/compaction entries are resolved the
+ * same way the runtime would.
+ */
+export function toEngineFromEntries(entries) {
+    return entries.flatMap((e) => toEngineMessages(sessionEntryToContextMessages(e)));
+}
+/**
+ * Compute the safe drop range over a pi message array using the engine's
+ * boundary guards (anchor floor + tool-pair), then return the surviving
+ * messages. Reuses the tested `computeDropRange` on an engine view and maps the
+ * indices back onto the original array (index alignment guarantees correctness).
+ */
+export function dropCompactedRange(messages, keepFrom, anchorUserMessages) {
+    if (messages.length === 0)
+        return messages;
+    const view = toEngineMessages(messages);
+    const [, dropEnd] = computeDropRange(view, keepFrom, anchorUserMessages);
+    if (dropEnd <= 0)
+        return messages;
+    return messages.slice(dropEnd);
+}

package/dist/src/boundary.js

@@ -0,0 +1,88 @@
+/**
+ * boundary.ts — drop-boundary safety guards for the `context` hook.
+ *
+ * Two invariants the drop range must never violate (PREVENT-PI-001 / 002):
+ *  1. ANCHOR FLOOR: never drop the most recent N user messages.
+ *  2. TOOL-PAIR: never split an assistant(toolCall) from its following
+ *     tool-result message — an orphaned `tool` role with no preceding
+ *     assistant tool call causes a 400 on the OpenAI-compat path.
+ *
+ * The engine reasons over EngineMessage; the pi adapter maps role "tool" +
+ * toolName to the tool-result shape.
+ */
+/** Is this message a tool result (pi `tool` role with a tool name)? */
+function isToolResult(m) {
+    return m.role === "tool" && Boolean(m.toolName);
+}
+/** Does this assistant/tool message contain a tool call (toolName set)? */
+function hasToolUse(m) {
+    return Boolean(m.toolName) && m.role !== "tool";
+}
+/**
+ * Compute the safe drop range [dropStart, dropEnd) within `messages`.
+ * `keepFrom` is the caller's desired first-preserved index. We then:
+ *  1. Walk it back (lower dropEnd = keep more) so the first preserved message
+ *     is never an orphaned tool result (tool-pair invariant).
+ *  2. Raise it (lower dropEnd) to the anchor floor so the last N user messages
+ *     are never dropped, when enough user messages exist.
+ *
+ * dropEnd is the first index KEPT. Returns [dropStart, dropEnd]; empty range
+ * if nothing should be dropped.
+ */
+export function computeDropRange(messages, keepFrom, anchorUserMessages) {
+    if (keepFrom <= 0 || keepFrom >= messages.length)
+        return [0, 0];
+    const userIndexes = [];
+    messages.forEach((m, i) => { if (m.role === "user")
+        userIndexes.push(i); });
+    const anchorActive = anchorUserMessages > 0 && userIndexes.length >= anchorUserMessages;
+    const anchorStart = anchorActive ? userIndexes[userIndexes.length - anchorUserMessages] : 0;
+    const floor = anchorActive ? anchorStart : 0;
+    // Walk back for the tool-pair invariant (keep more when needed).
+    let k = keepFrom;
+    while (k > floor) {
+        const firstPreserved = messages[k];
+        if (!firstPreserved || !isToolResult(firstPreserved))
+            break;
+        const preceding = messages[k - 1];
+        if (preceding && hasToolUse(preceding)) {
+            k -= 1; // pair intact across boundary — include the assistant turn
+            break;
+        }
+        k -= 1;
+    }
+    if (k < floor)
+        k = floor;
+    // Anchor floor: never drop a must-keep user message. Raise dropEnd so we keep
+    // from anchorStart onward when the walk didn't already.
+    if (anchorActive && k > anchorStart)
+        k = anchorStart;
+    if (k <= 0)
+        return [0, 0];
+    return [0, k];
+}
+/**
+ * Validate that the intended split at `keepFrom` (drop [0, keepFrom), keep the
+ * rest) does not start the preserved run on an orphaned tool result. Checks
+ * messages[keepFrom] against messages[keepFrom-1] directly — independent of the
+ * walk-back that computeDropRange may apply.
+ */
+export function isBoundarySafe(messages, keepFrom) {
+    if (keepFrom <= 0 || keepFrom >= messages.length)
+        return true;
+    const firstPreserved = messages[keepFrom];
+    if (!isToolResult(firstPreserved))
+        return true;
+    const preceding = messages[keepFrom - 1];
+    return Boolean(preceding && hasToolUse(preceding));
+}
+/**
+ * Drop everything before the safe keep-index, honoring both guards, returning
+ * the filtered message list.
+ */
+export function dropBefore(messages, keepFrom, anchorUserMessages) {
+    const [dropStart, dropEnd] = computeDropRange(messages, keepFrom, anchorUserMessages);
+    if (dropStart === dropEnd)
+        return messages;
+    return messages.slice(dropEnd);
+}

package/dist/src/boundary.test.js

@@ -0,0 +1,53 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { computeDropRange, isBoundarySafe, dropBefore } from "./boundary.js";
+function user(t) { return { role: "user", text: t }; }
+function assistant(t) { return { role: "assistant", text: t }; }
+function toolUse(n, i = "{}") { return { role: "assistant", text: "", toolName: n, input: i }; }
+function toolResult(n, o = "ok") { return { role: "tool", text: "", toolName: n, output: o }; }
+test("walks back so first preserved message is not an orphaned tool result", () => {
+    const messages = [
+        user("Search for files"),
+        toolUse("search"),
+        toolResult("search", "found 5 files"),
+        assistant("Done."),
+    ];
+    // keepFrom=2 would start the preserved run on the tool result at index 2,
+    // orphaning it. The guard walks back to include the assistant tool-call.
+    const [start, end] = computeDropRange(messages, 2, 0);
+    assert.equal(start, 0);
+    assert.equal(end, 1);
+    const kept = messages.slice(end);
+    assert.notEqual(kept[0].role, "tool");
+    assert.equal(kept[0].toolName, "search"); // assistant tool-call preserved
+});
+test("isBoundarySafe: tool result at boundary with preceding tool use is safe", () => {
+    const messages = [user("a"), toolUse("search"), toolResult("search")];
+    assert.equal(isBoundarySafe(messages, 2), true);
+});
+test("isBoundarySafe: orphaned tool result without preceding tool use is unsafe", () => {
+    const messages = [user("a"), toolResult("search", "orphan")];
+    assert.equal(isBoundarySafe(messages, 1), false);
+});
+test("anchor floor preserves the last N user messages", () => {
+    const messages = [
+        user("u1"), user("u2"), user("u3"),
+        assistant("a1"), assistant("a2"), assistant("a3"), assistant("a4"), assistant("a5"),
+    ];
+    // Caller wants to keep from index 2 (would drop u2). Anchor=2 forces keeping
+    // from u2 (index 1) onward.
+    const out = dropBefore(messages, 2, 2);
+    assert.ok(out.some((m) => m.text === "u2"));
+    assert.ok(out.some((m) => m.text === "u3"));
+});
+test("anchor floor is a no-op when fewer users than anchor", () => {
+    const messages = [user("u1"), assistant("a1"), assistant("a2"), assistant("a3")];
+    const out = dropBefore(messages, 1, 2);
+    // only 1 user, anchor=2 → no floor; keep from index 1 (drop the user)
+    assert.ok(!out.some((m) => m.text === "u1"));
+    assert.equal(out.length, 3);
+});
+test("dropBefore returns original when range is empty", () => {
+    const messages = [user("a"), assistant("b")];
+    assert.equal(dropBefore(messages, 0, 1), messages);
+});

package/dist/src/canary.js

@@ -0,0 +1,118 @@
+/**
+ * canary.ts — safe sequential tier rollout (Sprint 14, Phase 7).
+ *
+ * Enables tiers one at a time (L0 → L1 → L2 → RAPTOR), watching each tier's p95
+ * latency (from monitoring metrics) and AUTO-DISABLING a tier whose p95 breaches
+ * the budget. No human-in-the-loop: degradation is automatic and local (QA #19).
+ *
+ * The controller owns a MUTABLE working copy of the dedup config; callers read
+ * `controller.config` after each step. Tiers disabled via MARK_ONLY degrade
+ * gracefully rather than fully off.
+ */
+import { loadDedupConfig } from "./config/dedup.js";
+import { p95 } from "./monitoring.js";
+/** Canonical enablement order. */
+export const CANARY_ORDER = ["L0", "L1", "L2", "RAPTOR"];
+export class CanaryController {
+    config;
+    state;
+    constructor(base = loadDedupConfig()) {
+        // Start from the base config but begin with L0 only (sequential rollout).
+        this.config = { ...base };
+        this.config.L1_ENABLED = false;
+        this.config.L2_ENABLED = false;
+        this.config.RAPTOR_ENABLED = false;
+        this.state = {
+            enabled: new Set(["L0"]),
+            disabled: new Set(),
+            step: 1,
+        };
+    }
+    /** Enable the next tier in CANARY_ORDER (no-op if all enabled). */
+    stepForward() {
+        for (const tier of CANARY_ORDER) {
+            if (!this.state.enabled.has(tier) && !this.state.disabled.has(tier)) {
+                this.setEnabled(tier, true);
+                this.state.step++;
+                return tier;
+            }
+        }
+        return null;
+    }
+    setEnabled(tier, on) {
+        switch (tier) {
+            case "L0":
+                this.config.L0_ENABLED = on;
+                break;
+            case "L1":
+                this.config.L1_ENABLED = on;
+                break;
+            case "L2":
+                this.config.L2_ENABLED = on;
+                break;
+            case "RAPTOR":
+                this.config.RAPTOR_ENABLED = on;
+                break;
+        }
+        if (on) {
+            this.state.enabled.add(tier);
+            this.state.disabled.delete(tier);
+        }
+        else {
+            this.state.enabled.delete(tier);
+        }
+    }
+    disableReason(tier) {
+        this.setEnabled(tier, false);
+        this.state.disabled.add(tier);
+    }
+    /**
+     * Evaluate p95 latency for every enabled tier against the budget. Any tier
+     * whose p95 exceeds `config.P95_BUDGET_MS` is auto-disabled. Returns the tiers
+     * it disabled this pass (so the caller can log/alert).
+     */
+    evaluate(metrics) {
+        const disabledNow = [];
+        for (const tier of CANARY_ORDER) {
+            if (!this.state.enabled.has(tier))
+                continue;
+            const lat = p95(metrics.latency[tier] ?? []);
+            if (lat > this.config.P95_BUDGET_MS) {
+                this.disableReason(tier);
+                disabledNow.push(tier);
+            }
+        }
+        return disabledNow;
+    }
+    getState() {
+        return {
+            enabled: new Set(this.state.enabled),
+            disabled: new Set(this.state.disabled),
+            step: this.state.step,
+        };
+    }
+}
+/**
+ * Run the full canary rollout against a metrics feed. `feed` is sampled at each
+ * step (after enabling a tier) to drive auto-disable. Deterministic + offline.
+ */
+export function runCanary(metricsFeed, base = loadDedupConfig()) {
+    const controller = new CanaryController(base);
+    const allDisabled = [];
+    let step = 0;
+    // Up to one step per tier + a final eval.
+    while (true) {
+        const tier = controller.stepForward();
+        if (tier === null)
+            break;
+        const metrics = metricsFeed(controller.getState().step, controller.config);
+        const disabled = controller.evaluate(metrics);
+        allDisabled.push(...disabled);
+        if (++step > CANARY_ORDER.length + 1)
+            break;
+    }
+    // Final eval pass on the last enabled set.
+    const finalMetrics = metricsFeed(controller.getState().step, controller.config);
+    allDisabled.push(...controller.evaluate(finalMetrics));
+    return { controller, disabled: [...new Set(allDisabled)] };
+}

package/dist/src/compact.js

@@ -0,0 +1,250 @@
+/**
+ * compact.ts — the COLLAPSE/summarize engine (Layer 2) + the compaction gate.
+ *
+ * Ported (conceptually) from claw-code rusty-claude-cli compact.rs
+ * (summarize_messages / merge_compact_summaries / format_compact_summary) and
+ * from memory-mcp session_context.py auto_compact_check / should_compact.
+ * Pure, pi-agnostic, deterministic, no LLM required.
+ */
+import { estimateSessionTokens } from "./tokens.js";
+const INTERESTING_EXT = new Set(["rs", "ts", "tsx", "js", "json", "md"]);
+const PENDING_WORDS = ["todo", "next", "pending", "follow up", "remaining"];
+const COMPACT_PREAMBLE = "This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.\n\n";
+const RECENT_NOTE = "Recent messages are preserved verbatim.";
+const DIRECT_RESUME = "Continue the conversation from where it left off without asking the user any further questions. Resume directly — do not acknowledge the summary, do not recap what was happening, and do not preface with continuation text.";
+function truncate(s, max) {
+    return s.length <= max ? s : `${s.slice(0, max)}…`;
+}
+function firstText(m) {
+    const t = m.text.trim();
+    return t.length > 0 ? t : undefined;
+}
+/** Heuristic: does this text look like chatty filler we can collapse? */
+export function isChatty(text) {
+    const low = text.toLowerCase();
+    if (low.includes("hello") || low.includes("thanks") || low.includes("great") || low.includes("ok")) {
+        return true;
+    }
+    return text.length < 40 && !/(\/|\.|\{|import |def |function )/.test(text);
+}
+/** Extract plausible file paths (contain '/' + an interesting extension). */
+export function extractFileCandidates(content) {
+    const out = [];
+    for (const raw of content.split(/\s+/)) {
+        // Trim surrounding punctuation only — do NOT strip internal dots, or we
+        // would erase the extension separator (src/server.ts -> src/server/ts).
+        const token = raw.replace(/^[^A-Za-z0-9/]+|[^A-Za-z0-9/]+$/g, "");
+        if (!token.includes("/") || !token.includes("."))
+            continue;
+        const ext = token.split(".").pop()?.toLowerCase() ?? "";
+        if (INTERESTING_EXT.has(ext))
+            out.push(token);
+    }
+    return out;
+}
+/** Collect unique key files referenced across a set of messages. */
+export function collectKeyFiles(messages) {
+    const files = new Set();
+    for (const m of messages) {
+        for (const c of [m.text, m.input, m.output]) {
+            if (!c)
+                continue;
+            for (const f of extractFileCandidates(c))
+                files.add(f);
+        }
+    }
+    return [...files].slice(0, 8);
+}
+/** Infer pending work from recent messages via keyword scan. */
+export function inferPendingWork(messages) {
+    const out = [];
+    for (const m of [...messages].reverse()) {
+        const t = firstText(m);
+        if (!t)
+            continue;
+        const low = t.toLowerCase();
+        if (PENDING_WORDS.some((w) => low.includes(w))) {
+            out.push(truncate(t, 160));
+            if (out.length >= 3)
+                break;
+        }
+    }
+    return out.reverse();
+}
+/** Latest user request (for "current work" line). */
+export function inferCurrentWork(messages) {
+    for (const m of [...messages].reverse()) {
+        const t = firstText(m);
+        if (t && m.role === "user")
+            return truncate(t, 200);
+    }
+    return undefined;
+}
+/** Last N user requests, in original order. */
+export function collectRecentUserRequests(messages, limit) {
+    const reqs = messages
+        .filter((m) => m.role === "user")
+        .map((m) => firstText(m))
+        .filter((t) => Boolean(t))
+        .map((t) => truncate(t, 160));
+    return reqs.slice(-limit);
+}
+/** Summarize a block to a one-line description. */
+function summarizeBlock(m) {
+    if (m.role === "tool")
+        return `tool_result ${m.toolName ?? "?"}: ${truncate(m.output ?? m.text, 160)}`;
+    if (m.toolName)
+        return `tool_use ${m.toolName}(${truncate(m.input ?? "", 160)})`;
+    return truncate(m.text, 160);
+}
+function stripTag(block, tag) {
+    const start = `<${tag}>`;
+    const end = `</${tag}>`;
+    const s = block.indexOf(start);
+    const e = block.indexOf(end);
+    if (s === -1 || e === -1)
+        return block;
+    return block.slice(0, s) + block.slice(e + end.length);
+}
+function extractTag(block, tag) {
+    const s = block.indexOf(`<${tag}>`);
+    const e = block.indexOf(`</${tag}>`);
+    if (s === -1 || e === -1)
+        return undefined;
+    return block.slice(s + `<${tag}>`.length, e);
+}
+/** Normalize a raw summary into user-facing "Summary: ..." text. */
+export function formatCompactSummary(summary) {
+    const withoutAnalysis = stripTag(summary, "analysis");
+    let formatted = withoutAnalysis;
+    const content = extractTag(withoutAnalysis, "summary");
+    if (content !== undefined) {
+        formatted = withoutAnalysis.replace(`<summary>${content}</summary>`, `Summary:\n${content.trim()}`);
+    }
+    return formatted.replace(/\n{3,}/g, "\n\n").trim();
+}
+/**
+ * Build a <summary> block from a slice of messages (the COLLAPSE output).
+ * Mirrors claw-code summarize_messages.
+ */
+export function summarizeMessages(messages) {
+    const users = messages.filter((m) => m.role === "user").length;
+    const assistants = messages.filter((m) => m.role === "assistant").length;
+    const tools = messages.filter((m) => m.role === "tool").length;
+    const toolNames = [...new Set(messages.flatMap((m) => (m.toolName ? [m.toolName] : [])))].sort();
+    const lines = [
+        "<summary>",
+        "Conversation summary:",
+        `- Scope: ${messages.length} earlier messages compacted (user=${users}, assistant=${assistants}, tool=${tools}).`,
+    ];
+    if (toolNames.length)
+        lines.push(`- Tools mentioned: ${toolNames.join(", ")}.`);
+    const recent = collectRecentUserRequests(messages, 3);
+    if (recent.length) {
+        lines.push("- Recent user requests:");
+        recent.forEach((r) => lines.push(`  - ${r}`));
+    }
+    const pending = inferPendingWork(messages);
+    if (pending.length) {
+        lines.push("- Pending work:");
+        pending.forEach((p) => lines.push(`  - ${p}`));
+    }
+    const files = collectKeyFiles(messages);
+    if (files.length)
+        lines.push(`- Key files referenced: ${files.join(", ")}.`);
+    const current = inferCurrentWork(messages);
+    if (current)
+        lines.push(`- Current work: ${current}`);
+    lines.push("- Key timeline:");
+    for (const m of messages) {
+        const role = m.role;
+        lines.push(`  - ${role}: ${summarizeBlock(m)}`);
+    }
+    lines.push("</summary>");
+    return lines.join("\n");
+}
+/** Extract the prior "highlights" + "timeline" sections from an existing summary. */
+function extractSummaryHighlights(summary) {
+    const lines = formatCompactSummary(summary).split("\n");
+    const out = [];
+    let inTimeline = false;
+    for (const line of lines) {
+        const t = line.trimEnd();
+        if (!t || t === "Summary:" || t === "Conversation summary:")
+            continue;
+        if (t === "- Key timeline:") {
+            inTimeline = true;
+            continue;
+        }
+        if (inTimeline)
+            continue;
+        out.push(t);
+    }
+    return out;
+}
+function extractSummaryTimeline(summary) {
+    const lines = formatCompactSummary(summary).split("\n");
+    const out = [];
+    let inTimeline = false;
+    for (const line of lines) {
+        const t = line.trimEnd();
+        if (t === "- Key timeline:") {
+            inTimeline = true;
+            continue;
+        }
+        if (!inTimeline)
+            continue;
+        if (!t)
+            break;
+        out.push(t);
+    }
+    return out;
+}
+/** Merge an existing compact summary with a new one (accumulate, don't overwrite). */
+export function mergeCompactSummaries(existing, newSummary) {
+    if (!existing)
+        return newSummary;
+    const prevHighlights = extractSummaryHighlights(existing);
+    const newHighlights = extractSummaryHighlights(formatCompactSummary(newSummary));
+    const newTimeline = extractSummaryTimeline(formatCompactSummary(newSummary));
+    const lines = ["<summary>", "Conversation summary:"];
+    if (prevHighlights.length) {
+        lines.push("- Previously compacted context:");
+        prevHighlights.forEach((l) => lines.push(`  ${l}`));
+    }
+    if (newHighlights.length) {
+        lines.push("- Newly compacted context:");
+        newHighlights.forEach((l) => lines.push(`  ${l}`));
+    }
+    if (newTimeline.length) {
+        lines.push("- Key timeline:");
+        newTimeline.forEach((l) => lines.push(`  ${l}`));
+    }
+    lines.push("</summary>");
+    return lines.join("\n");
+}
+/** True when the compactable portion exceeds the budget. */
+export function shouldCompact(messages, maxEstimatedTokens, preserveRecent) {
+    if (messages.length <= preserveRecent)
+        return false;
+    const compactable = messages.slice(0, messages.length - preserveRecent);
+    return estimateSessionTokens(compactable) >= maxEstimatedTokens;
+}
+/** Local reimplementation of memory-mcp auto_compact_check. */
+export function autoCompactCheck(currentTokens, threshold = 50000) {
+    return {
+        shouldCompact: currentTokens >= threshold,
+        currentTokens,
+        threshold,
+        utilizationPct: Math.round((currentTokens / threshold) * 1000) / 10,
+    };
+}
+/** Build the synthetic continuation message (system-prompt prepend form). */
+export function getContinuationMessage(summary, suppressFollowUp, recentPreserved) {
+    let base = COMPACT_PREAMBLE + formatCompactSummary(summary);
+    if (recentPreserved)
+        base += `\n\n${RECENT_NOTE}`;
+    if (suppressFollowUp)
+        base += `\n${DIRECT_RESUME}`;
+    return base;
+}