Merge branch 'skills-unreachable-sources' into skills-shared-store

Author: ethanndickson

src/node/acp/agent.ts

@@ -1405,12 +1405,19 @@ export class MuxAgent implements Agent {
       advertisedSkills = cachedSkillsByName ? Array.from(cachedSkillsByName.values()) : [];
     }
 
+    await this.publishSessionCommands(sessionId, advertisedSkills);
+  }
+
+  private async publishSessionCommands(
+    sessionId: string,
+    skills: AgentSkillDescriptor[]
+  ): Promise<void> {
     try {
       await this.connection.sessionUpdate({
         sessionId,
         update: {
           sessionUpdate: "available_commands_update",
-          availableCommands: buildAcpAvailableCommands(advertisedSkills),
+          availableCommands: buildAcpAvailableCommands(skills),
         },
       });
     } catch (error) {
@@ -1428,10 +1435,11 @@ export class MuxAgent implements Agent {
       return cached;
     }
 
-    return this.cacheSessionSkills(
-      sessionId,
-      await this.server.client.agentSkills.list({ workspaceId })
-    );
+    const result = await this.server.client.agentSkills.list({ workspaceId });
+    // No cache means the client was last sent a partial list (or none), so its
+    // command picker is stale too: send it the list just read.
+    await this.publishSessionCommands(sessionId, result.skills);
+    return this.cacheSessionSkills(sessionId, result);
   }
 
   private cacheSessionSkills(

src/node/services/agentPlugins/composition.ts

@@ -10,6 +10,7 @@ import { discoverAgentDefinitions } from "@/node/services/agentDefinitions/agent
 import {
   discoverAgentSkills,
   getDefaultAgentSkillsRoots,
+  requireReachableSkills,
 } from "@/node/services/agentSkills/agentSkillsService";
 import { getErrorMessage } from "@/common/utils/errors";
 import { log } from "@/node/services/log";
@@ -182,10 +183,14 @@ export async function buildWorkspaceComposition(
         }
       : undefined;
 
-  const { skills: skillDescriptors } = await discoverAgentSkills(args.runtime, args.workspacePath, {
-    dedupeByName: false,
-    ...(checkoutSkillRoots ?? {}),
-  });
+  // Like the turn's skill index, the inspector must not report a composition
+  // that silently lost a project root to an unreachable host.
+  const skillDescriptors = requireReachableSkills(
+    await discoverAgentSkills(args.runtime, args.workspacePath, {
+      dedupeByName: false,
+      ...(checkoutSkillRoots ?? {}),
+    })
+  );
   const skills = markShadowed(
     skillDescriptors.map((skill) => ({
       name: skill.name,

tests/ipc/acp.promptCorrelation.test.ts

@@ -1,6 +1,7 @@
 import { AgentSideConnection, PROTOCOL_VERSION, ndJsonStream } from "@agentclientprotocol/sdk";
 import { STOP_UNRECORDED_MESSAGE } from "../../src/common/constants/workspace";
 import type { OnChatMode, WorkspaceChatMessage } from "../../src/common/orpc/types";
+import type { AgentSkillListResult } from "../../src/common/types/agentSkill";
 import { MuxAgent } from "../../src/node/acp/agent";
 import type { ORPCClient, ServerConnection } from "../../src/node/acp/serverConnection";
 
@@ -291,6 +292,7 @@ interface HarnessOptions {
   sendHeldInput?: (
     input: Record<string, unknown>
   ) => Promise<{ success: boolean; data?: unknown; error?: unknown }>;
+  listSkills?: () => Promise<AgentSkillListResult>;
   /** Custom output WritableStream for simulating stdout backpressure. */
   acpOutputStream?: WritableStream<Uint8Array>;
   agentOptions?: ConstructorParameters<typeof MuxAgent>[2];
@@ -338,7 +340,12 @@ function createHarness(options?: HarnessOptions): Harness {
       list: async () => [],
     },
     agentSkills: {
-      list: async () => ({ skills: [], invalidSkills: [], unavailableSources: [] }),
+      list: async () =>
+        (await options?.listSkills?.()) ?? {
+          skills: [],
+          invalidSkills: [],
+          unavailableSources: [],
+        },
       get: async () => {
         throw new Error("createHarness: get not implemented for this test");
       },
@@ -1753,6 +1760,51 @@ describe("ACP prompt stream correlation", () => {
   }, 15_000);
 });
 
+describe("ACP slash commands after a partial skill list", () => {
+  it("sends the client the complete list once a slash prompt reads it", async () => {
+    const partial: AgentSkillListResult = {
+      skills: [],
+      invalidSkills: [],
+      unavailableSources: [
+        { scope: "project", displayPath: "/remote/.xum/skills", message: "host unreachable" },
+      ],
+    };
+    const complete: AgentSkillListResult = {
+      skills: [{ name: "deploy", description: "Deploy the app", scope: "project" }],
+      invalidSkills: [],
+      unavailableSources: [],
+    };
+    let listCount = 0;
+    const harness = createHarness({
+      listSkills: async () => (listCount++ === 0 ? partial : complete),
+    });
+    const advertised = () =>
+      harness.sessionUpdates
+        .filter(({ update }) => update.sessionUpdate === "available_commands_update")
+        .map(({ update }) => (update.availableCommands as { name: string }[]).map((c) => c.name));
+
+    await initializeDefaultAgent(harness);
+    const { sessionId } = await createDefaultSession(harness);
+    await waitForCondition(() => advertised().length === 1);
+    expect(advertised()[0]).not.toContain("deploy");
+
+    const { promptPromise, promptCorrelationId } = await startPromptTurn(
+      harness,
+      sessionId,
+      "/deploy now"
+    );
+    harness.pushChatEvent(
+      streamStart(sessionId, "assistant-deploy", { acpPromptId: promptCorrelationId })
+    );
+    harness.pushChatEvent(streamEnd(sessionId, "assistant-deploy"));
+    await expect(promptPromise).resolves.toMatchObject({ stopReason: "end_turn" });
+
+    expect(advertised().at(-1)).toContain("deploy");
+    harness.closeConnection();
+    await harness.connectionClosed;
+  });
+});
+
 describe("ACP held inputs (#4944)", () => {
   const heldInputs = ["queued follow-up", "second queued"].map((displayText, index) => ({
     id: `held-${index + 1}`,