@vellumai/assistant 0.8.5 → 0.8.7-dev.202606052118.34cd356

package/src/__tests__/conversation-runtime-workspace.test.ts

@@ -1,11 +1,12 @@
-import { beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, test } from "bun:test";
 
-import { applyRuntimeInjections } from "../daemon/conversation-runtime-assembly.js";
-import { defaultInjectorsPlugin } from "../plugins/defaults/injectors.js";
 import {
-  registerPlugin,
-  resetPluginRegistryForTests,
-} from "../plugins/registry.js";
+  clearConversations,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import { applyRuntimeInjections } from "../daemon/conversation-runtime-assembly.js";
+import type { SurfaceData, SurfaceType } from "../daemon/message-protocol.js";
+import { createApp } from "../memory/app-store.js";
 import type { Message } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
@@ -16,6 +17,46 @@ function userMsg(text: string): Message {
   return { role: "user", content: [{ type: "text", text }] };
 }
 
+// `applyRuntimeInjections` synthesizes this conversation id when no
+// `turnContext` is supplied, so the `workspace-context` injector resolves the
+// live workspace block from the registry under this key.
+const FALLBACK_CONVERSATION_ID = "runtime-assembly-fallback";
+
+// Register the fallback conversation in the live registry so the runtime
+// injectors resolve their blocks from it (the orchestrator no longer threads
+// workspace or active-surface content as options).
+function registerFallbackConversation(fields: Record<string, unknown>): void {
+  setConversation(FALLBACK_CONVERSATION_ID, {
+    conversationId: FALLBACK_CONVERSATION_ID,
+    workingDir: "/sandbox",
+    // Non-dirty empty workspace by default so the workspace-context injector
+    // skips both the filesystem rescan and the DB refresh unless a test
+    // explicitly seeds a block via `workspaceTopLevelContext`.
+    workspaceTopLevelContext: "",
+    workspaceTopLevelDirty: false,
+    ...fields,
+  } as never);
+}
+
+// Seed the live conversation registry with a pre-rendered top-level block. The
+// cache is non-dirty with non-null content, so `resolveWorkspaceTopLevelContext`
+// returns it verbatim without rescanning the filesystem.
+function seedWorkspaceContext(text: string): void {
+  registerFallbackConversation({
+    workspaceTopLevelContext: text,
+    workspaceTopLevelDirty: false,
+  });
+}
+
+// Build the conversation surface-state map that `buildActiveSurfaceContext`
+// reads to render the `<active_workspace>` block.
+function makeSurfaceState(
+  surfaceId: string,
+  data: SurfaceData,
+): Map<string, { surfaceType: SurfaceType; data: SurfaceData }> {
+  return new Map([[surfaceId, { surfaceType: "dynamic_page", data }]]);
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -23,26 +64,21 @@ function userMsg(text: string): Message {
 const sampleContext =
   "<workspace>\nRoot: /sandbox\nDirectories: src, lib, tests\n</workspace>";
 
-// The standalone `injectWorkspaceTopLevelContext` helper was removed in
-// G2.1. The workspace-context default injector (registered by
-// `defaultInjectorsPlugin`) now emits the workspace block as a
-// `prepend-user-tail` placement during `applyRuntimeInjections`. The suite
-// below exercises that end-to-end path instead.
+// The workspace-context default injector emits the workspace block as a
+// `prepend-user-tail` placement during `applyRuntimeInjections`. It sources
+// the rendered block from the per-conversation workspace registry and
+// (re)injects only when the block is absent from the working messages, so the
+// suite seeds the registry and exercises that end-to-end path.
 
 describe("applyRuntimeInjections — workspace top-level context", () => {
-  beforeEach(() => {
-    // Post-G2.1: workspace injection is driven by the `workspace-context`
-    // default injector, so the plugin must be registered for the chain to
-    // produce a block. Each test gets a clean registry.
-    resetPluginRegistryForTests();
-    registerPlugin(defaultInjectorsPlugin);
+  afterEach(() => {
+    clearConversations();
   });
 
-  test("injects workspace context when provided", async () => {
+  test("injects workspace context when registered", async () => {
+    seedWorkspaceContext(sampleContext);
     const messages: Message[] = [userMsg("Hello")];
-    const { messages: result } = await applyRuntimeInjections(messages, {
-      workspaceTopLevelContext: sampleContext,
-    });
+    const { messages: result } = await applyRuntimeInjections(messages, {});
 
     expect(result).toHaveLength(1);
     expect(result[0].content).toHaveLength(2);
@@ -50,22 +86,38 @@ describe("applyRuntimeInjections — workspace top-level context", () => {
     expect((result[0].content[1] as { text: string }).text).toBe("Hello");
   });
 
-  test("does not inject when workspace context is null", async () => {
+  test("does not inject when no workspace context is registered", async () => {
     const messages: Message[] = [userMsg("Hello")];
-    const { messages: result } = await applyRuntimeInjections(messages, {
-      workspaceTopLevelContext: null,
-    });
+    const { messages: result } = await applyRuntimeInjections(messages, {});
 
     expect(result).toHaveLength(1);
     expect(result[0].content).toHaveLength(1);
   });
 
+  test("does not re-inject when the workspace block is already present", async () => {
+    // GIVEN the registry holds a workspace block AND the working messages
+    // already carry that block (a normal cached turn, post-injection).
+    seedWorkspaceContext(sampleContext);
+    const messages: Message[] = [userMsg(sampleContext), userMsg("Hello")];
+
+    // WHEN injections are applied
+    const { messages: result } = await applyRuntimeInjections(messages, {});
+
+    // THEN presence detection skips the block to keep the prefix stable.
+    expect(result).toHaveLength(2);
+    expect(result[1].content).toHaveLength(1);
+    expect((result[1].content[0] as { text: string }).text).toBe("Hello");
+  });
+
   test("workspace context appears before active surface context in content", async () => {
-    const messages: Message[] = [userMsg("Hello")];
-    const { messages: result } = await applyRuntimeInjections(messages, {
-      activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
+    registerFallbackConversation({
       workspaceTopLevelContext: sampleContext,
+      workspaceTopLevelDirty: false,
+      currentActiveSurfaceId: "sf_1",
+      surfaceState: makeSurfaceState("sf_1", { html: "<div>test</div>" }),
     });
+    const messages: Message[] = [userMsg("Hello")];
+    const { messages: result } = await applyRuntimeInjections(messages, {});
 
     // Workspace is injected last (in applyRuntimeInjections order) so it
     // prepends to whatever was already prepended by activeSurface.
@@ -77,18 +129,38 @@ describe("applyRuntimeInjections — workspace top-level context", () => {
     );
     expect((result[0].content[2] as { text: string }).text).toBe("Hello");
   });
+
+  test("app-backed active surface tells the model to load app-builder with the right argument", async () => {
+    const app = createApp({
+      name: "Example App",
+      schemaJson: "{}",
+      htmlDefinition: "<div>test</div>",
+    });
+    registerFallbackConversation({
+      currentActiveSurfaceId: "sf_1",
+      surfaceState: makeSurfaceState("sf_1", {
+        html: "<div>test</div>",
+        appId: app.id,
+      }),
+    });
+    const messages: Message[] = [userMsg("Edit this app")];
+    const { messages: result } = await applyRuntimeInjections(messages, {});
+
+    const activeWorkspaceText = (result[0].content[0] as { text: string }).text;
+    expect(activeWorkspaceText).toContain('skill: "app-builder"');
+    expect(activeWorkspaceText).not.toContain('id: "app-builder"');
+  });
 });
 
 describe("applyRuntimeInjections — minimal mode skips workspace blocks", () => {
-  beforeEach(() => {
-    resetPluginRegistryForTests();
-    registerPlugin(defaultInjectorsPlugin);
+  afterEach(() => {
+    clearConversations();
   });
 
   test("minimal mode skips workspace top-level context", async () => {
+    seedWorkspaceContext(sampleContext);
     const messages: Message[] = [userMsg("Hello")];
     const { messages: result } = await applyRuntimeInjections(messages, {
-      workspaceTopLevelContext: sampleContext,
       mode: "minimal",
     });
 
@@ -98,9 +170,12 @@ describe("applyRuntimeInjections — minimal mode skips workspace blocks", () =>
   });
 
   test("minimal mode skips active surface context", async () => {
+    registerFallbackConversation({
+      currentActiveSurfaceId: "sf_1",
+      surfaceState: makeSurfaceState("sf_1", { html: "<div>test</div>" }),
+    });
     const messages: Message[] = [userMsg("Hello")];
     const { messages: result } = await applyRuntimeInjections(messages, {
-      activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
       mode: "minimal",
     });
 
@@ -110,11 +185,14 @@ describe("applyRuntimeInjections — minimal mode skips workspace blocks", () =>
   });
 
   test("full mode (default) still includes workspace blocks", async () => {
-    const messages: Message[] = [userMsg("Hello")];
-    const { messages: result } = await applyRuntimeInjections(messages, {
+    registerFallbackConversation({
       workspaceTopLevelContext: sampleContext,
-      activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
+      workspaceTopLevelDirty: false,
+      currentActiveSurfaceId: "sf_1",
+      surfaceState: makeSurfaceState("sf_1", { html: "<div>test</div>" }),
     });
+    const messages: Message[] = [userMsg("Hello")];
+    const { messages: result } = await applyRuntimeInjections(messages, {});
 
     expect(result[0].content).toHaveLength(3);
     expect((result[0].content[0] as { text: string }).text).toBe(sampleContext);

package/src/__tests__/conversation-skill-tools.test.ts

@@ -92,12 +92,13 @@ mock.module("../skills/tool-manifest.js", () => ({
 }));
 
 mock.module("../tools/skills/skill-tool-factory.js", () => ({
+  // Mirrors the real factory: no skillId in/out — ownership is recorded by
+  // the registry at `registerSkillTools(skillId, tools)` time.
   createSkillToolsFromManifest: (
     entries: SkillToolManifest["tools"],
-    skillId: string,
     _skillDir: string,
-    versionHash: string,
-    bundled?: boolean,
+    _versionHash: string,
+    _bundled?: boolean,
   ): Tool[] => {
     return entries.map((entry) => ({
       name: entry.name,
@@ -105,10 +106,6 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
       category: entry.category,
       defaultRiskLevel: RiskLevel.Medium,
       executionTarget: "sandbox" as const,
-      origin: "skill" as const,
-      ownerSkillId: skillId,
-      ownerSkillVersionHash: versionHash,
-      ownerSkillBundled: bundled ?? undefined,
       input_schema: entry.input_schema as object,
       execute: async () => ({ content: "", isError: false }),
     }));
@@ -116,18 +113,14 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
 }));
 
 mock.module("../tools/registry.js", () => ({
-  registerSkillTools: (tools: Tool[]) => {
-    const skillIds = new Set<string>();
-    for (const tool of tools) {
-      const skillId = tool.ownerSkillId!;
-      skillIds.add(skillId);
-      const existing = mockRegisteredTools.get(skillId) ?? [];
-      existing.push(tool);
-      mockRegisteredTools.set(skillId, existing);
-    }
-    for (const id of skillIds) {
-      mockSkillRefCount.set(id, (mockSkillRefCount.get(id) ?? 0) + 1);
-    }
+  // Matches the new signature: `registerSkillTools(skillId, tools)`. The
+  // skillId comes from the caller (conversation-skill-tools) and is the
+  // sole source of truth for ownership.
+  registerSkillTools: (skillId: string, tools: Tool[]) => {
+    const existing = mockRegisteredTools.get(skillId) ?? [];
+    existing.push(...tools);
+    mockRegisteredTools.set(skillId, existing);
+    mockSkillRefCount.set(skillId, (mockSkillRefCount.get(skillId) ?? 0) + 1);
     return tools;
   },
   unregisterSkillTools: (skillId: string) => {
@@ -151,6 +144,22 @@ mock.module("../tools/registry.js", () => ({
     }
     return found;
   },
+  // Mirrors the registry's `ownersByName` accessor: the mock derives the
+  // owning skillId from `mockRegisteredTools` (which is keyed by skillId)
+  // and reports it back as the `OwnerInfo` shape production callers expect.
+  getToolOwner: (
+    name: string,
+  ): { kind: "skill" | "plugin" | "mcp"; id: string } | undefined => {
+    let ownerSkillId: string | undefined;
+    for (const [skillId, tools] of mockRegisteredTools.entries()) {
+      for (const tool of tools) {
+        if (tool.name === name) ownerSkillId = skillId;
+      }
+    }
+    return ownerSkillId === undefined
+      ? undefined
+      : { kind: "skill", id: ownerSkillId };
+  },
   getSkillToolNames: () => {
     const names: string[] = [];
     for (const tools of mockRegisteredTools.values()) {
@@ -1730,11 +1739,11 @@ describe("bundled skill: app-builder", () => {
     expect(tools).toBeDefined();
     expect(tools!.length).toBe(4);
 
-    // All tools should have skill origin metadata
-    for (const tool of tools!) {
-      expect(tool.origin).toBe("skill");
-      expect(tool.ownerSkillId).toBe("app-builder");
-    }
+    // Ownership is asserted by the fact that
+    // `mockRegisteredTools.get("app-builder")` returned the tools — i.e. the
+    // mock `registerSkillTools(skillId, tools)` was called with skillId
+    // "app-builder", which is what the registry would record in production.
+    // The Tool object itself no longer carries a kind/origin field.
   });
 });
 
@@ -2229,7 +2238,7 @@ describe("hash change re-prompt regressions (PR 35)", () => {
     expect(sessionState.get("oncall")).toBe("v2:oncall-edited");
   });
 
-  test("registered tools carry updated ownerSkillId after hash change re-registration", () => {
+  test("registered tools carry updated owner after hash change re-registration", () => {
     mockCatalog = [makeSkill("deploy")];
     mockManifests = { deploy: makeManifest(["deploy_run"]) };
     mockVersionHashes = { deploy: "v1:pre-edit" };
@@ -2238,12 +2247,14 @@ describe("hash change re-prompt regressions (PR 35)", () => {
       ...skillLoadMessages('<loaded_skill id="deploy" />'),
     ];
 
-    // Turn 1
+    // Turn 1: ownership is asserted by the mock registry's keying — the
+    // tools landing under skillId "deploy" in `mockRegisteredTools` means
+    // `registerSkillTools("deploy", tools)` was called, which is the only
+    // path that records ownership in the real registry.
     projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
     const toolsV1 = mockRegisteredTools.get("deploy");
     expect(toolsV1).toBeDefined();
     expect(toolsV1!.length).toBe(1);
-    expect(toolsV1![0].ownerSkillId).toBe("deploy");
 
     // Edit
     mockVersionHashes = { deploy: "v2:post-edit" };
@@ -2253,121 +2264,6 @@ describe("hash change re-prompt regressions (PR 35)", () => {
     const toolsV2 = mockRegisteredTools.get("deploy");
     expect(toolsV2).toBeDefined();
     expect(toolsV2!.length).toBeGreaterThanOrEqual(1);
-    expect(toolsV2![0].ownerSkillId).toBe("deploy");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Version hash plumbing regression tests
-// Verify that createSkillToolsFromManifest receives the computed hash and
-// that projected tools carry ownerSkillVersionHash, which downstream
-// components (executor.ts) use to build policy context.
-// ---------------------------------------------------------------------------
-
-describe("version hash plumbing to projected tools", () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test("projected tools carry ownerSkillVersionHash matching the computed hash", () => {
-    mockCatalog = [makeSkill("deploy")];
-    mockManifests = { deploy: makeManifest(["deploy_run", "deploy_status"]) };
-    mockVersionHashes = { deploy: "v1:secure-hash-abc" };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    const tools = mockRegisteredTools.get("deploy");
-    expect(tools).toBeDefined();
-    expect(tools!.length).toBe(2);
-
-    // Every tool created for this skill must carry the version hash
-    for (const tool of tools!) {
-      expect(tool.ownerSkillVersionHash).toBe("v1:secure-hash-abc");
-    }
-  });
-
-  test("after hash change re-registration, new tools carry the updated hash", () => {
-    mockCatalog = [makeSkill("deploy")];
-    mockManifests = { deploy: makeManifest(["deploy_run"]) };
-    mockVersionHashes = { deploy: "v1:hash-before" };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    // Turn 1: register with original hash
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    const toolsV1 = mockRegisteredTools.get("deploy");
-    expect(toolsV1).toBeDefined();
-    expect(toolsV1![0].ownerSkillVersionHash).toBe("v1:hash-before");
-
-    // Simulate file edit — hash changes
-    mockVersionHashes = { deploy: "v2:hash-after" };
-
-    // Turn 2: re-registration with new hash
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    const toolsV2 = mockRegisteredTools.get("deploy");
-    expect(toolsV2).toBeDefined();
-
-    // The most recently registered tool should carry the new hash
-    const lastTool = toolsV2![toolsV2!.length - 1];
-    expect(lastTool.ownerSkillVersionHash).toBe("v2:hash-after");
-  });
-
-  test("tools for multiple co-active skills each carry their own version hash", () => {
-    mockCatalog = [makeSkill("deploy"), makeSkill("oncall")];
-    mockManifests = {
-      deploy: makeManifest(["deploy_run"]),
-      oncall: makeManifest(["oncall_page"]),
-    };
-    mockVersionHashes = {
-      deploy: "v1:deploy-hash-123",
-      oncall: "v1:oncall-hash-456",
-    };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    const deployTools = mockRegisteredTools.get("deploy");
-    expect(deployTools).toBeDefined();
-    expect(deployTools![0].ownerSkillVersionHash).toBe("v1:deploy-hash-123");
-
-    const oncallTools = mockRegisteredTools.get("oncall");
-    expect(oncallTools).toBeDefined();
-    expect(oncallTools![0].ownerSkillVersionHash).toBe("v1:oncall-hash-456");
-  });
-
-  test("default hash is used and plumbed when no explicit hash override is set", () => {
-    mockCatalog = [makeSkill("deploy")];
-    mockManifests = { deploy: makeManifest(["deploy_run"]) };
-    // No mockVersionHashes override — mock returns 'v1:default-hash-deploy'
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    const tools = mockRegisteredTools.get("deploy");
-    expect(tools).toBeDefined();
-    expect(tools![0].ownerSkillVersionHash).toBe("v1:default-hash-deploy");
   });
 });
 

package/src/__tests__/conversation-slash-commands.test.ts

@@ -140,53 +140,19 @@ describe("resolveSlash command contract", () => {
   });
 });
 
-describe("resolveSlash /compact target override", () => {
-  test("plain /compact returns no override", async () => {
+describe("resolveSlash /compact", () => {
+  test("plain /compact resolves to kind=compact", async () => {
     const result = await resolveSlash("/compact");
     expect(result).toEqual({ kind: "compact" });
   });
 
-  test("/compact <integer> sets explicit token target", async () => {
+  test("/compact rejects arguments with usage hint", async () => {
     const result = await resolveSlash("/compact 30000");
-    expect(result).toEqual({
-      kind: "compact",
-      targetInputTokensOverride: 30000,
-    });
-  });
-
-  test("/compact <n>k expands to thousands", async () => {
-    const result = await resolveSlash("/compact 30k");
-    expect(result).toEqual({
-      kind: "compact",
-      targetInputTokensOverride: 30_000,
-    });
-  });
-
-  test("/compact <n>m expands to millions", async () => {
-    const result = await resolveSlash("/compact 1.5M");
-    expect(result).toEqual({
-      kind: "compact",
-      targetInputTokensOverride: 1_500_000,
-    });
-  });
-
-  test("/compact rejects malformed args with usage hint", async () => {
-    const result = await resolveSlash("/compact bogus");
     expect(result.kind).toBe("unknown");
     if (result.kind !== "unknown") throw new Error("expected unknown");
-    expect(result.message).toContain("`bogus`");
+    expect(result.message).toContain("does not take arguments");
     expect(result.message).toContain("/compact");
   });
-
-  test("/compact rejects zero", async () => {
-    const result = await resolveSlash("/compact 0");
-    expect(result.kind).toBe("unknown");
-  });
-
-  test("/compact rejects negative numbers", async () => {
-    const result = await resolveSlash("/compact -50");
-    expect(result.kind).toBe("unknown");
-  });
 });
 
 describe("resolveSlash /clean", () => {
@@ -227,9 +193,9 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     { input: "/status", kind: "unknown" },
     { input: "/commands", kind: "unknown" },
     { input: "/compact", kind: "compact" },
-    { input: "/compact 30000", kind: "compact" },
-    { input: "/compact 30k", kind: "compact" },
-    { input: "/compact 1.5M", kind: "compact" },
+    { input: "/compact 30000", kind: "unknown" },
+    { input: "/compact 30k", kind: "unknown" },
+    { input: "/compact 1.5M", kind: "unknown" },
     { input: "/compact bogus", kind: "unknown" },
     { input: "/clean", kind: "clean" },
     { input: "  /clean  ", kind: "clean" },
@@ -239,7 +205,7 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     { input: "/opus", kind: "unknown" },
     { input: "hello", kind: "passthrough" },
     { input: "  /compact  ", kind: "compact" },
-    { input: "  /compact 50k  ", kind: "compact" },
+    { input: "  /compact 50k  ", kind: "unknown" },
     { input: "/models foo", kind: "passthrough" },
   ];