@vellumai/assistant 0.4.42 → 0.4.44

package/src/__tests__/skill-projection-feature-flag.test.ts

@@ -20,9 +20,9 @@ let mockRegisteredTools: Map<string, Tool[]> = new Map();
 let mockUnregisteredSkillIds: string[] = [];
 let mockSkillRefCount: Map<string, number> = new Map();
 
-let currentConfig: Record<string, unknown> = { featureFlags: {} };
+let currentConfig: Record<string, unknown> = {};
 const DECLARED_SKILL_ID = "hatch-new-assistant";
-const DECLARED_LEGACY_KEY = "skills.hatch-new-assistant.enabled";
+const DECLARED_FLAG_KEY = "feature_flags.hatch-new-assistant.enabled";
 
 // ---------------------------------------------------------------------------
 // Mocks
@@ -50,10 +50,6 @@ mock.module("../config/assistant-feature-flags.js", () => ({
       }
     ).assistantFeatureFlagValues;
     if (vals && typeof vals[key] === "boolean") return vals[key];
-    // Check legacy featureFlags too
-    const legacy = (config as { featureFlags?: Record<string, boolean> })
-      .featureFlags;
-    if (legacy && typeof legacy[key] === "boolean") return legacy[key];
     return true; // default enabled
   },
   loadDefaultsRegistry: () => ({}),
@@ -62,7 +58,7 @@ mock.module("../config/assistant-feature-flags.js", () => ({
 }));
 
 mock.module("../config/skill-state.js", () => ({
-  skillFlagKey: (skillId: string) => `skills.${skillId}.enabled`,
+  skillFlagKey: (skillId: string) => `feature_flags.${skillId}.enabled`,
 }));
 
 mock.module("../skills/active-skill-tools.js", () => {
@@ -99,8 +95,6 @@ mock.module("../skills/active-skill-tools.js", () => {
 
   return {
     deriveActiveSkills: (messages: Message[]) => parseMarkers(messages),
-    deriveActiveSkillIds: (messages: Message[]) =>
-      parseMarkers(messages).map((e) => e.id),
   };
 });
 
@@ -231,6 +225,7 @@ function makeSkill(id: string): SkillSummary {
   return {
     id,
     name: id,
+    displayName: id,
     description: `Skill ${id}`,
     directoryPath: `/skills/${id}`,
     skillFilePath: `/skills/${id}/SKILL.md`,
@@ -293,7 +288,7 @@ describe("projectSkillTools feature flag enforcement", () => {
     mockRegisteredTools = new Map();
     mockUnregisteredSkillIds = [];
     mockSkillRefCount = new Map();
-    currentConfig = { featureFlags: {} };
+    currentConfig = {};
     resetSkillToolProjection();
   });
 
@@ -308,7 +303,9 @@ describe("projectSkillTools feature flag enforcement", () => {
     const prevActive = new Map<string, string>();
 
     // Feature flag is OFF
-    currentConfig = { featureFlags: { [DECLARED_LEGACY_KEY]: false } };
+    currentConfig = {
+      assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: false },
+    };
 
     const result = projectSkillTools(history, {
       previouslyActiveSkillIds: prevActive,
@@ -329,7 +326,9 @@ describe("projectSkillTools feature flag enforcement", () => {
     const prevActive = new Map<string, string>();
 
     // Feature flag is ON
-    currentConfig = { featureFlags: { [DECLARED_LEGACY_KEY]: true } };
+    currentConfig = {
+      assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: true },
+    };
 
     const result = projectSkillTools(history, {
       previouslyActiveSkillIds: prevActive,
@@ -347,8 +346,8 @@ describe("projectSkillTools feature flag enforcement", () => {
     const history = buildHistoryWithMarker(DECLARED_SKILL_ID);
     const prevActive = new Map<string, string>();
 
-    // featureFlags is empty — should default to enabled
-    currentConfig = { featureFlags: {} };
+    // No overrides — should default to enabled
+    currentConfig = {};
 
     const result = projectSkillTools(history, {
       previouslyActiveSkillIds: prevActive,
@@ -414,7 +413,7 @@ describe("projectSkillTools feature flag enforcement", () => {
 
     // Declared skill is OFF, twitter is undeclared with no persisted override so remains ON.
     currentConfig = {
-      featureFlags: { [DECLARED_LEGACY_KEY]: false },
+      assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: false },
     };
 
     const result = projectSkillTools(history, {

package/src/__tests__/skills-uninstall.test.ts

@@ -0,0 +1,131 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { uninstallSkillLocally } from "../cli/commands/skills.js";
+
+let tempDir: string;
+let originalBaseDataDir: string | undefined;
+
+function getSkillsDir(): string {
+  return join(tempDir, ".vellum", "workspace", "skills");
+}
+
+function getSkillsIndexPath(): string {
+  return join(getSkillsDir(), "SKILLS.md");
+}
+
+function installFakeSkill(skillId: string): void {
+  const skillDir = join(getSkillsDir(), skillId);
+  mkdirSync(skillDir, { recursive: true });
+  writeFileSync(join(skillDir, "SKILL.md"), `# ${skillId}\nA test skill.\n`);
+}
+
+function writeSkillsIndex(content: string): void {
+  mkdirSync(getSkillsDir(), { recursive: true });
+  writeFileSync(getSkillsIndexPath(), content);
+}
+
+beforeEach(() => {
+  tempDir = join(
+    tmpdir(),
+    `skills-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(join(tempDir, ".vellum", "workspace", "skills"), {
+    recursive: true,
+  });
+  originalBaseDataDir = process.env.BASE_DATA_DIR;
+  process.env.BASE_DATA_DIR = tempDir;
+});
+
+afterEach(() => {
+  process.env.BASE_DATA_DIR = originalBaseDataDir;
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe("assistant skills uninstall", () => {
+  test("removes skill directory and SKILLS.md entry", () => {
+    /**
+     * Tests the happy path for uninstalling a skill.
+     */
+
+    // GIVEN a skill is installed locally
+    installFakeSkill("weather");
+    writeSkillsIndex("- weather\n- google-oauth-setup\n");
+
+    // WHEN we uninstall the skill
+    uninstallSkillLocally("weather");
+
+    // THEN the skill directory should be removed
+    expect(existsSync(join(getSkillsDir(), "weather"))).toBe(false);
+
+    // AND the SKILLS.md entry should be removed
+    const index = readFileSync(getSkillsIndexPath(), "utf-8");
+    expect(index).not.toContain("weather");
+
+    // AND other skills should remain in the index
+    expect(index).toContain("google-oauth-setup");
+  });
+
+  test("errors when skill is not installed", () => {
+    /**
+     * Tests that uninstalling a non-existent skill throws an error.
+     */
+
+    // GIVEN no skills are installed
+    // WHEN we try to uninstall a nonexistent skill
+    // THEN it should throw an error
+    expect(() => uninstallSkillLocally("nonexistent")).toThrow(
+      'Skill "nonexistent" is not installed.',
+    );
+  });
+
+  test("works when SKILLS.md does not exist", () => {
+    /**
+     * Tests that uninstall works even if the SKILLS.md index file is missing.
+     */
+
+    // GIVEN a skill directory exists but no SKILLS.md
+    installFakeSkill("weather");
+
+    // WHEN we uninstall the skill
+    uninstallSkillLocally("weather");
+
+    // THEN the skill directory should be removed
+    expect(existsSync(join(getSkillsDir(), "weather"))).toBe(false);
+
+    // AND no SKILLS.md should have been created
+    expect(existsSync(getSkillsIndexPath())).toBe(false);
+  });
+
+  test("removes skill with nested files", () => {
+    /**
+     * Tests that uninstall recursively removes skills with nested directories.
+     */
+
+    // GIVEN a skill with nested files is installed
+    const skillDir = join(getSkillsDir(), "weather");
+    mkdirSync(join(skillDir, "scripts", "lib"), { recursive: true });
+    writeFileSync(join(skillDir, "SKILL.md"), "# weather\n");
+    writeFileSync(join(skillDir, "scripts", "fetch.sh"), "#!/bin/bash\n");
+    writeFileSync(join(skillDir, "scripts", "lib", "utils.sh"), "# utils\n");
+    writeSkillsIndex("- weather\n");
+
+    // WHEN we uninstall the skill
+    uninstallSkillLocally("weather");
+
+    // THEN the entire skill directory tree should be removed
+    expect(existsSync(skillDir)).toBe(false);
+
+    // AND the SKILLS.md entry should be removed
+    const index = readFileSync(getSkillsIndexPath(), "utf-8");
+    expect(index).not.toContain("weather");
+  });
+});

package/src/__tests__/skills.test.ts

@@ -18,7 +18,7 @@ mock.module("../util/platform.js", () => ({
   ...realPlatform,
   getRootDir: () => TEST_DIR,
   getDataDir: () => TEST_DIR,
-  getIpcBlobDir: () => join(TEST_DIR, "ipc-blobs"),
+
   getSandboxRootDir: () => join(TEST_DIR, "sandbox"),
   getSandboxWorkingDir: () => TEST_DIR,
   getInterfacesDir: () => join(TEST_DIR, "interfaces"),
@@ -39,11 +39,7 @@ mock.module("../util/platform.js", () => ({
   getHooksDir: () => join(TEST_DIR, "hooks"),
   getWorkspaceDir: () => TEST_DIR,
   getWorkspacePromptPath: (file: string) => join(TEST_DIR, file),
-  migrateToDataLayout: () => {},
-  migrateToWorkspaceLayout: () => {},
-  migratePath: () => {},
   readSessionToken: () => null,
-  removeSocketFile: () => {},
   normalizeAssistantId: (id: string) => id,
   readLockfile: () => null,
   writeLockfile: () => {},
@@ -471,9 +467,13 @@ describe("includes frontmatter parsing", () => {
   function writeSkillWithIncludes(skillId: string, includes: string): void {
     const skillDir = join(TEST_DIR, "skills", skillId);
     mkdirSync(skillDir, { recursive: true });
+    // includes lives inside metadata.vellum, matching buildSkillMarkdown output.
+    // The raw includes string is interpolated directly so tests can pass both
+    // valid and intentionally malformed values.
+    const metadata = `{"vellum":{"includes":${includes}}}`;
     writeFileSync(
       join(skillDir, "SKILL.md"),
-      `---\nname: "${skillId}"\ndescription: "test"\nincludes: ${includes}\n---\n\nBody.\n`,
+      `---\nname: "${skillId}"\ndescription: "test"\nmetadata: ${metadata}\n---\n\nBody.\n`,
     );
   }
 
@@ -566,7 +566,8 @@ describe("bundled browser skill", () => {
     const catalog = loadSkillCatalog();
     const browserSkill = catalog.find((s) => s.id === "browser");
     expect(browserSkill).toBeDefined();
-    expect(browserSkill!.name).toBe("Browser");
+    expect(browserSkill!.name).toBe("browser");
+    expect(browserSkill!.displayName).toBe("Browser");
     expect(browserSkill!.bundled).toBe(true);
   });
 
@@ -635,7 +636,8 @@ describe("bundled public-ingress skill", () => {
     const catalog = loadSkillCatalog();
     const skill = catalog.find((s) => s.id === "public-ingress");
     expect(skill).toBeDefined();
-    expect(skill!.name).toBe("Public Ingress");
+    expect(skill!.name).toBe("public-ingress");
+    expect(skill!.displayName).toBe("Public Ingress");
     expect(skill!.bundled).toBe(true);
   });
 
@@ -682,13 +684,26 @@ describe("ingress-dependent setup skills declare public-ingress", () => {
       const sep = line.indexOf(":");
       if (sep === -1) continue;
       const key = line.slice(0, sep).trim();
-      if (key !== "includes") continue;
-      const val = line.slice(sep + 1).trim();
-      try {
-        const parsed = JSON.parse(val);
-        if (Array.isArray(parsed)) return parsed as string[];
-      } catch {
-        /* ignore */
+      // Check top-level includes (legacy format)
+      if (key === "includes") {
+        const val = line.slice(sep + 1).trim();
+        try {
+          const parsed = JSON.parse(val);
+          if (Array.isArray(parsed)) return parsed as string[];
+        } catch {
+          /* ignore */
+        }
+      }
+      // Check metadata.vellum.includes (spec-compliant format)
+      if (key === "metadata") {
+        const val = line.slice(sep + 1).trim();
+        try {
+          const parsed = JSON.parse(val);
+          const includes = parsed?.vellum?.includes;
+          if (Array.isArray(includes)) return includes as string[];
+        } catch {
+          /* ignore */
+        }
       }
     }
     return undefined;
@@ -731,7 +746,8 @@ describe("bundled computer-use skill", () => {
     const catalog = loadSkillCatalog();
     const cuSkill = catalog.find((s) => s.id === "computer-use");
     expect(cuSkill).toBeDefined();
-    expect(cuSkill!.name).toBe("Computer Use");
+    expect(cuSkill!.name).toBe("computer-use");
+    expect(cuSkill!.displayName).toBe("Computer Use");
     expect(cuSkill!.bundled).toBe(true);
   });
 

package/src/__tests__/slack-block-formatting.test.ts

@@ -93,7 +93,7 @@ describe("isSlackCallbackUrl", () => {
   test("returns false for managed outbound URLs", () => {
     expect(
       isSlackCallbackUrl(
-        "http://localhost:7830/v1/internal/managed-gateway/outbound-send/?route_id=r1&assistant_id=a1&source_channel=sms",
+        "http://localhost:7830/v1/internal/managed-gateway/outbound-send/?route_id=r1&assistant_id=a1&source_channel=phone",
       ),
     ).toBe(false);
   });

package/src/__tests__/slack-channel-config.test.ts

@@ -5,21 +5,59 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 const testDir = mkdtempSync(join(tmpdir(), "slack-channel-cfg-test-"));
 
+// In-memory config store for tests
+let configStore: Record<string, unknown> = {};
+
+function setNestedValue(
+  obj: Record<string, unknown>,
+  path: string,
+  value: unknown,
+): void {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (current[key] == null || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key] as Record<string, unknown>;
+  }
+  current[keys[keys.length - 1]] = value;
+}
+
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
+    slack: {
+      deliverAuthBypass: false,
+      teamId:
+        ((configStore.slack as Record<string, unknown>)?.teamId as string) ??
+        "",
+      teamName:
+        ((configStore.slack as Record<string, unknown>)?.teamName as string) ??
+        "",
+      botUserId:
+        ((configStore.slack as Record<string, unknown>)?.botUserId as string) ??
+        "",
+      botUsername:
+        ((configStore.slack as Record<string, unknown>)
+          ?.botUsername as string) ?? "",
+    },
   }),
   loadConfig: () => ({}),
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
+  loadRawConfig: () => structuredClone(configStore),
+  saveRawConfig: (raw: Record<string, unknown>) => {
+    configStore = structuredClone(raw);
+  },
   saveConfig: () => {},
   invalidateConfigCache: () => {},
+  setNestedValue,
 }));
 
 mock.module("../util/platform.js", () => ({
   getRootDir: () => testDir,
   getDataDir: () => testDir,
-  getIpcBlobDir: () => join(testDir, "ipc-blobs"),
+
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
@@ -149,6 +187,7 @@ describe("Slack channel config handler", () => {
   beforeEach(() => {
     secureKeyStore = {};
     credentialMetadataStore = [];
+    configStore = {};
     globalThis.fetch = originalFetch;
   });
 
@@ -171,18 +210,16 @@ describe("Slack channel config handler", () => {
     expect(result.connected).toBe(true);
   });
 
-  test("GET returns metadata when available", () => {
+  test("GET returns metadata from config when available", () => {
     secureKeyStore["credential:slack_channel:bot_token"] = "xoxb-test";
-    credentialMetadataStore.push({
-      service: "slack_channel",
-      field: "bot_token",
-      accountInfo: JSON.stringify({
+    configStore = {
+      slack: {
         teamId: "T123",
         teamName: "TestTeam",
         botUserId: "U_BOT",
         botUsername: "testbot",
-      }),
-    });
+      },
+    };
 
     const result = getSlackChannelConfig();
     expect(result.teamId).toBe("T123");
@@ -209,7 +246,7 @@ describe("Slack channel config handler", () => {
     );
   });
 
-  test("POST validates bot token via Slack auth.test API", async () => {
+  test("POST validates bot token via Slack auth.test API and writes config", async () => {
     globalThis.fetch = (async () => {
       return new Response(
         JSON.stringify({
@@ -231,6 +268,13 @@ describe("Slack channel config handler", () => {
     expect(result.hasBotToken).toBe(true);
     expect(result.teamId).toBe("T_TEAM");
     expect(result.teamName).toBe("MyTeam");
+
+    // Assert metadata was written to config (not credential metadata)
+    const slack = configStore.slack as Record<string, unknown>;
+    expect(slack.teamId).toBe("T_TEAM");
+    expect(slack.teamName).toBe("MyTeam");
+    expect(slack.botUserId).toBe("U_BOT");
+    expect(slack.botUsername).toBe("mybot");
   });
 
   test("POST returns error when Slack auth.test rejects bot token", async () => {
@@ -252,7 +296,7 @@ describe("Slack channel config handler", () => {
     expect(result.error).toContain("invalid_auth");
   });
 
-  test("DELETE clears credentials", async () => {
+  test("DELETE clears credentials and config", async () => {
     secureKeyStore["credential:slack_channel:bot_token"] = "xoxb-test";
     secureKeyStore["credential:slack_channel:app_token"] = "xapp-test";
     credentialMetadataStore.push({
@@ -263,6 +307,14 @@ describe("Slack channel config handler", () => {
       service: "slack_channel",
       field: "app_token",
     });
+    configStore = {
+      slack: {
+        teamId: "T123",
+        teamName: "TestTeam",
+        botUserId: "U_BOT",
+        botUsername: "testbot",
+      },
+    };
 
     const result = await clearSlackChannelConfig();
     expect(result.success).toBe(true);
@@ -277,5 +329,12 @@ describe("Slack channel config handler", () => {
       secureKeyStore["credential:slack_channel:app_token"],
     ).toBeUndefined();
     expect(credentialMetadataStore).toHaveLength(0);
+
+    // Assert config values were cleared
+    const slack = configStore.slack as Record<string, unknown>;
+    expect(slack.teamId).toBe("");
+    expect(slack.teamName).toBe("");
+    expect(slack.botUserId).toBe("");
+    expect(slack.botUsername).toBe("");
   });
 });

package/src/__tests__/slack-inbound-verification.test.ts

@@ -79,7 +79,7 @@ mock.module("../runtime/gateway-client.js", () => ({
 
 import { createGuardianBinding } from "../contacts/contacts-write.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
-import { findActiveSession } from "../runtime/channel-guardian-service.js";
+import { findActiveSession } from "../runtime/channel-verification-service.js";
 import { handleChannelInbound } from "../runtime/routes/channel-routes.js";
 
 initializeDb();
@@ -102,7 +102,7 @@ const TEST_BEARER_TOKEN = "test-token";
 function resetState(): void {
   const db = getDb();
   db.run("DELETE FROM channel_guardian_approval_requests");
-  db.run("DELETE FROM channel_guardian_verification_challenges");
+  db.run("DELETE FROM channel_verification_sessions");
   db.run("DELETE FROM channel_guardian_rate_limits");
   db.run("DELETE FROM channel_inbound_events");
   db.run("DELETE FROM conversations");
@@ -293,14 +293,14 @@ describe("Slack inbound trusted contact verification", () => {
     // sessions, extract it from the session's challengeHash by consuming
     // the challenge directly.
     // The session was created with createOutboundSession which generates
-    // a 6-digit code. We can validate by calling validateAndConsumeChallenge
+    // a 6-digit code. We can validate by calling validateAndConsumeVerification
     // with the correct secret. Since the mock captures the DM text, we
     // can extract the code indirectly. But for testing, we just verify
-    // the session properties and that validateAndConsumeChallenge works
+    // the session properties and that validateAndConsumeVerification works
     // with the correct identity.
 
     // The actual secret was sent in the DM. For this test, let's use the
-    // session directly via the channel-guardian-service to verify the
+    // session directly via the channel-verification-service to verify the
     // consume path works.
     // The DM text contains the verification code implicitly (it's in the
     // template message). Since we need to test the full round-trip, let's
@@ -313,7 +313,7 @@ describe("Slack inbound trusted contact verification", () => {
 
     // Create a verification session manually to test the consume path
     const { createOutboundSession } =
-      await import("../runtime/channel-guardian-service.js");
+      await import("../runtime/channel-verification-service.js");
 
     const outboundSession = createOutboundSession({
       channel: "slack",
@@ -338,6 +338,6 @@ describe("Slack inbound trusted contact verification", () => {
     const verifyJson = (await verifyResp.json()) as Record<string, unknown>;
 
     expect(verifyJson.accepted).toBe(true);
-    expect(verifyJson.guardianVerification).toBe("verified");
+    expect(verifyJson.verificationOutcome).toBe("verified");
   });
 });

package/src/__tests__/slack-share-routes.test.ts

@@ -64,7 +64,7 @@ mock.module("../util/logger.js", () => ({
 // ---------------------------------------------------------------------------
 
 const { handleListSlackChannels, handleShareToSlackChannel } =
-  await import("../runtime/routes/slack-share-routes.js");
+  await import("../runtime/routes/integrations/slack/share.js");
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/__tests__/slack-skill.test.ts

@@ -125,11 +125,11 @@ describe("slack skill SKILL.md", () => {
   );
 
   test("has correct frontmatter name", () => {
-    expect(skillMd).toContain('name: "Slack"');
+    expect(skillMd).toContain("name: slack");
   });
 
   test("is user-invocable", () => {
-    expect(skillMd).toContain("user-invocable: true");
+    expect(skillMd).toContain('"user-invocable":true');
   });
 
   test("mentions privacy rules", () => {

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

@@ -11,6 +11,7 @@ function makeSkill(
   return {
     id,
     name: overrides?.name ?? id,
+    displayName: overrides?.displayName ?? overrides?.name ?? id,
     description: `Description for ${id}`,
     directoryPath: `/skills/${id}`,
     skillFilePath: `/skills/${id}/SKILL.md`,

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

@@ -16,6 +16,7 @@ function makeSkill(
   return {
     id,
     name: overrides?.name ?? id,
+    displayName: overrides?.displayName ?? overrides?.name ?? id,
     description: `Description for ${id}`,
     directoryPath: `/skills/${id}`,
     skillFilePath: `/skills/${id}/SKILL.md`,

package/src/__tests__/starter-task-flow.test.ts

@@ -1,33 +1,23 @@
 import { describe, expect, mock, test } from "bun:test";
 
-import type { ServerMessage, SurfaceType } from "../daemon/ipc-protocol.js";
+import type { ServerMessage, SurfaceType } from "../daemon/message-protocol.js";
 
 mock.module("../memory/app-store.js", () => ({
   getApp: (id: string) => {
-    if (id !== "home-base-app") return null;
+    if (id !== "test-app") return null;
     return {
       id,
-      name: "Home Base",
-      htmlDefinition:
-        '<main id="home-base-root" data-vellum-home-base="v1"></main>',
+      name: "Test App",
+      description: "A test app",
+      htmlDefinition: "<main>Test App</main>",
     };
   },
+  getAppPreview: () => null,
   updateApp: () => {
     throw new Error("updateApp should not be called in this test");
   },
 }));
 
-mock.module("../home-base/prebuilt/seed.js", () => ({
-  findSeededHomeBaseApp: () => ({ id: "home-base-app" }),
-  getPrebuiltHomeBasePreview: () => ({
-    title: "Home Base",
-    subtitle: "Dashboard",
-    description: "Preview",
-    icon: "🏠",
-    metrics: [{ label: "Starter tasks", value: "3" }],
-  }),
-}));
-
 import {
   createSurfaceMutex,
   handleSurfaceAction,
@@ -70,12 +60,12 @@ describe("starter task surface actions", () => {
     ctx.pendingSurfaceActions.set("surf-1", { surfaceType: "dynamic_page" });
 
     handleSurfaceAction(ctx, "surf-1", "relay_prompt", {
-      prompt: "Help me customize Home Base with a calmer palette.",
+      prompt: "Help me customize the app with a calmer palette.",
       task: "change_look_and_feel",
     });
 
     expect(forwarded).toEqual([
-      "Help me customize Home Base with a calmer palette.",
+      "Help me customize the app with a calmer palette.",
     ]);
     expect(ctx.pendingSurfaceActions.has("surf-1")).toBe(true);
   });
@@ -133,7 +123,7 @@ describe("starter task surface actions", () => {
     ctx.sendToClient = (msg) => sent.push(msg);
 
     const result = await surfaceProxyResolver(ctx, "app_open", {
-      app_id: "home-base-app",
+      app_id: "test-app",
     });
 
     expect(result.isError).toBe(false);
@@ -141,7 +131,7 @@ describe("starter task surface actions", () => {
       surfaceId: string;
       appId: string;
     };
-    expect(parsed.appId).toBe("home-base-app");
+    expect(parsed.appId).toBe("test-app");
     expect(ctx.pendingSurfaceActions.get(parsed.surfaceId)?.surfaceType).toBe(
       "dynamic_page",
     );

package/src/__tests__/subagent-manager-notify.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import type { ServerMessage } from "../daemon/ipc-contract.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
 import { SubagentManager } from "../subagent/manager.js";
 import type { SubagentState } from "../subagent/types.js";