@geteigen/cli 0.0.0-stage → 3.0.0

package/dist/shared/providerModels.js

@@ -0,0 +1,503 @@
+import { isCodexModelId } from "./codexModels.js";
+const ANTHROPIC_MODELS_URL = "https://api.anthropic.com/v1/models?limit=200";
+const OPENAI_MODELS_URL = "https://api.openai.com/v1/models";
+const ANTHROPIC_VERSION = "2023-06-01";
+export function displayNameFromId(id) {
+    if (id === "auto")
+        return "Auto";
+    return id
+        .replace(/^claude-/, "")
+        .replace(/[_-]+/g, " ")
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+/** First list wins id + display name; later lists only append new ids. */
+export function mergeModelLists(...lists) {
+    const seen = new Set();
+    const out = [];
+    for (const list of lists) {
+        if (!list)
+            continue;
+        for (const model of list) {
+            const id = model?.id?.trim();
+            if (!id || seen.has(id))
+                continue;
+            seen.add(id);
+            out.push({
+                id,
+                displayName: model.displayName?.trim() || displayNameFromId(id),
+                ...(model.description ? { description: model.description } : {}),
+                ...(model.free ? { free: true } : {}),
+                ...(model.group ? { group: model.group } : {}),
+            });
+        }
+    }
+    return out;
+}
+/** Keep a currently-selected id visible in the picker even if the catalog moved on. */
+export function ensureModelPresent(models, modelId) {
+    const id = modelId?.trim();
+    if (!id || models.some((m) => m.id === id))
+        return models;
+    return [...models, { id, displayName: displayNameFromId(id) }];
+}
+function asRecordArray(json) {
+    if (Array.isArray(json)) {
+        return json.filter((item) => Boolean(item && typeof item === "object"));
+    }
+    if (json && typeof json === "object") {
+        const rec = json;
+        const nested = rec.data ?? rec.models ?? rec.items;
+        if (Array.isArray(nested)) {
+            return nested.filter((item) => Boolean(item && typeof item === "object"));
+        }
+    }
+    return [];
+}
+function createdMs(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value < 1e12 ? value * 1000 : value;
+    }
+    if (typeof value === "string" && value.trim()) {
+        const asNum = Number(value);
+        if (Number.isFinite(asNum) && asNum > 0) {
+            return asNum < 1e12 ? asNum * 1000 : asNum;
+        }
+        const parsed = Date.parse(value);
+        if (!Number.isNaN(parsed))
+            return parsed;
+    }
+    return 0;
+}
+export function parseAnthropicModelsResponse(json) {
+    const rows = asRecordArray(json)
+        .map((rec) => {
+        const id = String(rec.id || "").trim();
+        if (!id)
+            return null;
+        const displayName = String(rec.display_name || rec.displayName || "").trim();
+        return {
+            id,
+            displayName: displayName || displayNameFromId(id),
+            created: createdMs(rec.created_at ?? rec.createdAt ?? rec.created),
+        };
+    })
+        .filter((row) => Boolean(row));
+    rows.sort((a, b) => b.created - a.created);
+    return rows.map(({ id, displayName }) => ({ id, displayName }));
+}
+function isExcludedOpenaiModel(id) {
+    const lower = id.toLowerCase();
+    return (lower.includes("embed") ||
+        lower.includes("whisper") ||
+        lower.includes("tts") ||
+        lower.includes("dall-e") ||
+        lower.includes("davinci") ||
+        lower.includes("babbage") ||
+        lower.includes("ada-") ||
+        lower.includes("realtime") ||
+        lower.includes("transcribe") ||
+        lower.includes("moderation") ||
+        lower.includes("image") ||
+        lower.includes("audio") ||
+        lower.includes("sora") ||
+        lower.startsWith("ft:"));
+}
+function openaiRank(id) {
+    const lower = id.toLowerCase();
+    if (lower.includes("codex"))
+        return 0;
+    if (lower.startsWith("gpt-6"))
+        return 1;
+    if (lower.startsWith("gpt-5"))
+        return 2;
+    if (lower.startsWith("o4") || lower.startsWith("o3"))
+        return 3;
+    if (lower.startsWith("gpt-4"))
+        return 4;
+    return 5;
+}
+export function parseOpenaiModelsResponse(json) {
+    const rows = asRecordArray(json)
+        .map((rec) => {
+        const id = String(rec.id || rec.slug || rec.model || "").trim();
+        if (!id || isExcludedOpenaiModel(id) || !isCodexModelId(id))
+            return null;
+        return { id, created: createdMs(rec.created) };
+    })
+        .filter((row) => Boolean(row));
+    rows.sort((a, b) => {
+        const rank = openaiRank(a.id) - openaiRank(b.id);
+        if (rank !== 0)
+            return rank;
+        return b.created - a.created;
+    });
+    return rows.map(({ id }) => ({ id, displayName: displayNameFromId(id) }));
+}
+const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]/g;
+const MODEL_LINE_RE = /^([a-zA-Z0-9][a-zA-Z0-9._-]*)\s+[-–—|:]\s+(.+)$/;
+const MODEL_TOKEN_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+function stripAnsi(text) {
+    return text.replace(ANSI_RE, "").replace(/\r/g, "");
+}
+function modelFromUnknown(value) {
+    if (typeof value === "string") {
+        const id = value.trim();
+        if (!id || !MODEL_TOKEN_RE.test(id) || !isCodexModelId(id))
+            return null;
+        return { id, displayName: displayNameFromId(id) };
+    }
+    if (!value || typeof value !== "object")
+        return null;
+    const rec = value;
+    const id = String(rec.id || rec.slug || rec.model || rec.name || "").trim();
+    if (!id || !isCodexModelId(id))
+        return null;
+    const displayName = String(rec.display_name || rec.displayName || rec.label || rec.name || "").trim();
+    return {
+        id,
+        displayName: displayName && displayName !== id ? displayName : displayNameFromId(id),
+    };
+}
+function parseCodexDebugJson(json) {
+    if (Array.isArray(json)) {
+        return mergeModelLists(json.map(modelFromUnknown).filter((m) => Boolean(m)));
+    }
+    if (json && typeof json === "object") {
+        const rec = json;
+        const nested = rec.models ?? rec.data ?? rec.items ?? rec.available;
+        if (nested)
+            return parseCodexDebugJson(nested);
+    }
+    return [];
+}
+/** Parse `codex debug models` — JSON, "id — label" lines, or bare ids. */
+export function parseCodexDebugModels(stdout) {
+    const text = stripAnsi(stdout || "").trim();
+    if (!text)
+        return [];
+    const jsonStart = text.indexOf("[") >= 0 && (text.indexOf("{") < 0 || text.indexOf("[") < text.indexOf("{"))
+        ? text.indexOf("[")
+        : text.indexOf("{");
+    if (jsonStart >= 0) {
+        try {
+            const parsed = parseCodexDebugJson(JSON.parse(text.slice(jsonStart)));
+            if (parsed.length)
+                return parsed;
+        }
+        catch {
+            // fall through to line parser
+        }
+    }
+    const models = [];
+    const seen = new Set();
+    for (const raw of text.split("\n")) {
+        const line = raw.trim();
+        if (!line || /^(available models|models):?$/i.test(line))
+            continue;
+        const labeled = line.match(MODEL_LINE_RE);
+        const id = (labeled?.[1] || line.split(/\s+/)[0] || "").trim();
+        if (!id || !MODEL_TOKEN_RE.test(id) || !isCodexModelId(id) || seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        const label = labeled?.[2]?.trim();
+        models.push({
+            id,
+            displayName: label && label !== id ? label : displayNameFromId(id),
+        });
+    }
+    return models;
+}
+export async function fetchAnthropicModels(apiKey) {
+    const key = apiKey.trim();
+    if (!key)
+        throw new Error("Anthropic API key is required to list models");
+    const res = await fetch(ANTHROPIC_MODELS_URL, {
+        headers: {
+            "x-api-key": key,
+            "anthropic-version": ANTHROPIC_VERSION,
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Anthropic models request failed (${res.status})`);
+    }
+    return parseAnthropicModelsResponse(await res.json());
+}
+export async function fetchOpenaiCodingModels(apiKey) {
+    const key = apiKey.trim();
+    if (!key)
+        throw new Error("OpenAI API key is required to list models");
+    const res = await fetch(OPENAI_MODELS_URL, {
+        headers: { Authorization: `Bearer ${key}` },
+    });
+    if (!res.ok) {
+        throw new Error(`OpenAI models request failed (${res.status})`);
+    }
+    return parseOpenaiModelsResponse(await res.json());
+}
+// ── OpenCode (models.dev) catalog ────────────────────────────────────────────
+/**
+ * The model database the OpenCode CLI itself is built on. Fetching it makes
+ * the picker show every provider OpenCode supports — including free models
+ * that need no sign-in — without any worker or API key.
+ */
+const OPENCODE_CATALOG_URLS = [
+    "https://models.opencode.ai/api.json",
+    "https://models.dev/api.json",
+];
+const OPENCODE_CATALOG_TTL_MS = 6 * 60 * 60_000;
+const OPENCODE_CATALOG_FETCH_TIMEOUT_MS = 30_000;
+let opencodeCatalogCache = null;
+let opencodeCatalogInFlight = null;
+/** Sync peek for keyless checks in hot paths (null until the first fetch). */
+export function cachedOpencodeCatalog() {
+    return opencodeCatalogCache?.catalog ?? null;
+}
+function modelsDevText(parsed, field) {
+    const value = parsed?.[field];
+    return typeof value === "string" ? value.trim() : "";
+}
+/** Can this model drive an agent: tool calling + text output. */
+function modelsDevAgentCapable(model) {
+    if (model.tool_call === false)
+        return false;
+    const modalities = model.modalities;
+    const outputs = modalities?.output;
+    if (Array.isArray(outputs) && outputs.length && !outputs.includes("text")) {
+        return false;
+    }
+    return true;
+}
+function modelsDevFree(model) {
+    const cost = model.cost;
+    if (!cost)
+        return false;
+    return Number(cost.input) === 0 && Number(cost.output) === 0;
+}
+export function parseModelsDevCatalog(json) {
+    const providers = json && typeof json === "object" && !Array.isArray(json)
+        ? json
+        : {};
+    const models = [];
+    const seen = new Set();
+    const keylessModelIds = new Set();
+    for (const [providerId, providerRaw] of Object.entries(providers)) {
+        if (!providerRaw || typeof providerRaw !== "object")
+            continue;
+        const provider = providerRaw;
+        const providerName = modelsDevText(provider, "name") || providerId;
+        const modelMap = provider.models;
+        if (!modelMap || typeof modelMap !== "object")
+            continue;
+        for (const [rawModelId, modelRaw] of Object.entries(modelMap)) {
+            if (!modelRaw || typeof modelRaw !== "object")
+                continue;
+            const model = modelRaw;
+            const id = modelsDevText(model, "id") || rawModelId.trim();
+            if (!id || /\s/.test(id))
+                continue;
+            const composite = `${providerId}/${id}`;
+            if (seen.has(composite))
+                continue;
+            seen.add(composite);
+            if (!modelsDevAgentCapable(model))
+                continue;
+            const free = modelsDevFree(model);
+            const keyless = free && providerId === "opencode";
+            if (keyless)
+                keylessModelIds.add(composite);
+            models.push({
+                id: composite,
+                displayName: modelsDevText(model, "name") || id,
+                ...(free ? { free: true } : {}),
+                description: free
+                    ? keyless
+                        ? `${providerName} — free, no API key`
+                        : `${providerName} — free (needs the provider's own API key)`
+                    : providerName,
+            });
+        }
+    }
+    models.sort((a, b) => a.id.localeCompare(b.id));
+    return { models, keylessModelIds };
+}
+const OPENCODE_ZEN_MODELS_URL = "https://opencode.ai/zen/v1/models";
+/** Model ids OpenCode's gateway serves right now (`opencode models` uses the same list). */
+async function fetchOpencodeZenModelIds() {
+    try {
+        const res = await fetch(OPENCODE_ZEN_MODELS_URL, {
+            signal: AbortSignal.timeout(OPENCODE_CATALOG_FETCH_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return null;
+        const json = (await res.json());
+        const ids = (json.data || [])
+            .map((m) => (typeof m.id === "string" ? m.id.trim() : ""))
+            .filter((id) => id && !/\s/.test(id));
+        return ids.length ? ids : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * models.dev keeps free gateway models long after OpenCode retires them, and
+ * the CLI answers those with "Unexpected server error". Keep only the free
+ * ones the gateway still lists.
+ */
+export function applyOpencodeZenModels(catalog, zenIds) {
+    if (!zenIds)
+        return catalog;
+    const live = new Set(zenIds.map((id) => `opencode/${id}`));
+    const known = new Set(catalog.models.map((m) => m.id));
+    const keylessModelIds = new Set();
+    const models = catalog.models.filter((m) => !m.id.startsWith("opencode/") || live.has(m.id));
+    for (const m of models) {
+        if (catalog.keylessModelIds.has(m.id))
+            keylessModelIds.add(m.id);
+    }
+    for (const id of zenIds) {
+        const composite = `opencode/${id}`;
+        if (!/-free$/i.test(id))
+            continue;
+        keylessModelIds.add(composite);
+        if (known.has(composite))
+            continue;
+        models.push({
+            id: composite,
+            displayName: id,
+            free: true,
+            description: "OpenCode — free, no API key",
+        });
+    }
+    models.sort((a, b) => a.id.localeCompare(b.id));
+    return { models, keylessModelIds };
+}
+async function fetchOpencodeCatalogOnce() {
+    const zen = fetchOpencodeZenModelIds();
+    let lastError = null;
+    for (const url of OPENCODE_CATALOG_URLS) {
+        try {
+            const res = await fetch(url, {
+                signal: AbortSignal.timeout(OPENCODE_CATALOG_FETCH_TIMEOUT_MS),
+            });
+            if (!res.ok)
+                throw new Error(`models.dev request failed (${res.status})`);
+            const json = (await res.json());
+            return applyOpencodeZenModels(parseModelsDevCatalog(json), await zen);
+        }
+        catch (err) {
+            lastError = err;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("models.dev unreachable");
+}
+/** Full OpenCode model database (models.dev), cached 6 h and stale-safe. */
+export async function fetchOpencodeCatalog() {
+    const cached = opencodeCatalogCache;
+    if (cached && Date.now() - cached.at < OPENCODE_CATALOG_TTL_MS) {
+        return cached.catalog;
+    }
+    opencodeCatalogInFlight ??= fetchOpencodeCatalogOnce()
+        .then((catalog) => {
+        opencodeCatalogCache = { at: Date.now(), catalog };
+        return catalog;
+    })
+        .finally(() => {
+        opencodeCatalogInFlight = null;
+    });
+    const inflight = opencodeCatalogInFlight;
+    try {
+        return await inflight;
+    }
+    catch {
+        // Serve the previous copy while the next attempt runs; otherwise empty.
+        if (cached)
+            return cached.catalog;
+        opencodeCatalogInFlight = null;
+        throw new Error("Could not load the OpenCode model catalog");
+    }
+}
+const OPENCODE_FREE_GROUP_ORDER = [
+    "xAI",
+    "Zhipu",
+    "MiniMax",
+    "Moonshot",
+    "Alibaba",
+    "DeepSeek",
+    "NVIDIA",
+    "Xiaomi",
+    "OpenCode",
+];
+/** Underlying lab for an `opencode/<slug>` free model. */
+export function opencodeFreeModelGroup(id) {
+    const slug = id.includes("/") ? id.slice(id.indexOf("/") + 1) : id;
+    if (/^grok/i.test(slug))
+        return "xAI";
+    if (/^glm/i.test(slug))
+        return "Zhipu";
+    if (/^minimax/i.test(slug))
+        return "MiniMax";
+    if (/^kimi/i.test(slug))
+        return "Moonshot";
+    if (/^qwen/i.test(slug))
+        return "Alibaba";
+    if (/^deepseek/i.test(slug))
+        return "DeepSeek";
+    if (/^nemotron/i.test(slug))
+        return "NVIDIA";
+    if (/^mimo/i.test(slug))
+        return "Xiaomi";
+    return "OpenCode";
+}
+/**
+ * Preferred free defaults on OpenCode's own gateway (no API key).
+ */
+export const OPENCODE_FREE_PICKER_PREFERENCES = [
+    "opencode/glm-5.3-flash-free",
+    "opencode/deepseek-v4.1-flash-free",
+    "opencode/big-pickle",
+    "opencode/grok-code",
+    "opencode/minimax-m3-free",
+    "opencode/kimi-k2.5-free",
+    "opencode/qwen3.6-plus-free",
+];
+export function firstKeylessFreeOpencodeModel() {
+    const keylessModelIds = cachedOpencodeCatalog()?.keylessModelIds;
+    if (!keylessModelIds?.size)
+        return null;
+    for (const id of OPENCODE_FREE_PICKER_PREFERENCES) {
+        if (keylessModelIds.has(id))
+            return id;
+    }
+    return keylessModelIds.values().next().value ?? null;
+}
+/** Only OpenCode-gateway free models, grouped by provider. */
+export function opencodePickerModels(catalog) {
+    const pref = new Map(OPENCODE_FREE_PICKER_PREFERENCES.map((id, i) => [id, i]));
+    const free = [];
+    for (const model of catalog.models) {
+        if (!catalog.keylessModelIds.has(model.id))
+            continue;
+        const group = opencodeFreeModelGroup(model.id);
+        free.push({
+            ...model,
+            free: true,
+            group,
+            description: model.description || `${group} — free, no API key`,
+        });
+    }
+    free.sort((a, b) => {
+        const ga = OPENCODE_FREE_GROUP_ORDER.indexOf(a.group || "OpenCode");
+        const gb = OPENCODE_FREE_GROUP_ORDER.indexOf(b.group || "OpenCode");
+        const g = (ga < 0 ? 99 : ga) - (gb < 0 ? 99 : gb);
+        if (g)
+            return g;
+        const pa = pref.get(a.id) ?? 100;
+        const pb = pref.get(b.id) ?? 100;
+        if (pa !== pb)
+            return pa - pb;
+        return a.displayName.localeCompare(b.displayName);
+    });
+    return free;
+}

package/dist/shared/roomAttention.d.ts

@@ -0,0 +1,17 @@
+import type { AgentRunStatus, ApprovalRequestInfo, PingInfo } from "./events.js";
+export type AttentionKind = "approval" | "ping" | "error" | "drive" | "running" | "unread";
+export type RoomAttention = {
+    kind: AttentionKind;
+    label: string;
+    count?: number;
+};
+export declare function computeRoomAttention({ pendingApprovals, openPings, agentError, errorByAgent, agentStatus, statusByAgent, pendingDrive, unreadCount, }: {
+    pendingApprovals: ApprovalRequestInfo[];
+    openPings: PingInfo[];
+    agentError: string;
+    errorByAgent: Record<string, string>;
+    agentStatus: AgentRunStatus;
+    statusByAgent: Record<string, AgentRunStatus>;
+    pendingDrive: boolean;
+    unreadCount: number;
+}): RoomAttention | null;

package/dist/shared/roomAttention.js

@@ -0,0 +1,36 @@
+export function computeRoomAttention({ pendingApprovals, openPings, agentError, errorByAgent, agentStatus, statusByAgent, pendingDrive, unreadCount, }) {
+    if (pendingApprovals.length > 0) {
+        return {
+            kind: "approval",
+            label: pendingApprovals.length === 1 ? "Approval" : "Approvals",
+            count: pendingApprovals.length,
+        };
+    }
+    if (openPings.length > 0) {
+        return {
+            kind: "ping",
+            label: openPings.length === 1 ? "Review ping" : "Review pings",
+            count: openPings.length,
+        };
+    }
+    const errors = Object.values(errorByAgent).filter(Boolean);
+    if (agentError || errors.length) {
+        return { kind: "error", label: "Error" };
+    }
+    if (pendingDrive) {
+        return { kind: "drive", label: "Drive request" };
+    }
+    const running = agentStatus === "running" ||
+        Object.values(statusByAgent).some((status) => status === "running");
+    if (running) {
+        return { kind: "running", label: "Running" };
+    }
+    if (unreadCount > 0) {
+        return {
+            kind: "unread",
+            label: unreadCount === 1 ? "New message" : "New messages",
+            count: unreadCount,
+        };
+    }
+    return null;
+}

package/dist/shared/roomContext.d.ts

@@ -0,0 +1,120 @@
+/** Room-scoped repo map + shared memory contracts. */
+export declare const MEMORY_KINDS: readonly ["goal", "decision", "constraint", "discovery", "handoff", "feedback"];
+export type MemoryKind = (typeof MEMORY_KINDS)[number];
+export declare const MEMORY_STATUSES: readonly ["active", "proposed", "archived", "superseded"];
+export type MemoryStatus = (typeof MEMORY_STATUSES)[number];
+export declare const MEMORY_SOURCES: readonly ["human", "auto", "agent_proposed"];
+export type MemorySource = (typeof MEMORY_SOURCES)[number];
+export declare const AUTO_MEMORY_MODES: readonly ["off", "extract"];
+export type AutoMemoryMode = (typeof AUTO_MEMORY_MODES)[number];
+export declare function isMemorySource(v: unknown): v is MemorySource;
+export declare function parseAutoMemoryMode(raw: unknown, fallback?: AutoMemoryMode): AutoMemoryMode;
+export type RepoMapStatus = "idle" | "scanning" | "ready" | "error";
+export type RepoMapNodeKind = "file" | "symbol";
+export type RepoMapEdgeRel = "contains" | "imports" | "requires" | "references";
+export interface RepoMapNode {
+    id: string;
+    kind: RepoMapNodeKind;
+    path: string;
+    ext?: string;
+    keywords: string[];
+    name?: string;
+    symbolType?: string;
+    lineStart?: number;
+    lineEnd?: number;
+    exported?: boolean;
+}
+export interface RepoMapEdge {
+    from: string;
+    to: string;
+    rel: RepoMapEdgeRel;
+}
+export interface RepoMapGraph {
+    nodes: RepoMapNode[];
+    edges: RepoMapEdge[];
+}
+export interface RepoMapInfo {
+    id: string;
+    roomId: string;
+    repoKey: string;
+    gitSha: string | null;
+    status: RepoMapStatus;
+    error?: string | null;
+    fileCount: number;
+    symbolCount: number;
+    edgeCount: number;
+    generatedAt: number;
+}
+export interface MemoryEntryInfo {
+    id: string;
+    roomId: string;
+    kind: MemoryKind;
+    title: string;
+    content: string;
+    status: MemoryStatus;
+    pinned: boolean;
+    revision: number;
+    createdByUserId?: string | null;
+    createdByAgentId?: string | null;
+    createdAt: number;
+    updatedAt: number;
+    sourceMessageId?: string | null;
+    sourcePath?: string | null;
+    supersedesId?: string | null;
+    /** Who wrote this row. Auto entries are extractor-created, no click. */
+    source?: MemorySource;
+}
+export interface AgentContextReceiptInfo {
+    id: string;
+    roomId: string;
+    agentId: string;
+    runId: string;
+    mapId?: string | null;
+    gitSha?: string | null;
+    memoryVersion: number;
+    entryIds: string[];
+    fileIds: string[];
+    isBaseline: boolean;
+    createdAt: number;
+}
+export interface HandoffDraft {
+    title: string;
+    content: string;
+    sourcePath?: string;
+    branch?: string | null;
+    prUrl?: string | null;
+    touchedPaths: string[];
+}
+export interface RoomContextSnapshot {
+    memoryVersion: number;
+    map: RepoMapInfo | null;
+    entries: MemoryEntryInfo[];
+    lastReceiptByAgent: Record<string, AgentContextReceiptInfo>;
+}
+export interface PackedContext {
+    text: string;
+    memoryVersion: number;
+    mapId: string | null;
+    gitSha: string | null;
+    entryIds: string[];
+    fileIds: string[];
+    isBaseline: boolean;
+    estimatedChars: number;
+}
+export declare const MEMORY_TITLE_MAX = 160;
+export declare const MEMORY_CONTENT_MAX = 4000;
+export declare const CONTEXT_BUDGET_CHARS = 12000;
+export declare const BASELINE_BUDGET_CHARS = 8000;
+export declare const TASK_PACK_FILES = 12;
+export declare const TASK_PACK_EDGES = 20;
+export declare function isMemoryKind(v: unknown): v is MemoryKind;
+/** Standing instructions / jailbreak-shaped text must never auto-accept. */
+export declare function looksLikeMemoryInjection(input: string): boolean;
+export declare function isMemoryStatus(v: unknown): v is MemoryStatus;
+export declare function stripControlChars(input: string): string;
+export declare function redactSecrets(input: string): string;
+export declare function sanitizeMemoryText(input: unknown, max: number): string;
+export declare function tokenizeQuery(text: string): string[];
+export type ContextIntent = "debug" | "explain" | "test" | "refactor" | "feature" | "edit" | "general";
+export declare function classifyIntent(query: string): ContextIntent;
+export declare function wrapUntrustedBlock(tag: string, attrs: string, body: string): string;