@romiluz/clawmongo 0.1.0-rc.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Rom Iluz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,3 @@
+# ClawMongo
+
+A new project created with Intent by Augment.

package/dist/cli/boundary-contract-smoke.js

@@ -0,0 +1,108 @@
+import assert from "node:assert/strict";
+import { validateEventEnvelope, validateGatewayToOrchestratorRequest, validateOrchestratorToProviderRequest, validateOrchestratorToToolRuntimeRequest } from "../contracts/validators.js";
+function assertValidationError(result, expectedBoundary) {
+    assert.equal(result.ok, false, "validation should fail");
+    if (result.ok) {
+        return;
+    }
+    assert.equal(result.error.code, "VALIDATION_ERROR");
+    assert.equal(result.error.retryable, false);
+    assert.equal(result.error.details.boundary, expectedBoundary);
+}
+function run() {
+    const gatewayValid = validateGatewayToOrchestratorRequest({
+        requestId: "req-001",
+        tenantId: "tenant-demo",
+        workspaceId: "workspace-alpha",
+        actor: "user:123",
+        sessionKey: "agent:agent-alpha:main",
+        inputPayload: { text: "hello" }
+    });
+    assert.equal(gatewayValid.ok, true);
+    if (gatewayValid.ok) {
+        assert.equal(gatewayValid.value.request_id, "req-001");
+        assert.equal(gatewayValid.value.mode, "sync");
+    }
+    const gatewayInvalid = validateGatewayToOrchestratorRequest({
+        request_id: "req-002",
+        workspace_id: "workspace-alpha",
+        actor: "user:123",
+        session_key: "agent:agent-alpha:main",
+        input_payload: { text: "missing tenant_id" },
+        mode: "sync"
+    });
+    assertValidationError(gatewayInvalid, "gateway->orchestrator.v1");
+    const providerValid = validateOrchestratorToProviderRequest({
+        provider: "openai",
+        model: "gpt-5-mini",
+        messages: [{ role: "user", content: "hi" }],
+        toolContext: { run_mode: "smoke" },
+        generationConfig: { temperature: 0 }
+    });
+    assert.equal(providerValid.ok, true);
+    if (providerValid.ok) {
+        assert.equal(providerValid.value.provider, "openai");
+        assert.equal(providerValid.value.messages.length, 1);
+    }
+    const providerInvalid = validateOrchestratorToProviderRequest({
+        provider: "openai",
+        model: "gpt-5-mini",
+        messages: "not-an-array",
+        tool_context: {},
+        generation_config: {}
+    });
+    assertValidationError(providerInvalid, "orchestrator->provider.v1");
+    const toolValid = validateOrchestratorToToolRuntimeRequest({
+        toolName: "fetch_profile",
+        toolCallId: "call-001",
+        params: { user_id: "u-123" },
+        policyContext: { tenant_id: "tenant-demo" }
+    });
+    assert.equal(toolValid.ok, true);
+    if (toolValid.ok) {
+        assert.equal(toolValid.value.tool_name, "fetch_profile");
+        assert.equal(toolValid.value.tool_call_id, "call-001");
+    }
+    const toolInvalid = validateOrchestratorToToolRuntimeRequest({
+        tool_call_id: "call-002",
+        params: {},
+        policy_context: {}
+    });
+    assertValidationError(toolInvalid, "orchestrator->tool-runtime.v1");
+    const eventValid = validateEventEnvelope({
+        eventId: "evt-001",
+        eventType: "tool.side_effect.appended",
+        aggregateId: "tool-run:call-001",
+        tenantId: "tenant-demo",
+        payload: {
+            side_effect_ref: "sidefx:fetch_profile:call-001"
+        },
+        createdAt: "2026-02-11T00:00:00.000Z",
+        traceId: "trace-evt-001"
+    });
+    assert.equal(eventValid.ok, true);
+    if (eventValid.ok) {
+        assert.equal(eventValid.value.event_id, "evt-001");
+        assert.equal(eventValid.value.event_type, "tool.side_effect.appended");
+    }
+    const eventInvalid = validateEventEnvelope({
+        event_type: "tool.side_effect.appended",
+        aggregate_id: "tool-run:call-001",
+        tenant_id: "tenant-demo",
+        payload: {},
+        created_at: "2026-02-11T00:00:00.000Z",
+        trace_id: "trace-evt-002"
+    });
+    assertValidationError(eventInvalid, "eventing->outbox.v1");
+    process.stdout.write(`${JSON.stringify({
+        status: "PASS",
+        checks: [
+            { id: "gateway_mapper_and_validator", ok: true },
+            { id: "provider_mapper_and_validator", ok: true },
+            { id: "tool_runtime_mapper_and_validator", ok: true },
+            { id: "eventing_mapper_and_validator", ok: true },
+            { id: "validation_error_taxonomy", ok: true }
+        ]
+    }, null, 2)}\n`);
+}
+run();

package/dist/cli/embedding-policy-smoke.js

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { applyEmbeddingPolicyToScope, DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_PROVIDER, resolveEmbeddingPolicy } from "../retrieval/embeddings/policy.js";
+function run() {
+    const defaults = resolveEmbeddingPolicy({
+        tenant_id: "tenant-demo"
+    });
+    assert.equal(defaults.provider, DEFAULT_EMBEDDING_PROVIDER);
+    assert.equal(defaults.model, DEFAULT_EMBEDDING_MODEL);
+    assert.equal(defaults.source, "defaults");
+    const override = resolveEmbeddingPolicy({
+        tenant_id: "tenant-demo",
+        embedding_provider: "voyage",
+        embedding_model: "voyage-3-lite"
+    });
+    assert.equal(override.provider, "voyage");
+    assert.equal(override.model, "voyage-3-lite");
+    assert.equal(override.source, "scope_override");
+    const partialOverride = resolveEmbeddingPolicy({
+        tenant_id: "tenant-demo",
+        embedding_model: "voyage-4-large"
+    });
+    assert.equal(partialOverride.provider, DEFAULT_EMBEDDING_PROVIDER);
+    assert.equal(partialOverride.model, "voyage-4-large");
+    assert.equal(partialOverride.source, "scope_override");
+    const noOverridePolicy = resolveEmbeddingPolicy({
+        embedding_provider: "custom-provider",
+        embedding_model: "custom-model"
+    }, {
+        allowScopeOverride: false
+    });
+    assert.equal(noOverridePolicy.provider, DEFAULT_EMBEDDING_PROVIDER);
+    assert.equal(noOverridePolicy.model, DEFAULT_EMBEDDING_MODEL);
+    assert.equal(noOverridePolicy.source, "defaults");
+    const scoped = applyEmbeddingPolicyToScope({
+        tenant_id: "tenant-demo",
+        workspace_id: "workspace-alpha"
+    }, override);
+    assert.equal(scoped.embedding_provider, "voyage");
+    assert.equal(scoped.embedding_model, "voyage-3-lite");
+    process.stdout.write(`${JSON.stringify({
+        status: "PASS",
+        checks: [
+            {
+                id: "embedding_policy_defaults",
+                ok: true,
+                policy: defaults
+            },
+            {
+                id: "embedding_policy_scope_override",
+                ok: true,
+                policy: override
+            },
+            {
+                id: "embedding_policy_partial_override",
+                ok: true,
+                policy: partialOverride
+            },
+            {
+                id: "embedding_policy_override_disabled",
+                ok: true,
+                policy: noOverridePolicy
+            }
+        ]
+    }, null, 2)}\n`);
+}
+run();

package/dist/cli/embedding-provider-live-smoke.js

@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import { createDefaultEmbeddingProviderRegistry, embedTextsWithPolicy } from "../retrieval/embeddings/provider.js";
+import { resolveEmbeddingPolicy } from "../retrieval/embeddings/policy.js";
+function hasAnyEnv(keys) {
+    return keys.some((key) => {
+        const value = process.env[key];
+        return typeof value === "string" && value.trim().length > 0;
+    });
+}
+function detectLiveProviders() {
+    const voyage = hasAnyEnv(["CLAWMONGO_VOYAGE_API_KEY", "VOYAGE_API_KEY"]);
+    const openai = hasAnyEnv(["CLAWMONGO_OPENAI_API_KEY", "OPENAI_API_KEY"]);
+    const globalDimensions = Number(process.env.CLAWMONGO_EMBEDDING_LIVE_DIMENSIONS ?? "");
+    const voyageDimensions = Number(process.env.CLAWMONGO_VOYAGE_EMBEDDING_DIMENSIONS ?? "");
+    const openaiDimensions = Number(process.env.CLAWMONGO_OPENAI_EMBEDDING_DIMENSIONS ?? "");
+    const pickDimensions = (provider) => {
+        const providerValue = provider === "voyage" ? voyageDimensions : openaiDimensions;
+        if (Number.isInteger(providerValue) && providerValue > 0) {
+            return providerValue;
+        }
+        if (Number.isInteger(globalDimensions) && globalDimensions > 0) {
+            return globalDimensions;
+        }
+        // Keep live smoke dimensions provider-valid by default.
+        return 256;
+    };
+    const allProviders = [
+        {
+            provider: "voyage",
+            model: process.env.CLAWMONGO_VOYAGE_EMBEDDING_MODEL ?? "voyage-4-large",
+            dimensions: pickDimensions("voyage"),
+            hasKey: voyage
+        },
+        {
+            provider: "openai",
+            model: process.env.CLAWMONGO_OPENAI_EMBEDDING_MODEL ?? "text-embedding-3-large",
+            dimensions: pickDimensions("openai"),
+            hasKey: openai
+        }
+    ];
+    return allProviders.filter((entry) => entry.hasKey);
+}
+async function run() {
+    if (process.env.CLAWMONGO_EMBEDDING_LIVE !== "true") {
+        process.stdout.write(`${JSON.stringify({
+            status: "SKIP",
+            reason: "Set CLAWMONGO_EMBEDDING_LIVE=true to run live embedding smoke checks."
+        }, null, 2)}\n`);
+        return;
+    }
+    const providers = detectLiveProviders();
+    if (providers.length === 0) {
+        process.stdout.write(`${JSON.stringify({
+            status: "SKIP",
+            reason: "No live embedding API keys detected. Provide Voyage and/or OpenAI keys to run this check."
+        }, null, 2)}\n`);
+        return;
+    }
+    const registry = createDefaultEmbeddingProviderRegistry({ preferLive: true });
+    const checks = [];
+    for (const providerConfig of providers) {
+        const policy = resolveEmbeddingPolicy({
+            embedding_provider: providerConfig.provider,
+            embedding_model: providerConfig.model
+        });
+        const result = await embedTextsWithPolicy(["ClawMongo live embedding smoke verification query"], policy, {
+            dimensions: providerConfig.dimensions,
+            inputType: "query",
+            registry
+        });
+        assert.equal(result.provider, providerConfig.provider);
+        assert.equal(result.model, providerConfig.model);
+        assert.equal(result.source, "live");
+        assert.equal(result.dimensions, providerConfig.dimensions);
+        assert.equal(result.vectors.length, 1);
+        assert.equal(result.vectors[0]?.length, providerConfig.dimensions);
+        checks.push({
+            provider: result.provider,
+            model: result.model,
+            source: result.source,
+            dimensions: result.dimensions,
+            vectorCount: result.vectors.length
+        });
+    }
+    process.stdout.write(`${JSON.stringify({
+        status: "PASS",
+        checks
+    }, null, 2)}\n`);
+}
+void run().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`embedding-provider-live-smoke failed: ${message}\n`);
+    process.exitCode = 1;
+});

package/dist/cli/embedding-provider-smoke.js

@@ -0,0 +1,81 @@
+import assert from "node:assert/strict";
+import { createDefaultEmbeddingProviderRegistry, embedTextsWithPolicy, resolveEmbeddingProvider } from "../retrieval/embeddings/provider.js";
+import { resolveEmbeddingPolicy } from "../retrieval/embeddings/policy.js";
+import { resolveQueryEmbeddingVector } from "../retrieval/embeddings/query-vector.js";
+async function run() {
+    const registry = createDefaultEmbeddingProviderRegistry({ preferLive: false });
+    const policy = resolveEmbeddingPolicy({
+        embedding_provider: "voyage",
+        embedding_model: "voyage/voyage-4-large"
+    });
+    const provider = resolveEmbeddingProvider(policy, registry);
+    assert.equal(provider.provider, "voyage");
+    const batchA = await embedTextsWithPolicy(["Slack IDs keep case", "Mongo rank fusion fallback"], policy, {
+        dimensions: 8,
+        registry
+    });
+    const batchB = await embedTextsWithPolicy(["Slack IDs keep case", "Mongo rank fusion fallback"], policy, {
+        dimensions: 8,
+        registry
+    });
+    assert.equal(batchA.provider, "voyage");
+    assert.equal(batchA.model, "voyage-4-large");
+    assert.equal(batchA.dimensions, 8);
+    assert.equal(batchA.vectors.length, 2);
+    assert.equal(batchA.vectors[0]?.length, 8);
+    assert.deepEqual(batchA.vectors, batchB.vectors, "deterministic vectors should be stable");
+    const unsupportedPolicy = resolveEmbeddingPolicy({
+        embedding_provider: "custom-provider",
+        embedding_model: "custom-model"
+    });
+    let unsupportedError = null;
+    try {
+        resolveEmbeddingProvider(unsupportedPolicy, registry);
+    }
+    catch (error) {
+        unsupportedError = error instanceof Error ? error.message : String(error);
+    }
+    assert.ok(unsupportedError && unsupportedError.includes("Unsupported embedding provider"));
+    const scopeFallback = await resolveQueryEmbeddingVector({
+        query: "Unsupported provider should degrade, not crash",
+        scopeFilters: {
+            embedding_provider: "custom-provider",
+            embedding_model: "custom-model",
+            tenant_id: "tenant-demo"
+        },
+        topK: 3,
+        profile: "atlas-default",
+        preferNativeFusion: true
+    }, 8);
+    assert.equal(scopeFallback.vector.length, 8);
+    assert.equal(scopeFallback.degraded, true);
+    assert.ok(scopeFallback.note.includes("fallback"));
+    process.stdout.write(`${JSON.stringify({
+        status: "PASS",
+        checks: [
+            {
+                id: "provider_registry_resolution",
+                ok: true,
+                provider: provider.provider
+            },
+            {
+                id: "deterministic_embedding_batch",
+                ok: true,
+                dimensions: batchA.dimensions,
+                vectorCount: batchA.vectors.length
+            },
+            {
+                id: "unsupported_provider_error",
+                ok: true,
+                message: unsupportedError
+            },
+            {
+                id: "query_embedding_scope_fallback",
+                ok: true,
+                degraded: scopeFallback.degraded,
+                note: scopeFallback.note
+            }
+        ]
+    }, null, 2)}\n`);
+}
+void run();

package/dist/cli/embedding-provider-voyage-batch-smoke.js

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import { createDefaultEmbeddingProviderRegistry, embedTextsWithPolicy } from "../retrieval/embeddings/provider.js";
+import { resolveEmbeddingPolicy } from "../retrieval/embeddings/policy.js";
+function jsonResponse(payload, status = 200) {
+    return new Response(JSON.stringify(payload), {
+        status,
+        headers: { "content-type": "application/json" }
+    });
+}
+function textResponse(payload, status = 200) {
+    return new Response(payload, {
+        status,
+        headers: { "content-type": "text/plain" }
+    });
+}
+async function run() {
+    const originalFetch = globalThis.fetch;
+    const originalEnv = {
+        CLAWMONGO_VOYAGE_API_KEY: process.env.CLAWMONGO_VOYAGE_API_KEY,
+        CLAWMONGO_VOYAGE_API_BASE: process.env.CLAWMONGO_VOYAGE_API_BASE
+    };
+    const calls = [];
+    let createBatchBody = null;
+    process.env.CLAWMONGO_VOYAGE_API_KEY = "test-key";
+    process.env.CLAWMONGO_VOYAGE_API_BASE = "https://api.voyageai.com/v1";
+    globalThis.fetch = (async (input, init) => {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+        const method = init?.method ?? "GET";
+        calls.push({ url, method });
+        if (url.endsWith("/files") && method === "POST") {
+            const body = init?.body;
+            assert.ok(body instanceof FormData, "file upload must use FormData");
+            assert.equal(body.get("purpose"), "batch");
+            return jsonResponse({ id: "file-123" });
+        }
+        if (url.endsWith("/batches") && method === "POST") {
+            const body = init?.body;
+            assert.equal(typeof body, "string");
+            createBatchBody = JSON.parse(body);
+            return jsonResponse({ id: "batch-abc", status: "pending" });
+        }
+        if (url.endsWith("/batches/batch-abc") && method === "GET") {
+            return jsonResponse({
+                id: "batch-abc",
+                status: "completed",
+                output_file_id: "file-out-999"
+            });
+        }
+        if (url.endsWith("/files/file-out-999/content") && method === "GET") {
+            const lines = [
+                JSON.stringify({
+                    custom_id: "req-1",
+                    response: {
+                        status_code: 200,
+                        body: { data: [{ embedding: [0.1, 0.1, 0.1] }] }
+                    }
+                }),
+                JSON.stringify({
+                    custom_id: "req-2",
+                    response: {
+                        status_code: 200,
+                        body: { data: [{ embedding: [0.2, 0.2, 0.2] }] }
+                    }
+                })
+            ].join("\n");
+            return textResponse(lines);
+        }
+        throw new Error(`Unexpected fetch call: ${method} ${url}`);
+    });
+    try {
+        const registry = createDefaultEmbeddingProviderRegistry({ preferLive: true });
+        const policy = resolveEmbeddingPolicy({
+            embedding_provider: "voyage",
+            embedding_model: "voyage/voyage-4-large"
+        });
+        const result = await embedTextsWithPolicy(["document one", "document two"], policy, {
+            registry,
+            inputType: "document",
+            remoteBatch: true,
+            remoteBatchMinTexts: 1,
+            remoteBatchPollIntervalMs: 1,
+            remoteBatchTimeoutMs: 1000
+        });
+        assert.equal(result.provider, "voyage");
+        assert.equal(result.model, "voyage-4-large");
+        assert.equal(result.source, "live");
+        assert.equal(result.vectors.length, 2);
+        assert.deepEqual(result.vectors[0], [0.1, 0.1, 0.1]);
+        assert.deepEqual(result.vectors[1], [0.2, 0.2, 0.2]);
+        assert.ok(createBatchBody, "batch-create payload should be captured");
+        const batchBody = createBatchBody;
+        const requestParams = (batchBody.request_params ?? null);
+        assert.equal(batchBody.input_file_id, "file-123");
+        assert.equal(batchBody.endpoint, "/v1/embeddings");
+        assert.equal(batchBody.completion_window, "12h");
+        assert.deepEqual(requestParams, {
+            model: "voyage-4-large",
+            input_type: "document"
+        });
+        process.stdout.write(`${JSON.stringify({
+            status: "PASS",
+            checks: [
+                {
+                    id: "voyage_remote_batch_flow",
+                    ok: true,
+                    fetchCallCount: calls.length
+                },
+                {
+                    id: "voyage_remote_batch_request_shape",
+                    ok: true,
+                    requestParams
+                }
+            ]
+        }, null, 2)}\n`);
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        process.env.CLAWMONGO_VOYAGE_API_KEY = originalEnv.CLAWMONGO_VOYAGE_API_KEY;
+        process.env.CLAWMONGO_VOYAGE_API_BASE = originalEnv.CLAWMONGO_VOYAGE_API_BASE;
+    }
+}
+void run().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stdout.write(`${JSON.stringify({
+        status: "FAIL",
+        error: message
+    }, null, 2)}\n`);
+    process.exitCode = 1;
+});

package/dist/cli/gateway-smoke.js

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import { createDefaultGatewayDependencies, executeGatewayRequest } from "../modules/gateway/service.js";
+async function run() {
+    const deps = createDefaultGatewayDependencies();
+    const successResponse = await executeGatewayRequest({
+        requestId: "gateway-success-001",
+        tenantId: "tenant-demo",
+        workspaceId: "workspace-alpha",
+        actor: "user:123",
+        sessionKey: "agent:agent-alpha:main",
+        traceId: "trace-success-001",
+        inputPayload: {
+            text: "hello gateway"
+        }
+    }, deps);
+    assert.equal(successResponse.status, "ok");
+    assert.equal(successResponse.request_id, "gateway-success-001");
+    assert.equal(successResponse.errors.length, 0);
+    assert.equal(typeof successResponse.timings.gateway_normalize_ms, "number");
+    assert.equal(typeof successResponse.timings.gateway_total_ms, "number");
+    const invalidResponse = await executeGatewayRequest({
+        requestId: "gateway-invalid-001",
+        workspaceId: "workspace-alpha",
+        actor: "user:123",
+        sessionKey: "agent:agent-alpha:main",
+        inputPayload: {}
+    }, deps);
+    assert.equal(invalidResponse.status, "error");
+    assert.equal(invalidResponse.errors[0]?.code, "VALIDATION_ERROR");
+    const dependencyFailureResponse = await executeGatewayRequest({
+        requestId: "gateway-dependency-fail-001",
+        tenantId: "tenant-demo",
+        workspaceId: "workspace-alpha",
+        actor: "user:123",
+        sessionKey: "agent:agent-alpha:main",
+        inputPayload: {
+            text: "trigger dependency failure"
+        }
+    }, {
+        orchestrator: async () => {
+            throw new Error("orchestrator unavailable");
+        }
+    });
+    assert.equal(dependencyFailureResponse.status, "error");
+    assert.equal(dependencyFailureResponse.errors[0]?.code, "DEPENDENCY_UNAVAILABLE");
+    assert.equal(dependencyFailureResponse.errors[0]?.retryable, true);
+    process.stdout.write(`${JSON.stringify({
+        status: "PASS",
+        checks: [
+            {
+                id: "gateway_normalization_and_forwarding",
+                ok: true
+            },
+            {
+                id: "gateway_validation_error",
+                ok: true
+            },
+            {
+                id: "gateway_dependency_error",
+                ok: true
+            }
+        ]
+    }, null, 2)}\n`);
+}
+void run();

package/dist/cli/health.js

@@ -0,0 +1,17 @@
+import { bootstrapRuntime, resolveProfileSummary } from "../runtime/bootstrap.js";
+async function run() {
+    const report = await bootstrapRuntime();
+    const response = {
+        status: report.status,
+        timestamp: report.timestamp,
+        request_id: report.requestId,
+        deployment_profile: report.profile,
+        deployment_profile_summary: resolveProfileSummary(report.profile),
+        modules: report.modules
+    };
+    process.stdout.write(`${JSON.stringify(response, null, 2)}\n`);
+    if (report.status !== "ready") {
+        process.exitCode = 1;
+    }
+}
+void run();

package/dist/cli/index-budget-smoke.js

@@ -0,0 +1,14 @@
+import assert from "node:assert/strict";
+import { assertSearchIndexBudget } from "../store/mongo/indexes.js";
+const baseline = assertSearchIndexBudget("atlas-m0", 2);
+assert.equal(baseline.withinBudget, true, "atlas-m0 should allow planned=2");
+assert.equal(baseline.budget, 3, "atlas-m0 budget should be 3");
+const overflow = assertSearchIndexBudget("atlas-m0", 4);
+assert.equal(overflow.withinBudget, false, "atlas-m0 should reject planned=4");
+process.stdout.write(`${JSON.stringify({
+    status: "PASS",
+    checks: [
+        { id: "atlas_m0_within_budget", result: baseline },
+        { id: "atlas_m0_over_budget", result: overflow }
+    ]
+}, null, 2)}\n`);