@robota-sdk/agent-command 3.0.0-beta.100

package/src/shell/shell-command-module.ts

@@ -0,0 +1,53 @@
+/**
+ * TERM-003: `/shell` command module — a framework-level consumer of the terminal-handoff capability.
+ */
+import { executeShellCommand, SHELL_COMMAND_DESCRIPTION } from './shell-command.js';
+
+import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+export function createShellCommandEntry(): ICommand {
+  return {
+    name: 'shell',
+    displayName: 'Shell',
+    description: SHELL_COMMAND_DESCRIPTION,
+    source: 'shell',
+    // User-only: the user's own shell passthrough; the model has its permission-gated shell tool.
+    modelInvocable: false,
+    // It takes over the terminal the user sits at, so that terminal runs it, even when attached.
+    runner: 'client',
+    surfaces: ['terminal'],
+  };
+}
+
+function createShellSystemCommand(executable?: string): ISystemCommand {
+  const entry = createShellCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: true,
+    userInvocable: true,
+    modelInvocable: false,
+    runner: entry.runner,
+    surfaces: entry.surfaces,
+    lifecycle: 'inline',
+    execute: (context, args) => executeShellCommand(context, args, executable),
+  };
+}
+
+export class ShellCommandSource implements ICommandSource {
+  readonly name = 'shell';
+
+  getCommands(): ICommand[] {
+    return [createShellCommandEntry()];
+  }
+}
+
+export function createShellCommandModule(executable?: string): ICommandModule {
+  return {
+    name: 'agent-command-shell',
+    commandSources: [new ShellCommandSource()],
+    systemCommands: [createShellSystemCommand(executable)],
+  };
+}

package/src/shell/shell-command.ts

@@ -0,0 +1,48 @@
+/**
+ * TERM-003: `/shell` — hand the real terminal to an interactive subshell (or run a single command
+ * interactively), then return to the agent session. Uses the framework terminal-handoff capability;
+ * the shell choice goes through the `resolveShell()` seam (macOS/Linux first).
+ */
+import { resolveShell } from './resolve-shell.js';
+import { spawnInherited } from './spawn-inherited.js';
+
+import type {
+  ICommandHostTerminalHandoff,
+  ICommandHostWorkspace,
+} from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+
+export const SHELL_COMMAND_DESCRIPTION =
+  'Drop to an interactive shell (or run `/shell <command>` interactively), then return to the agent.';
+
+export async function executeShellCommand(
+  context: ICommandHostTerminalHandoff & ICommandHostWorkspace,
+  args: string,
+  executable?: string,
+): Promise<ICommandResult> {
+  if (!context.canHandoffTerminal()) {
+    return {
+      message: 'An interactive shell is unavailable here (no interactive terminal).',
+      success: false,
+    };
+  }
+
+  const shell = resolveShell(executable);
+  const cwd = context.getCwd();
+  const command = args.trim();
+
+  const exitCode = await context.runWithTerminal(async () =>
+    command.length > 0
+      ? spawnInherited(shell.command, shell.commandArgs(command), cwd)
+      : spawnInherited(shell.command, shell.interactiveArgs, cwd),
+  );
+
+  return {
+    message:
+      command.length > 0
+        ? `Command exited (code ${exitCode}).`
+        : `Shell session ended (code ${exitCode}).`,
+    success: exitCode === 0,
+    data: { exitCode },
+  };
+}

package/src/shell/spawn-inherited.ts

@@ -0,0 +1,32 @@
+/**
+ * Pure-Node spawn with the real terminal inherited (interactive input + output). Used inside a
+ * terminal-handoff `runWithTerminal(fn)` — the framework/transport own the suspend/restore; this just
+ * runs the child attached to the real TTY and resolves with its exit code.
+ */
+import { spawn } from 'node:child_process';
+import { constants } from 'node:os';
+
+export function spawnInherited(
+  command: string,
+  args: readonly string[],
+  cwd: string,
+): Promise<number> {
+  return new Promise<number>((resolve, reject) => {
+    const child = spawn(command, [...args], { cwd, stdio: 'inherit', env: process.env });
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      // RUNTIME-53: a signal-terminated child reports code=null; resolving 0 there is a false
+      // success. Translate to the shell convention 128 + signal number so callers see the failure.
+      if (code !== null) {
+        resolve(code);
+        return;
+      }
+      if (signal) {
+        const signalNumber = constants.signals[signal as keyof typeof constants.signals];
+        resolve(128 + (signalNumber ?? 0));
+        return;
+      }
+      resolve(0);
+    });
+  });
+}

package/src/skills/__tests__/skill-read-command.test.ts

@@ -0,0 +1,64 @@
+import { expect, it, vi } from 'vitest';
+import { SystemCommandExecutor } from '@robota-sdk/agent-framework';
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
+import { createSkillsCommandModule } from '../skills-command-module.js';
+
+it('offers supporting reads to the model under the composed semantic command identity', async () => {
+  const module = createSkillsCommandModule({ contributionSources: [] });
+  const executor = new SystemCommandExecutor([...(module.systemCommands ?? [])]);
+  expect(executor.getSemanticRoles().skillResourceRead).toBe('skill-read');
+  expect(executor.isModelInvocable('skill-read')).toBe(true);
+  expect(
+    executor.listModelInvocableCommands().find((command) => command.name === 'skill-read')
+      ?.description,
+  ).toContain('already activated');
+  const resource = {
+    uri: 'skill://demo/reference%20file.txt',
+    digest: 'sha256:verified',
+    size: 7,
+    text: 'content',
+  };
+  const readSkillResource = vi.fn(async () => resource);
+  const context = createTestCommandHost({ overrides: { readSkillResource } });
+  const result = await executor.executeModelInvocable(
+    'skill-read',
+    context,
+    JSON.stringify(['demo', resource.uri]),
+  );
+  expect(readSkillResource).toHaveBeenCalledWith('demo', resource.uri);
+  expect(result).toMatchObject({ success: true, data: resource });
+});
+
+it.each(['', '{}', '["demo"]', '["demo", 3]', '["demo", "uri", "extra"]', '["", "uri"]'])(
+  'refuses malformed resource arguments without calling the host: %s',
+  async (args) => {
+    const executor = new SystemCommandExecutor([
+      ...(createSkillsCommandModule({ contributionSources: [] }).systemCommands ?? []),
+    ]);
+    const readSkillResource = vi.fn();
+    const result = await executor.executeModelInvocable(
+      'skill-read',
+      createTestCommandHost({ overrides: { readSkillResource } }),
+      args,
+    );
+    expect(result?.success).toBe(false);
+    expect(readSkillResource).not.toHaveBeenCalled();
+  },
+);
+
+it('reports an unavailable host instead of acquiring a skill or falling back to filesystem reads', async () => {
+  const executor = new SystemCommandExecutor([
+    ...(createSkillsCommandModule({ contributionSources: [] }).systemCommands ?? []),
+  ]);
+  const executeSkillCommandByName = vi.fn();
+  const result = await executor.executeModelInvocable(
+    'skill-read',
+    createTestCommandHost({ overrides: { executeSkillCommandByName } }),
+    '["demo", "skill://demo/file"]',
+  );
+  expect(result).toMatchObject({
+    success: false,
+    message: expect.stringContaining('does not provide'),
+  });
+  expect(executeSkillCommandByName).not.toHaveBeenCalled();
+});

package/src/skills/__tests__/skills-command-module.test.ts

@@ -0,0 +1,200 @@
+import { describe, expect, it, vi } from 'vitest';
+import { mkdirSync, mkdtempSync, realpathSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  createNodeHostContributionSource,
+  InteractiveSession,
+  SystemCommandExecutor,
+  WorkspaceTrustService,
+} from '@robota-sdk/agent-framework';
+import { createSkillsCommandModule } from '../skills-command-module.js';
+import {
+  createTestCommandHost,
+  type ICreateTestCommandHostOptions,
+} from '@robota-sdk/agent-framework/testing';
+
+import type { IWorkspaceIdentity, IWorkspaceTrustStore } from '@robota-sdk/agent-framework';
+
+async function createTrustedProjectAccess(cwd: string) {
+  const root = realpathSync(cwd);
+  const identity: IWorkspaceIdentity = {
+    repositoryKey: `skills-command-test:${root}`,
+    displayPath: root,
+    worktreeRoot: root,
+  };
+  const store: IWorkspaceTrustStore = {
+    inspect: () => Promise.resolve({ state: 'trusted', generation: 1 }),
+    grant: () => Promise.resolve({ state: 'trusted', generation: 1 }),
+    revoke: () => Promise.resolve({ state: 'revoked', generation: 2 }),
+  };
+  return new WorkspaceTrustService({
+    identityResolver: { resolve: () => identity },
+    store,
+  }).inspect(root);
+}
+
+function createTempSkill(cwd: string): void {
+  const skillDir = join(cwd, '.agents', 'skills', 'audit');
+  mkdirSync(skillDir, { recursive: true });
+  writeFileSync(
+    join(skillDir, 'SKILL.md'),
+    ['---', 'name: audit', 'description: Audit code', '---', 'Audit $ARGUMENTS'].join('\n'),
+    'utf8',
+  );
+}
+
+function makeParentSession() {
+  return {
+    run: vi.fn().mockResolvedValue('parent response'),
+    abort: vi.fn(),
+    assertInputAllowed: vi.fn(),
+    getHistory: vi.fn().mockReturnValue([]),
+    getContextState: vi.fn().mockReturnValue({
+      usedPercentage: 10,
+      usedTokens: 100,
+      maxTokens: 1000,
+    }),
+    injectMessage: vi.fn(),
+    getSessionId: vi.fn().mockReturnValue('parent-session-id'),
+    // SELFHOST-004 P6: the span collector subscribes to the session bus each turn.
+    getEventService: vi.fn().mockReturnValue({ subscribe: vi.fn(), unsubscribe: vi.fn() }),
+    getSystemMessage: vi.fn().mockReturnValue('# system'),
+    getToolSchemas: vi.fn().mockReturnValue([]),
+  };
+}
+
+function createMockContext(overrides?: ICreateTestCommandHostOptions['overrides']) {
+  // ARCH-029: overrides over a conformant host rather than a 20-member literal asserting it IS one.
+  return createTestCommandHost({
+    overrides: {
+      getSession: vi.fn(),
+      getContextState: vi.fn(),
+      getAutoCompactThreshold: vi.fn().mockReturnValue(0.835),
+      compactContext: vi.fn(),
+      getCwd: vi.fn().mockReturnValue('/workspace'),
+      listEditCheckpoints: vi.fn().mockReturnValue([]),
+      restoreEditCheckpoint: vi.fn(),
+      rollbackEditCheckpoint: vi.fn(),
+      getUsedMemoryReferences: vi.fn().mockReturnValue([]),
+      recordMemoryEvent: vi.fn(),
+      listBackgroundTasks: vi.fn().mockReturnValue([]),
+      readBackgroundTaskLog: vi.fn(),
+      cancelBackgroundTask: vi.fn(),
+      closeBackgroundTask: vi.fn(),
+      ...overrides,
+    },
+  });
+}
+
+describe('createSkillsCommandModule', () => {
+  it('exposes skills as a normal model-invocable command module', () => {
+    const module = createSkillsCommandModule({ contributionSources: [] });
+    const command = module.systemCommands?.[0];
+
+    expect(module.name).toBe('agent-command-skills');
+    expect(module.commandSources?.[0]?.getCommands().map((entry) => entry.name)).toEqual([
+      'skills',
+      'skill-read',
+    ]);
+    expect(command).toMatchObject({
+      name: 'skills',
+      semanticRole: 'skillActivation',
+      userInvocable: true,
+      modelInvocable: true,
+      lifecycle: 'inline',
+      argumentHint: '[list | <skill-name> [args]]',
+      safety: 'read-only',
+    });
+    expect(command?.modelDescription).toContain('projected skills command tool');
+  });
+
+  it('lists skill metadata from the SDK host context', async () => {
+    const executor = new SystemCommandExecutor([
+      ...(createSkillsCommandModule({ contributionSources: [] }).systemCommands ?? []),
+    ]);
+
+    const result = await executor.execute(
+      'skills',
+      createMockContext({
+        listSkills: vi.fn().mockReturnValue([
+          {
+            name: 'repo-writing',
+            description: 'Repository writing rules',
+            source: 'skill',
+            modelInvocable: true,
+            userInvocable: true,
+          },
+        ]),
+      }),
+      '',
+    );
+
+    expect(result?.message).toContain('repo-writing: Repository writing rules');
+    expect(result?.message).toContain('Use /skills <skill-name> [args]');
+    expect(result?.data?.['activationContract']).toMatchObject({
+      activateWith: '/skills <skill-name> [args]',
+      activationRequiredBeforeWorkflow: true,
+    });
+  });
+
+  it('activates skills through the SDK host skill activation API', async () => {
+    const executeSkillCommandByName = vi.fn().mockResolvedValue({
+      success: true,
+      message: 'Skill activated: repo-writing',
+      data: { skill: 'repo-writing' },
+    });
+    const executor = new SystemCommandExecutor([
+      ...(createSkillsCommandModule({ contributionSources: [] }).systemCommands ?? []),
+    ]);
+
+    const result = await executor.execute(
+      'skills',
+      createMockContext({
+        getCommandInvocationSource: vi.fn().mockReturnValue('model'),
+        executeSkillCommandByName,
+      }),
+      'repo-writing update docs',
+    );
+
+    expect(executeSkillCommandByName).toHaveBeenCalledWith('repo-writing', 'update docs', {
+      invocationSource: 'model',
+      displayInput: '/repo-writing update docs',
+      rawInput: '/repo-writing update docs',
+    });
+    expect(result?.message).toBe('Skill activated: repo-writing');
+  });
+
+  it('lets the SDK normalize virtual /skill-name commands into the composed skills command', async () => {
+    const cwd = realpathSync(mkdtempSync(join(tmpdir(), 'agent-test-skills-command-module-')));
+    createTempSkill(cwd);
+    const parentSession = makeParentSession();
+    const session = new InteractiveSession({
+      session: parentSession as never,
+      cwd,
+      projectAccess: await createTrustedProjectAccess(cwd),
+      contributionSources: [createNodeHostContributionSource(cwd)],
+      skillRoots: [{ root: join('.agents', 'skills'), kind: 'skills' }],
+      commandModules: [
+        createSkillsCommandModule({
+          contributionSources: [createNodeHostContributionSource(cwd)],
+          skillRoots: [{ root: join('.agents', 'skills'), kind: 'skills' }],
+        }),
+      ],
+    });
+
+    const result = await session.executeCommand('audit', 'src/index.ts');
+
+    expect(result).toMatchObject({
+      success: true,
+      data: expect.objectContaining({
+        skill: 'audit',
+        sessionExecution: true,
+      }),
+    });
+    expect(parentSession.run).toHaveBeenCalledWith(
+      expect.stringContaining('Audit src/index.ts'),
+      '/audit src/index.ts',
+    );
+  });
+});

package/src/skills/index.ts

@@ -0,0 +1,7 @@
+export {
+  createSkillsCommandEntry,
+  createSkillsCommandModule,
+  SkillsCommandSource,
+} from './skills-command-module.js';
+export type { ISkillsCommandModuleOptions } from './skills-command-module.js';
+export { executeSkillsCommand, SKILLS_COMMAND_DESCRIPTION } from './skills-command.js';

package/src/skills/skill-read-command.ts

@@ -0,0 +1,60 @@
+import type { ICommand, ICommandResult } from '@robota-sdk/agent-interface-command';
+import type { ICommandHostCatalog, ISystemCommand } from '@robota-sdk/agent-framework';
+
+export function createSkillReadCommandEntry(): ICommand {
+  return {
+    name: 'skill-read',
+    description: 'Read a supporting file from a skill active in this execution',
+    modelDescription:
+      'Read verified supporting bytes from a skill already activated in this execution. Use when its instructions refer to a resource in the returned manifest. Args are a JSON array ["<skill-name>", "<resource-uri>"]. Returns the verified URI, digest, size and text or base64 blob with optional MIME type. This does not activate nested skills or grant consent; unactivated skills, undeclared resources and ended executions are refused. Binary blobs are returned as encoded data, not a rendered image.',
+    argumentHint: '["<skill-name>", "<resource-uri>"]',
+    source: 'skills',
+    userInvocable: true,
+    modelInvocable: true,
+    safety: 'read-only',
+  };
+}
+
+export async function executeSkillReadCommand(
+  context: Pick<ICommandHostCatalog, 'readSkillResource'>,
+  args = '',
+): Promise<ICommandResult> {
+  let input: unknown;
+  try {
+    input = JSON.parse(args);
+  } catch {
+    return { success: false, message: 'Use /skill-read ["<skill-name>", "<resource-uri>"]' };
+  }
+  if (
+    !Array.isArray(input) ||
+    input.length !== 2 ||
+    input.some((value) => typeof value !== 'string' || !value.length)
+  )
+    return { success: false, message: 'Use /skill-read ["<skill-name>", "<resource-uri>"]' };
+  if (!context.readSkillResource)
+    return { success: false, message: 'This host does not provide active skill resource reads.' };
+  try {
+    const resource = await context.readSkillResource(input[0], input[1]);
+    return {
+      success: true,
+      message: `Read verified skill resource: ${resource.uri}`,
+      data: { ...resource },
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Skill resource read refused: ${error instanceof Error ? error.message : 'host refused the read'}`,
+    };
+  }
+}
+
+export function createSkillReadSystemCommand(): ISystemCommand {
+  const entry = createSkillReadCommandEntry();
+  return {
+    ...entry,
+    semanticRole: 'skillResourceRead',
+    requiresPermission: false,
+    lifecycle: 'inline',
+    execute: executeSkillReadCommand,
+  };
+}

package/src/skills/skills-command-module.ts

@@ -0,0 +1,76 @@
+import { SkillCommandSource } from '@robota-sdk/agent-framework';
+import { createSkillReadCommandEntry, createSkillReadSystemCommand } from './skill-read-command.js';
+
+import {
+  executeSkillsCommand,
+  SKILLS_COMMAND_DESCRIPTION,
+  SKILLS_COMMAND_MODEL_DESCRIPTION,
+} from './skills-command.js';
+
+import type {
+  ICommandModule,
+  IContributionSource,
+  ISystemCommand,
+  ISkillRootDescriptor,
+} from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+export interface ISkillsCommandModuleOptions {
+  readonly contributionSources: readonly IContributionSource[];
+  readonly skillRoots?: readonly ISkillRootDescriptor[];
+}
+
+export function createSkillsCommandEntry(): ICommand {
+  return {
+    name: 'skills',
+    displayName: 'Skills',
+    description: SKILLS_COMMAND_DESCRIPTION,
+    // Model-invocable: activating a skill is how the model follows one; a skill's own
+    // `disable-model-invocation` frontmatter still refuses it per skill.
+    modelDescription: SKILLS_COMMAND_MODEL_DESCRIPTION,
+    source: 'skills',
+    modelInvocable: true,
+    userInvocable: true,
+    argumentHint: '[list | <skill-name> [args]]',
+    safety: 'read-only',
+  };
+}
+
+function createSkillsSystemCommand(): ISystemCommand {
+  const entry = createSkillsCommandEntry();
+  return {
+    name: entry.name,
+    semanticRole: 'skillActivation',
+    ...(entry.modelDescription !== undefined ? { modelDescription: entry.modelDescription } : {}),
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: true,
+    argumentHint: entry.argumentHint,
+    safety: entry.safety,
+    lifecycle: 'inline',
+    execute: executeSkillsCommand,
+  };
+}
+
+export class SkillsCommandSource implements ICommandSource {
+  readonly name = 'skills';
+
+  getCommands(): ICommand[] {
+    return [createSkillsCommandEntry(), createSkillReadCommandEntry()];
+  }
+}
+
+export function createSkillsCommandModule(options: ISkillsCommandModuleOptions): ICommandModule {
+  const commandSources: ICommandSource[] = [new SkillsCommandSource()];
+  commandSources.push(
+    new SkillCommandSource(options.contributionSources, options.skillRoots ?? []),
+  );
+
+  return {
+    name: 'agent-command-skills',
+    commandSources,
+    systemCommands: [createSkillsSystemCommand(), createSkillReadSystemCommand()],
+  };
+}

package/src/skills/skills-command.ts

@@ -0,0 +1,108 @@
+import type {
+  ICommandHostCatalog,
+  ICommandHostWorkspace,
+  ICommandSkillListEntry,
+} from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+
+export const SKILLS_COMMAND_DESCRIPTION = 'List registered skills, or activate one by name';
+
+/** What the model is told about `skills`; `SKILLS_COMMAND_DESCRIPTION` is the `/help` line. */
+export const SKILLS_COMMAND_MODEL_DESCRIPTION =
+  'Skill command. Before following a matching registered skill from the system prompt Skills section, invoke the projected skills command tool with args "<skill-name> [args]". Without arguments, list registered skills. With a skill name, activate that skill; a skill that declares it is not model-invocable is refused. Returns the skill list with each skill\'s description, or the activated skill\'s instructions to follow. Slash syntax is a UI input/display concern; the SDK command identity is "skills".';
+
+interface IParsedSkillsArgs {
+  readonly action: 'list' | 'activate';
+  readonly skillName?: string;
+  readonly skillArgs: string;
+}
+
+function formatSkillFlags(skill: ICommandSkillListEntry): string {
+  const flags: string[] = [];
+  if (!skill.modelInvocable) flags.push('model-disabled');
+  if (!skill.userInvocable) flags.push('model-only');
+  if (skill.context) flags.push(`context:${skill.context}`);
+  if (skill.agent) flags.push(`agent:${skill.agent}`);
+  return flags.length > 0 ? ` [${flags.join(', ')}]` : '';
+}
+
+function formatSkillLine(skill: ICommandSkillListEntry): string {
+  const hint = skill.argumentHint ? ` ${skill.argumentHint}` : '';
+  return `- ${skill.name}${hint}: ${skill.description}${formatSkillFlags(skill)}`;
+}
+
+function formatSkillsMessage(skills: readonly ICommandSkillListEntry[]): string {
+  if (skills.length === 0) {
+    return [
+      'No skills are registered for this session.',
+      '',
+      'Skills are metadata until activated. Do not invent or imitate a skill workflow when no matching registered skill exists.',
+    ].join('\n');
+  }
+
+  return [
+    'Registered skills:',
+    ...skills.map(formatSkillLine),
+    '',
+    'Activation contract:',
+    '- Use /skills <skill-name> [args] to activate a matching skill.',
+    '- Treat /<skill-name> as a virtual alias for /skills <skill-name>.',
+    '- The system prompt Skills section is skill selection metadata.',
+    '- Treat descriptions as selection metadata only, not as loaded SKILL.md content.',
+    '- Do not answer by merely naming, recommending, or imitating a matching skill.',
+    '- If no listed skill matches the task, continue without claiming a skill was activated.',
+  ].join('\n');
+}
+
+function parseSkillsArgs(args: string): IParsedSkillsArgs {
+  const trimmed = args.trim();
+  if (trimmed.length === 0 || trimmed === 'list') {
+    return { action: 'list', skillArgs: '' };
+  }
+
+  const [skillName = '', ...rest] = trimmed.split(/\s+/);
+  if (skillName.length === 0) {
+    return { action: 'list', skillArgs: '' };
+  }
+
+  return {
+    action: 'activate',
+    skillName,
+    skillArgs: rest.join(' '),
+  };
+}
+
+export async function executeSkillsCommand(
+  context: ICommandHostCatalog & ICommandHostWorkspace,
+  args = '',
+): Promise<ICommandResult> {
+  const parsed = parseSkillsArgs(args);
+  if (parsed.action === 'activate' && parsed.skillName !== undefined) {
+    const displayInput = `/${parsed.skillName}${parsed.skillArgs ? ` ${parsed.skillArgs}` : ''}`;
+    const result = await context.executeSkillCommandByName(parsed.skillName, parsed.skillArgs, {
+      invocationSource: context.getCommandInvocationSource(),
+      displayInput,
+      rawInput: displayInput,
+    });
+    return (
+      result ?? {
+        success: false,
+        message: `Unknown skill: ${parsed.skillName}`,
+      }
+    );
+  }
+
+  const skills = context.listSkills();
+  return {
+    success: true,
+    message: formatSkillsMessage(skills),
+    data: {
+      skills,
+      activationContract: {
+        activateWith: '/skills <skill-name> [args]',
+        activationRequiredBeforeWorkflow: true,
+        metadataIsNotSkillContent: true,
+      },
+    },
+  };
+}