@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/context-search-workspace-source.test.ts

@@ -126,10 +126,15 @@ describe("searchWorkspaceSource", () => {
     writeWorkspaceFile(root, "api-key.md", "needle key");
     writeWorkspaceFile(root, "secret-plan.md", "needle secret");
     writeWorkspaceFile(root, "token-cache.md", "needle token");
+    writeWorkspaceFile(root, "apiKey.json", "needle camel key");
+    writeWorkspaceFile(root, "userToken.txt", "needle camel token");
+    writeWorkspaceFile(root, "MySecret.md", "needle camel secret");
     writeWorkspaceFile(root, "credentials.json", "needle credentials");
     writeWorkspaceFile(root, "protected/readme.md", "needle protected");
     writeWorkspaceFile(root, "gateway-security/readme.md", "needle gateway");
     writeWorkspaceFile(root, "ces-security/readme.md", "needle ces");
+    writeWorkspaceFile(root, "keyboard.ts", "needle keyboard");
+    writeWorkspaceFile(root, "tokenizer.py", "needle tokenizer");
     writeWorkspaceFile(root, "src/readme.md", "needle safe");
 
     const result = await searchWorkspaceSource("needle", makeContext(root), 10);
@@ -138,7 +143,9 @@ describe("searchWorkspaceSource", () => {
       ".hidden.md:1",
       ".notes/.format-rec.md:1",
       ".notes/cake.md:1",
+      "keyboard.ts:1",
       "src/readme.md:1",
+      "tokenizer.py:1",
     ]);
   });
 

package/src/__tests__/context-token-estimator.test.ts

@@ -33,6 +33,7 @@ function makePngBase64(width: number, height: number): string {
 describe("token estimator", () => {
   test("estimates text tokens from character length", () => {
     expect(estimateTextTokens("")).toBe(0);
+    expect(estimateTextTokens(undefined)).toBe(0);
     expect(estimateTextTokens("abcd")).toBe(1);
     expect(estimateTextTokens("abcde")).toBe(2);
   });
@@ -218,36 +219,7 @@ describe("token estimator", () => {
     expect(largeFileTokens).toBe(smallFileTokens);
   });
 
-  // Non-Anthropic providers use base64 payload size for image estimation
-  test("scales image token estimate with base64 payload size (non-Anthropic)", () => {
-    const smallImageTokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: {
-          type: "base64",
-          media_type: "image/png",
-          data: "a".repeat(64),
-        },
-      },
-      { providerName: "openai" },
-    );
-    const largeImageTokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: {
-          type: "base64",
-          media_type: "image/png",
-          data: "a".repeat(60_000),
-        },
-      },
-      { providerName: "openai" },
-    );
-
-    expect(largeImageTokens).toBeGreaterThan(smallImageTokens);
-    expect(largeImageTokens - smallImageTokens).toBeGreaterThan(1000);
-  });
-
-  test("estimates Anthropic image tokens from dimensions, not base64 size", () => {
+  test("estimates image tokens from dimensions, not base64 size", () => {
     // Build a minimal valid PNG header encoding 1920x1080 dimensions.
     // PNG header: 8-byte signature + 4-byte IHDR length + 4-byte "IHDR" + 4-byte width + 4-byte height = 24 bytes minimum
     const pngHeader = Buffer.alloc(24);
@@ -277,55 +249,49 @@ describe("token estimator", () => {
     const fullPayload = Buffer.concat([pngHeader, padding]);
     const base64Data = fullPayload.toString("base64");
 
-    const anthropicTokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: { type: "base64", media_type: "image/png", data: base64Data },
-      },
-      { providerName: "anthropic" },
-    );
-
     // 1920x1080 scaled to fit 1568px bounding box: dimScale = 1568/1920 = 0.8167
     // scaledWidth = round(1920 * 0.8167) = 1568, scaledHeight = round(1080 * 0.8167) = 882
     // pixels = 1568 * 882 = 1,382,976 > 1,200,000 → mpScale = sqrt(1200000/1382976) = 0.9315
     // scaledWidth = round(1568 * 0.9315) = 1461, scaledHeight = round(882 * 0.9315) = 822
     // tokens = ceil(1461 * 822 / 750) = ceil(1601.26) = ~1,602
-    // With IMAGE_BLOCK_OVERHEAD_TOKENS and media_type overhead, still well under 5000
-    expect(anthropicTokens).toBeLessThan(5_000);
-
-    // Verify it's NOT using base64 size (which would be ~50,000+ tokens)
-    const nonAnthropicTokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: { type: "base64", media_type: "image/png", data: base64Data },
-      },
-      { providerName: "openai" },
-    );
-    expect(nonAnthropicTokens).toBeGreaterThan(50_000);
+    // With IMAGE_BLOCK_OVERHEAD_TOKENS and media_type overhead, still well under 5000.
+    // Same result for every provider — dimension-based estimate is universal.
+    for (const providerName of ["anthropic", "openai", "openrouter"]) {
+      const tokens = estimateContentBlockTokens(
+        {
+          type: "image",
+          source: { type: "base64", media_type: "image/png", data: base64Data },
+        },
+        { providerName },
+      );
+      expect(tokens).toBeLessThan(5_000);
+    }
   });
 
-  test("falls back to max tokens when Anthropic image dimensions can't be parsed", () => {
+  test("falls back to max tokens when image dimensions can't be parsed", () => {
     // Corrupted base64 that won't parse as a valid image header
     const corruptedData = Buffer.from(
       "not-a-valid-image-header-at-all",
     ).toString("base64");
 
-    const tokens = estimateContentBlockTokens(
-      {
-        type: "image",
-        source: {
-          type: "base64",
-          media_type: "image/png",
-          data: corruptedData,
+    for (const providerName of ["anthropic", "openai", "openrouter"]) {
+      const tokens = estimateContentBlockTokens(
+        {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: "image/png",
+            data: corruptedData,
+          },
         },
-      },
-      { providerName: "anthropic" },
-    );
+        { providerName },
+      );
 
-    // Should fall back to ANTHROPIC_IMAGE_MAX_TOKENS (1,600)
-    // Total = 16 (block overhead) + ceil(9/4) (media_type) + 1600 = 1619
-    expect(tokens).toBeGreaterThanOrEqual(1_600);
-    expect(tokens).toBeLessThan(2_000);
+      // Falls back to the per-image cap (1,600 tokens). Total = 16 (block
+      // overhead) + ceil(9/4) (media_type) + 1600 = 1619.
+      expect(tokens).toBeGreaterThanOrEqual(1_600);
+      expect(tokens).toBeLessThan(2_000);
+    }
   });
 
   test("Anthropic image tokens are the same for same-dimension images regardless of payload size", () => {

package/src/__tests__/conversation-abort-tool-results.test.ts

@@ -55,7 +55,10 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { v2: { enabled: false } },
+    memory: {
+      v2: { enabled: false },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/conversation-agent-loop-inference-profile.test.ts

@@ -84,6 +84,7 @@ mock.module("../config/loader.js", () => ({
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     workspaceGit: { turnCommitMaxWaitMs: 10 },
+    memory: { retrieval: { scratchpadInjection: { enabled: true } } },
     ui: {},
   }),
   loadRawConfig: () => ({}),

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -7,8 +7,9 @@
  *   2. Token estimation significantly underestimates actual token count
  *   3. No mid-loop budget check to prevent hitting the provider limit
  *
- * All tests are test.todo — they document expected behavior for bugs
+ * Most tests are test.todo — they document expected behavior for bugs
  * to be fixed in subsequent PRs (PR 2 for tests 1–5, PR 3 for tests 6–7).
+ * Tests 2, 8, 9, and 10 are now active and passing against current code.
  */
 import { createRequire } from "node:module";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
@@ -87,7 +88,9 @@ mock.module("../config/loader.js", () => ({
     llm: mockLlmConfig,
     rateLimit: { maxRequestsPerMinute: 0 },
     workspaceGit: { turnCommitMaxWaitMs: 10 },
+    memory: { retrieval: { scratchpadInjection: { enabled: true } } },
     ui: {},
+    compaction: { enabled: true, autoThreshold: 0.7 },
   }),
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
@@ -851,111 +854,108 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
   // When estimation says we're within budget but the provider rejects,
   // the post-run convergence loop should kick in and recover.
   // This test should PASS against current code (when no progress is made).
-  test.todo(
-    "overflow recovery compacts below limit even when estimation underestimates",
-    async () => {
-      const events: ServerMessage[] = [];
-      let callCount = 0;
-      let reducerCalled = false;
+  test("overflow recovery compacts below limit even when estimation underestimates", async () => {
+    const events: ServerMessage[] = [];
+    let callCount = 0;
+    let reducerCalled = false;
 
-      // Estimator says 185k (below 190k budget = 200k * 0.95)
-      mockEstimateTokens = 185_000;
+    // Estimator says 185k (below 190k budget = 200k * 0.95)
+    mockEstimateTokens = 185_000;
 
-      // Reducer successfully compacts
-      mockReducerStepFn = (msgs: Message[]) => {
-        reducerCalled = true;
-        return {
+    // Reducer successfully compacts
+    mockReducerStepFn = (msgs: Message[]) => {
+      reducerCalled = true;
+      return {
+        messages: msgs,
+        tier: "forced_compaction",
+        state: {
+          appliedTiers: ["forced_compaction"],
+          injectionMode: "full",
+          exhausted: false,
+        },
+        estimatedTokens: 100_000,
+        compactionResult: {
+          compacted: true,
           messages: msgs,
-          tier: "forced_compaction",
-          state: {
-            appliedTiers: ["forced_compaction"],
-            injectionMode: "full",
-            exhausted: false,
-          },
-          estimatedTokens: 100_000,
-          compactionResult: {
-            compacted: true,
-            messages: msgs,
-            compactedPersistedMessages: 10,
-            summaryText: "Summary",
-            previousEstimatedInputTokens: 185_000,
-            estimatedInputTokens: 100_000,
-            maxInputTokens: 200_000,
-            thresholdTokens: 160_000,
-            compactedMessages: 20,
-            summaryCalls: 1,
-            summaryInputTokens: 800,
-            summaryOutputTokens: 300,
-            summaryModel: "mock-model",
-          },
-        };
+          compactedPersistedMessages: 10,
+          summaryText: "Summary",
+          previousEstimatedInputTokens: 185_000,
+          estimatedInputTokens: 100_000,
+          maxInputTokens: 200_000,
+          thresholdTokens: 160_000,
+          compactedMessages: 20,
+          summaryCalls: 1,
+          summaryInputTokens: 800,
+          summaryOutputTokens: 300,
+          summaryModel: "mock-model",
+        },
       };
+    };
 
-      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
-        callCount++;
-        if (callCount === 1) {
-          // Provider rejects with "prompt is too long: 242201 tokens > 200000"
-          // even though estimator said 185k
-          onEvent({
-            type: "error",
-            error: new Error(
-              "prompt is too long: 242201 tokens > 200000 maximum",
-            ),
-          });
-          onEvent({
-            type: "usage",
-            inputTokens: 0,
-            outputTokens: 0,
-            model: "test-model",
-            providerDurationMs: 10,
-          });
-          // No progress — return same messages
-          return messages;
-        }
-        // Second call succeeds
+    const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+      callCount++;
+      if (callCount === 1) {
+        // Provider rejects with "prompt is too long: 242201 tokens > 200000"
+        // even though estimator said 185k
         onEvent({
-          type: "message_complete",
-          message: {
-            role: "assistant",
-            content: [{ type: "text", text: "recovered" }],
-          },
+          type: "error",
+          error: new Error(
+            "prompt is too long: 242201 tokens > 200000 maximum",
+          ),
         });
         onEvent({
           type: "usage",
-          inputTokens: 80_000,
-          outputTokens: 200,
+          inputTokens: 0,
+          outputTokens: 0,
           model: "test-model",
-          providerDurationMs: 500,
+          providerDurationMs: 10,
         });
-        return [
-          ...messages,
-          {
-            role: "assistant" as const,
-            content: [{ type: "text", text: "recovered" }] as ContentBlock[],
-          },
-        ];
-      };
-
-      const ctx = makeCtx({
-        agentLoopRun,
-        contextWindowManager: {
-          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-          maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        // No progress — return same messages
+        return messages;
+      }
+      // Second call succeeds
+      onEvent({
+        type: "message_complete",
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "recovered" }],
+        },
       });
+      onEvent({
+        type: "usage",
+        inputTokens: 80_000,
+        outputTokens: 200,
+        model: "test-model",
+        providerDurationMs: 500,
+      });
+      return [
+        ...messages,
+        {
+          role: "assistant" as const,
+          content: [{ type: "text", text: "recovered" }] as ContentBlock[],
+        },
+      ];
+    };
 
-      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+    const ctx = makeCtx({
+      agentLoopRun,
+      contextWindowManager: {
+        shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
+        maybeCompact: async () => ({ compacted: false }),
+      } as unknown as AgentLoopConversationContext["contextWindowManager"],
+    });
 
-      // The reducer should be called in the convergence loop
-      expect(reducerCalled).toBe(true);
-      // Should recover without conversation_error
-      const conversationError = events.find(
-        (e) => e.type === "conversation_error",
-      );
-      expect(conversationError).toBeUndefined();
-      expect(callCount).toBe(2);
-    },
-  );
+    await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+    // The reducer should be called in the convergence loop
+    expect(reducerCalled).toBe(true);
+    // Should recover without conversation_error
+    const conversationError = events.find(
+      (e) => e.type === "conversation_error",
+    );
+    expect(conversationError).toBeUndefined();
+    expect(callCount).toBe(2);
+  });
 
   // ── Test 3 ────────────────────────────────────────────────────────
   // BUG: When the provider rejection reveals actual token count (e.g.,

package/src/__tests__/conversation-agent-loop.test.ts

@@ -61,7 +61,9 @@ mock.module("../config/loader.js", () => ({
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     workspaceGit: { turnCommitMaxWaitMs: 10 },
+    memory: { retrieval: { scratchpadInjection: { enabled: true } } },
     ui: mockUiConfig,
+    compaction: { enabled: true, autoThreshold: 0.7 },
   }),
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
@@ -384,6 +386,7 @@ mock.module("../daemon/history-repair.js", () => ({
 
 const recordUsageMock = mock(() => {});
 const recordRequestLogMock = mock(() => {});
+const backfillMessageIdOnLogsMock = mock(() => {});
 mock.module("../daemon/conversation-usage.js", () => ({
   recordUsage: recordUsageMock,
 }));
@@ -480,7 +483,7 @@ mock.module("../memory/archive-store.js", () => ({
 
 mock.module("../memory/llm-request-log-store.js", () => ({
   recordRequestLog: recordRequestLogMock,
-  backfillMessageIdOnLogs: () => {},
+  backfillMessageIdOnLogs: backfillMessageIdOnLogsMock,
 }));
 
 let mockHasProactiveArtifactCompleted = true;
@@ -656,6 +659,7 @@ beforeEach(() => {
   mockInjectionBlocks = {};
   recordUsageMock.mockClear();
   recordRequestLogMock.mockClear();
+  backfillMessageIdOnLogsMock.mockClear();
   syncMessageToDiskMock.mockClear();
   rebuildConversationDiskViewFromDbStateMock.mockClear();
   updateMessageMetadataMock.mockClear();
@@ -2853,6 +2857,60 @@ describe("session-agent-loop", () => {
       );
       expect(conversationErrors.length).toBeGreaterThanOrEqual(1);
     });
+
+    test("pipes synthetic assistant message id into provider-error log rows via backfill", async () => {
+      // Codex P1 regression test: the provider-failure turn must not leave
+      // its `llm_request_logs` row orphaned. Without the backfill call in
+      // the synthetic-message branch, a later turn's `handleMessageComplete`
+      // sweep would wrong-attach this row to the wrong assistant message.
+      const events: ServerMessage[] = [];
+
+      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+        // 1) handleProviderError -> writes an `llm_request_logs` row with
+        //    messageId=null (the orphan we are trying to link).
+        onEvent({
+          type: "provider_error",
+          error: new Error("upstream 500"),
+          rawRequest: { model: "gpt-4.1", messages: [] },
+          actualProvider: "openai",
+        });
+        // 2) handleError -> sets `state.providerErrorUserMessage`, which
+        //    activates the synthetic-message branch below the loop.
+        onEvent({
+          type: "error",
+          error: new Error("upstream 500"),
+        });
+        // Provider returned no assistant content — same messages back.
+        return messages;
+      };
+
+      const ctx = makeCtx({ agentLoopRun });
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      // The orphan was written with messageId=undefined.
+      expect(recordRequestLogMock).toHaveBeenCalledTimes(1);
+      const recordCall = recordRequestLogMock.mock.calls[0] as unknown as [
+        string,
+        string,
+        string,
+        string | undefined,
+        string | undefined,
+      ];
+      expect(recordCall[0]).toBe("test-conv");
+      expect(recordCall[3]).toBeUndefined();
+
+      // The synthetic-message branch then piped the assigned message id
+      // (from the mocked `addMessage` -> `{ id: "mock-msg-id" }`) into the
+      // backfill primitive, scoped to this conversation.
+      expect(backfillMessageIdOnLogsMock).toHaveBeenCalledTimes(1);
+      const backfillCall =
+        backfillMessageIdOnLogsMock.mock.calls[0] as unknown as [
+          string,
+          string,
+        ];
+      expect(backfillCall[0]).toBe("test-conv");
+      expect(backfillCall[1]).toBe("mock-msg-id");
+    });
   });
 
   describe("pkbSystemReminderBlock metadata persistence", () => {

package/src/__tests__/conversation-error.test.ts

@@ -596,12 +596,51 @@ describe("classifyConversationError", () => {
       expect(result.retryable).toBe(true);
     });
 
-    it("classifies ProviderError with 401 as PROVIDER_NOT_CONFIGURED (non-retryable)", () => {
+    it("classifies ProviderError with 401 as PROVIDER_INVALID_KEY (non-retryable)", () => {
+      // 401 means the upstream provider rejected the configured key
+      // (vs. PROVIDER_NOT_CONFIGURED which is for a never-set key).
+      // The macOS chat renders these on different banners.
       const err = new ProviderError("Unauthorized", "anthropic", 401);
       const result = classifyConversationError(err, baseCtx);
-      expect(result.code).toBe("PROVIDER_NOT_CONFIGURED");
+      expect(result.code).toBe("PROVIDER_INVALID_KEY");
       expect(result.retryable).toBe(false);
-      expect(result.errorCategory).toBe("provider_not_configured");
+      expect(result.errorCategory).toBe("provider_invalid_key");
+    });
+
+    it("classifies ProviderError 401 with 'invalid x-api-key' message as PROVIDER_INVALID_KEY", () => {
+      // Regex-match branch — Anthropic's standard 401 wording.
+      const err = new ProviderError(
+        "Anthropic API error: invalid x-api-key",
+        "anthropic",
+        401,
+      );
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.code).toBe("PROVIDER_INVALID_KEY");
+      expect(result.errorCategory).toBe("provider_invalid_key");
+    });
+
+    it("classifies ProviderError 403 with 'invalid api key' message as PROVIDER_INVALID_KEY", () => {
+      const err = new ProviderError(
+        "OpenAI: Invalid API key",
+        "openai",
+        403,
+      );
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.code).toBe("PROVIDER_INVALID_KEY");
+      expect(result.errorCategory).toBe("provider_invalid_key");
+    });
+
+    it("includes connection/profile attribution in PROVIDER_INVALID_KEY when provided", () => {
+      const err = new ProviderError("Unauthorized", "anthropic", 401);
+      const result = classifyConversationError(err, {
+        ...baseCtx,
+        connectionName: "my-anthropic",
+        profileName: "personal",
+      });
+      expect(result.code).toBe("PROVIDER_INVALID_KEY");
+      expect(result.connectionName).toBe("my-anthropic");
+      expect(result.profileName).toBe("personal");
+      expect(result.userMessage).toContain("personal");
     });
 
     it("classifies direct ProviderError with 402 as provider_billing (non-retryable)", () => {

package/src/__tests__/conversation-fork-crud.test.ts

@@ -609,6 +609,88 @@ describe("forkConversation", () => {
     expect(await hydrateActivationState(db, fork.id)).toBeNull();
     expect(loadGraphMemoryState(fork.id)).toBeNull();
   });
+
+  test("does not copy memory state when the fork is truncated mid-history", async () => {
+    const source = createConversation("Truncated thread");
+    const firstMessage = await addMessage(
+      source.id,
+      "user",
+      "first turn",
+      undefined,
+      { skipIndexing: true },
+    );
+    await addMessage(source.id, "assistant", "first reply", undefined, {
+      skipIndexing: true,
+    });
+    const lastMessage = await addMessage(
+      source.id,
+      "user",
+      "second turn",
+      undefined,
+      { skipIndexing: true },
+    );
+
+    const db = getDb();
+    db.insert(activationState)
+      .values({
+        conversationId: source.id,
+        messageId: lastMessage.id,
+        stateJson: JSON.stringify({ "concepts/foo": 0.5 }),
+        everInjectedJson: JSON.stringify([{ slug: "concepts/foo", turn: 2 }]),
+        currentTurn: 2,
+        updatedAt: 1_700_000_000_000,
+      })
+      .run();
+    saveGraphMemoryState(
+      source.id,
+      JSON.stringify({
+        initialized: true,
+        needsReload: false,
+        inContext: ["node-foo"],
+        log: [{ nodeId: "node-foo", turn: 2 }],
+        currentTurn: 2,
+      }),
+    );
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: firstMessage.id,
+    });
+
+    expect(await hydrateActivationState(db, fork.id)).toBeNull();
+    expect(loadGraphMemoryState(fork.id)).toBeNull();
+  });
+
+  test("copies memory state when throughMessageId points at the last message", async () => {
+    const source = createConversation("Through-last thread");
+    const lastMessage = await addMessage(
+      source.id,
+      "user",
+      "only turn",
+      undefined,
+      { skipIndexing: true },
+    );
+
+    const db = getDb();
+    db.insert(activationState)
+      .values({
+        conversationId: source.id,
+        messageId: lastMessage.id,
+        stateJson: JSON.stringify({ "concepts/foo": 0.9 }),
+        everInjectedJson: JSON.stringify([{ slug: "concepts/foo", turn: 1 }]),
+        currentTurn: 1,
+        updatedAt: 1_700_000_000_000,
+      })
+      .run();
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: lastMessage.id,
+    });
+
+    const childState = await hydrateActivationState(db, fork.id);
+    expect(childState?.currentTurn).toBe(1);
+  });
 });
 
 describe("forkConversation + memory_retrospective_state", () => {