fix(vscode): list skills in the slash menu before a session exists

Skill resolution was reachable only through a live session, so a freshly opened
panel showed the built-in commands alone and skills appeared only after the
first message. Resolution now also runs at workspace scope, using the same
roots a session resolves, and the panel calls that when it has no session yet.
A live session is still preferred, since only it knows its MCP prompts.

Author: elkaix

apps/vscode/src/handlers/config.handler.ts

@@ -89,15 +89,20 @@ const getModels: Handler<void, ModelsConfig> = async (_, ctx) => {
 };
 
 /**
- * The skill catalog is session-scoped in the engine, so the list is empty until
- * a session exists. `bridge-handler` re-broadcasts the commands once one is
- * created, which is what fills the menu on a cold start.
+ * Skills are resolved from the workspace, not from a session, so a panel that
+ * has not sent a message yet still lists them. A live session is preferred when
+ * there is one: only it can report the prompts of its MCP connections.
  */
 export const getSlashCommands: Handler<void, SlashCommandInfo[]> = async (_, ctx) => {
   const session = ctx.getSession()?.session;
-  if (session === undefined) return SLASH_COMMANDS;
   try {
-    const { commands } = buildSkillSlashCommands(await session.listSkills());
+    const skills =
+      session !== undefined
+        ? await session.listSkills()
+        : ctx.workDir !== null
+          ? await ctx.harness.listWorkspaceSkills(ctx.workDir)
+          : [];
+    const { commands } = buildSkillSlashCommands(skills);
     return [...SLASH_COMMANDS, ...commands.map(toSlashCommandInfo)];
   } catch (error) {
     ctx.logError("Unable to list skills", error);

packages/agent-core/src/rpc/core-api.ts

@@ -387,6 +387,10 @@ export interface ListAgentProfilesPayload {
   readonly workDir: string;
 }
 
+export interface ListWorkspaceSkillsPayload {
+  readonly workDir: string;
+}
+
 export interface AgentProfileSummary {
   readonly name: string;
   readonly description?: string;
@@ -494,6 +498,7 @@ export interface CoreAPI extends SessionAPIWithId {
   getConfigDiagnostics: (payload: EmptyPayload) => ConfigDiagnostics;
   listOutputStyles: (payload: ListOutputStylesPayload) => OutputStyleCatalog;
   listAgentProfiles: (payload: ListAgentProfilesPayload) => AgentProfileCatalog;
+  listWorkspaceSkills: (payload: ListWorkspaceSkillsPayload) => readonly SkillSummary[];
   setPythinkerConfig: (payload: SetPythinkerConfigPayload) => PythinkerConfig;
   replacePythinkerConfig: (payload: ReplacePythinkerConfigPayload) => PythinkerConfig;
   removePythinkerProvider: (payload: RemovePythinkerProviderPayload) => PythinkerConfig;

packages/agent-core/src/rpc/core-impl.ts

@@ -35,6 +35,7 @@ import {
 import { FLAG_DEFINITIONS, FlagResolver, type ExperimentalFeatureState } from '../flags';
 import type { Logger } from '../logging/types';
 import { resolveSessionMcpConfig, mergeCallerMcpServers, type SessionMcpConfig } from '../mcp';
+import { listWorkspaceSkills } from '../skill/workspace';
 import {
   DEFAULT_AGENT_PROFILES,
   loadAgentProfilesFromDirectories,
@@ -92,6 +93,7 @@ import type {
   InstallPluginPayload,
   ListSessionsPayload,
   ListAgentProfilesPayload,
+  ListWorkspaceSkillsPayload,
   ListOutputStylesPayload,
   McpServerInfo,
   SkillActivationResult,
@@ -615,6 +617,19 @@ export class PythinkerCore implements PromisableMethods<CoreAPI> {
     return this.loadAgentProfileCatalog(requiredWorkDir('listAgentProfiles', workDir));
   }
 
+  // Resolves the same roots a session would, so a caller that has no session yet
+  // (a freshly opened editor panel) still sees the workspace's real skill list.
+  async listWorkspaceSkills({
+    workDir,
+  }: ListWorkspaceSkillsPayload): Promise<readonly SkillSummary[]> {
+    await this.pluginsReady;
+    this.assertPluginsLoaded();
+    return listWorkspaceSkills({
+      workDir: requiredWorkDir('listWorkspaceSkills', workDir),
+      ...this.resolveSessionSkillConfig(this.readConfigForWrite()),
+    });
+  }
+
   async setPythinkerConfig(input: SetPythinkerConfigPayload): Promise<PythinkerConfig> {
     const config = mergeConfigPatch(this.readConfigForWrite(), input);
     return this.writePythinkerConfig(config);

packages/agent-core/src/skill/index.ts

@@ -3,3 +3,4 @@ export * from './parser';
 export * from './registry';
 export * from './scanner';
 export * from './types';
+export * from './workspace';

packages/agent-core/src/skill/workspace.ts

@@ -0,0 +1,52 @@
+import { homedir } from 'node:os';
+
+import { registerBuiltinSkills } from './builtin';
+import { SessionSkillRegistry } from './registry';
+import { resolveSkillRoots } from './scanner';
+import { summarizeSkill, type SkillRoot, type SkillSummary } from './types';
+
+/**
+ * Field-for-field the resolution inputs a session uses, so a caller can pass the
+ * config it already assembles for sessions. Declared here rather than imported
+ * from the session layer, which depends on this one.
+ */
+export interface ListWorkspaceSkillsOptions {
+  /** Directory the skills are resolved for, as a session's cwd would be. */
+  readonly workDir: string;
+  readonly userHomeDir?: string;
+  /** Brand data dir (PYTHINKER_CODE_HOME); user brand skills live under `<brandHomeDir>/skills`. */
+  readonly brandHomeDir?: string;
+  readonly explicitDirs?: readonly string[];
+  readonly extraDirs?: readonly string[];
+  readonly pluginSkillRoots?: readonly SkillRoot[];
+  readonly mergeAllAvailableSkills?: boolean;
+  readonly builtinDir?: string;
+  readonly onWarning?: (message: string, cause?: unknown) => void;
+}
+
+/**
+ * The skill catalog a workspace resolves to, without opening a session.
+ *
+ * A session's own `listSkills` additionally reports the prompts of its MCP
+ * connections; those belong to a live session and are absent here.
+ */
+export async function listWorkspaceSkills(
+  options: ListWorkspaceSkillsOptions,
+): Promise<readonly SkillSummary[]> {
+  const registry = new SessionSkillRegistry({ onWarning: options.onWarning });
+  const roots = await resolveSkillRoots({
+    paths: {
+      userHomeDir: options.userHomeDir ?? homedir(),
+      brandHomeDir: options.brandHomeDir,
+      workDir: options.workDir,
+    },
+    explicitDirs: options.explicitDirs,
+    extraDirs: options.extraDirs,
+    pluginSkillRoots: options.pluginSkillRoots,
+    mergeAllAvailableSkills: options.mergeAllAvailableSkills,
+    builtinDir: options.builtinDir,
+  });
+  await registry.loadRoots(roots);
+  registerBuiltinSkills(registry);
+  return registry.listSkills().map(summarizeSkill);
+}

packages/node-sdk/src/pythinker-harness.ts

@@ -25,6 +25,7 @@ import type {
   RenameSessionInput,
   ResumeSessionInput,
   SessionSummary,
+  SkillSummary,
   TelemetryClient,
   TelemetryContextPatch,
   TelemetryProperties,
@@ -235,6 +236,11 @@ export class PythinkerHarness {
     return this.rpc.listAgentProfiles(workDir);
   }
 
+  /** The workspace's skills without opening a session; excludes session-only MCP prompts. */
+  async listWorkspaceSkills(workDir: string): Promise<readonly SkillSummary[]> {
+    return this.rpc.listWorkspaceSkills(workDir);
+  }
+
   async ensureConfigFile(): Promise<void> {
     await this.ensureConfigFileImpl();
   }

packages/node-sdk/src/rpc.ts

@@ -249,6 +249,12 @@ export abstract class SDKRpcClientBase {
     return rpc.listAgentProfiles({ workDir });
   }
 
+  /** The workspace's skills without opening a session; excludes session-only MCP prompts. */
+  async listWorkspaceSkills(workDir: string): Promise<readonly SkillSummary[]> {
+    const rpc = await this.getRpc();
+    return rpc.listWorkspaceSkills({ workDir });
+  }
+
   async setConfig(input: PythinkerConfigPatch): Promise<PythinkerConfig> {
     const rpc = await this.getRpc();
     return rpc.setPythinkerConfig(input);