@inneranimalmedia/agentsam-sdk 2.6.3 → 2.6.4

package/src/commands/interaction-clack.js

@@ -0,0 +1,115 @@
+/**
+ * Present AgentSamInteraction via Clack (or plain write fallback).
+ * Hosts (shell, Local Studio, Tauri) can swap the prompt impls.
+ */
+
+import { confirm, isCancel, select, text } from '@clack/prompts';
+
+/**
+ * @param {import('../skills/interaction.js').AgentSamInteraction} interaction
+ * @param {{
+ *   write?: (s: string) => void,
+ *   interactive?: boolean,
+ *   selectImpl?: typeof select,
+ *   confirmImpl?: typeof confirm,
+ *   textImpl?: typeof text,
+ * }} [options]
+ * @returns {Promise<{ action: string|null, value: string|null, cancelled: boolean }>}
+ */
+export async function presentAgentSamInteraction(interaction, options = {}) {
+  const write = options.write || ((s) => process.stdout.write(s));
+  const interactive =
+    options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const prompt = interaction?.prompt;
+
+  if (!prompt?.message) {
+    return { action: null, value: null, cancelled: false };
+  }
+
+  for (const line of String(prompt.message).split('\n')) {
+    write(`  ${line}\n`);
+  }
+
+  if (!interactive) {
+    return { action: null, value: null, cancelled: false };
+  }
+
+  const status = interaction.status;
+
+  if (status === 'needs_input' && prompt.kind === 'select' && Array.isArray(prompt.options) && prompt.options.length) {
+    const answer = await (options.selectImpl || select)({
+      message: prompt.title || 'Choose',
+      options: prompt.options.map((opt) => ({
+        value: opt.value,
+        label: opt.label,
+        hint: opt.description,
+      })),
+    });
+    if (isCancel(answer)) return { action: null, value: null, cancelled: true };
+    return { action: String(answer), value: String(answer), cancelled: false };
+  }
+
+  if (status === 'needs_input' && prompt.kind === 'text') {
+    const answer = await (options.textImpl || text)({
+      message: prompt.title || prompt.message,
+    });
+    if (isCancel(answer)) return { action: null, value: null, cancelled: true };
+    return { action: 'text', value: String(answer), cancelled: false };
+  }
+
+  if (status === 'needs_approval' || (status === 'needs_input' && prompt.kind === 'confirm')) {
+    const answer = await (options.confirmImpl || confirm)({
+      message: prompt.title || prompt.message,
+    });
+    if (isCancel(answer)) return { action: null, value: null, cancelled: true };
+    return { action: answer ? 'confirm' : 'cancel', value: answer ? 'yes' : 'no', cancelled: false };
+  }
+
+  if (
+    (status === 'blocked' || status === 'needs_input') &&
+    Array.isArray(prompt.actions) &&
+    prompt.actions.length
+  ) {
+    const answer = await (options.selectImpl || select)({
+      message: prompt.title || 'Next',
+      options: prompt.actions.map((a) => ({ value: a.id, label: a.label })),
+    });
+    if (isCancel(answer)) return { action: null, value: null, cancelled: true };
+    return { action: String(answer), value: String(answer), cancelled: false };
+  }
+
+  return { action: null, value: null, cancelled: false };
+}
+
+/**
+ * Map shell skill interaction choices to follow-up CLI actions.
+ */
+export async function handleSkillInteractionChoice(choice, state = {}) {
+  const write = state.write || ((s) => process.stdout.write(s));
+  const { runSkill } = await import('./skill.js');
+  if (!choice || choice.cancelled) return null;
+  if (choice.action === 'create' || choice.value === 'create') {
+    const id = 'my-first-skill';
+    write(`\n  Running: agentsam skill create ${id}\n\n`);
+    return runSkill(['create', id], { write, home: state.home, env: state.env });
+  }
+  if (typeof choice.value === 'string' && choice.value.startsWith('create:')) {
+    const id = choice.value.slice('create:'.length) || 'my-first-skill';
+    write(`\n  Running: agentsam skill create ${id}\n\n`);
+    return runSkill(['create', id], { write, home: state.home, env: state.env });
+  }
+  if (typeof choice.action === 'string' && choice.action.startsWith('create:')) {
+    const id = choice.action.slice('create:'.length) || 'my-first-skill';
+    write(`\n  Running: agentsam skill create ${id}\n\n`);
+    return runSkill(['create', id], { write, home: state.home, env: state.env });
+  }
+  if (choice.action === 'install' || choice.value === 'install') {
+    write('\n  Next: agentsam skill install ./path-to-skill  (or @scope/pkg)\n\n');
+    return null;
+  }
+  if (choice.action === 'list' || choice.value === 'list') {
+    return runSkill(['list'], { write, home: state.home, env: state.env });
+  }
+  // create with prefilled id handled above
+  return null;
+}

package/src/commands/models.js

@@ -1,7 +1,7 @@
 import pc from 'picocolors';
 import { isCancel, select } from '@clack/prompts';
 import { probeOllama, resolveOllamaConfig } from './ollama.js';
-import { listModelCatalog } from '../models/index.js';
+import { listModelCatalog } from '../models/catalog.js';
 import { discoverProviderModels } from '../models/discovery.js';
 import { resolveProviderCredential } from '../lib/provider-credentials.js';
 import { providerChoices, promptAndConfigureProvider } from './providers.js';

package/src/commands/providers.js

@@ -164,8 +164,13 @@ export async function validateAndSaveProviderCredential(provider, secret, option
     };
   }
 
-  // Key is verified! Now persist securely to OS store + AES-256-GCM vault + env profile
-  setProviderCredential(id, cleanSecret, { ...options, accountId });
+  // Key is verified. Persist securely to the OS store + AES-256-GCM vault.
+  // Plaintext shell profiles remain explicit opt-in only.
+  setProviderCredential(id, cleanSecret, {
+    ...options,
+    accountId,
+    writeEnvProfile: options.writeEnvProfile === true,
+  });
 
   return {
     attempted: true,
@@ -213,7 +218,11 @@ export async function promptAndConfigureProvider(provider, options = {}) {
   const spin = options.spinnerImpl ? options.spinnerImpl() : spinner();
   spin.start(`Verifying ${spec.label} API credential`);
 
-  const result = await validateAndSaveProviderCredential(id, String(secret), { ...options, accountId });
+  const result = await validateAndSaveProviderCredential(id, String(secret), {
+    ...options,
+    accountId,
+    writeEnvProfile: options.writeEnvProfile === true,
+  });
 
   if (!result.ok) {
     spin.stop(`Verification failed: ${result.error || 'invalid key'} · Key was NOT saved`, 1);
@@ -255,10 +264,19 @@ async function runInteractiveProviders(options = {}) {
 }
 
 function parseArgs(argv = []) {
-  const out = { command: 'interactive', provider: '', json: false, verify: false, yes: false, fromEnv: '' };
+  const out = {
+    command: 'interactive',
+    provider: '',
+    json: false,
+    verify: false,
+    yes: false,
+    fromEnv: '',
+    fromStdin: false,
+    exportProfile: true,
+  };
   const args = [...argv];
   if (args[0] && !args[0].startsWith('-')) out.command = args.shift();
-  if (['add', 'set', 'remove', 'verify', 'status', 'export'].includes(out.command) && args[0] && !args[0].startsWith('-')) {
+  if (['add', 'set', 'remove', 'verify', 'status', 'export', 'roll'].includes(out.command) && args[0] && !args[0].startsWith('-')) {
     out.provider = normalizeProviderId(args.shift());
   }
   while (args.length) {
@@ -267,6 +285,9 @@ function parseArgs(argv = []) {
     else if (arg === '--verify') out.verify = true;
     else if (arg === '--yes' || arg === '-y') out.yes = true;
     else if (arg === '--from-env') out.fromEnv = clean(args.shift());
+    else if (arg === '--from-stdin') out.fromStdin = true;
+    else if (arg === '--no-export') out.exportProfile = false;
+    else if (arg === '--export') out.exportProfile = true;
     else if (arg === '--help' || arg === '-h') out.command = 'help';
     else throw new Error(`unknown providers option: ${arg}`);
   }
@@ -281,13 +302,17 @@ export async function runProviders(argv = [], options = {}) {
     write([
       'agentsam providers',
       'agentsam providers status [provider] [--verify] [--json]',
-      'agentsam providers add <provider> [--from-env NAME]',
+      'agentsam providers add <provider> [--from-env NAME|--from-stdin] [--no-export]',
+      'agentsam providers roll <provider> [--from-env NAME|--from-stdin]   replace + export env.d',
       'agentsam providers export <provider>',
       'agentsam providers verify [provider] [--json]',
       'agentsam providers remove <provider> [--yes]',
       '',
       `Providers: ${PROVIDER_ORDER.join(', ')}`,
       '',
+      'Boot load: source ~/.agentsam/load-agent-env.sh <provider…>',
+      '           agentsam env boot-line',
+      '',
     ].join('\n'));
     return;
   }
@@ -338,24 +363,47 @@ export async function runProviders(argv = [], options = {}) {
     return results;
   }
 
-  if (parsed.command === 'add' || parsed.command === 'set') {
+  if (parsed.command === 'add' || parsed.command === 'set' || parsed.command === 'roll') {
     if (!parsed.provider) throw new Error('providers add requires a provider');
-    if (parsed.fromEnv) {
-      const value = clean((options.env || process.env)[parsed.fromEnv]);
-      if (!value) throw new Error(`environment credential missing: ${parsed.fromEnv}`);
-      const verified = await validateAndSaveProviderCredential(parsed.provider, value, options);
+    if (parsed.command === 'roll') {
+      removeProviderCredential(parsed.provider, options);
+    }
+    let secretValue = '';
+    if (parsed.fromStdin) {
+      const chunks = [];
+      for await (const chunk of options.stdin || process.stdin) chunks.push(chunk);
+      secretValue = Buffer.concat(chunks.map((c) => (Buffer.isBuffer(c) ? c : Buffer.from(c)))).toString('utf8').trim();
+      if (!secretValue) throw new Error('stdin credential missing');
+    } else if (parsed.fromEnv) {
+      secretValue = clean((options.env || process.env)[parsed.fromEnv]);
+      if (!secretValue) throw new Error(`environment credential missing: ${parsed.fromEnv}`);
+    }
+    if (secretValue) {
+      const verified = await validateAndSaveProviderCredential(parsed.provider, secretValue, {
+        ...options,
+        writeEnvProfile: parsed.exportProfile,
+      });
       if (!verified.ok) {
         throw new Error(`Provider verification failed: ${verified.error}. Credential was not saved.`);
       }
-      writeLine(write, `  ${parsed.provider} verified · ${verified.model_count || 0} models`);
+      writeLine(write, `  ${parsed.provider} verified · saved${parsed.exportProfile ? ' · env.d exported' : ''}`);
+      if (parsed.exportProfile) {
+        writeLine(write, `  source ~/.agentsam/load-agent-env.sh ${parsed.provider}`);
+      }
       return verified;
     }
     if (options.interactive === false || !(options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY))) {
-      throw new Error('providers add requires an interactive terminal or --from-env NAME');
+      throw new Error('providers add requires an interactive terminal, --from-env NAME, or --from-stdin');
     }
-    const result = await promptAndConfigureProvider(parsed.provider, options);
+    const result = await promptAndConfigureProvider(parsed.provider, {
+      ...options,
+      writeEnvProfile: parsed.exportProfile,
+    });
     if (!result) return null;
     writeLine(write, result.ok ? `  ${parsed.provider} verified` : `  ${parsed.provider} verification failed: ${result.error}`);
+    if (result.ok && parsed.exportProfile) {
+      writeLine(write, `  source ~/.agentsam/load-agent-env.sh ${parsed.provider}`);
+    }
     return result;
   }
 

package/src/commands/shell.js

@@ -20,7 +20,7 @@ import { createInlineActivity } from '../ui/cli/activity.js';
 import { createCliRuntimePresenter } from '../ui/cli/runtime-events.js';
 import { renderCliFooter, renderDiffPreview, renderUsagePanel } from '../ui/cli/footer.js';
 import { diagnosticFromError, renderDiagnosticError } from '../errors/index.js';
-import { getModelRecord, mergeModelReference } from '../models/index.js';
+import { getModelRecord, mergeModelReference, listModelCatalog } from '../models/index.js';
 import { discoverProviderModels } from '../models/discovery.js';
 import { detectCliProject, findCliProjectRoot, readCliPreferences, updateCliPreferences } from '../lib/cli-preferences.js';
 import { buildContextEconomicsReport, renderContextEconomics } from './context-economics.js';
@@ -40,6 +40,11 @@ import { tryResolveGitContext } from '../../packages/agentsam-repository/src/git
 import { syncWorkspaceStateToD1, readWorkspaceStateFromD1 } from '../../packages/agentsam-repository/src/workspace-state.js';
 import { syncGitCommitsToD1 } from '../../packages/agentsam-repository/src/work-tracking.js';
 import { readGoapState, listGoapTickets, createGoapGoal, switchGoapGoal, closeGoapGoal, renderGoapStatus, renderGoapList, renderGoapGoal, renderGoapWhy, renderGoapPlan } from '../../packages/agentsam-repository/src/goap.js';
+import { SkillRegistry, SkillRuntime, SkillContentResolver } from '../skills/index.js';
+import {
+  presentAgentSamInteraction,
+  handleSkillInteractionChoice,
+} from './interaction-clack.js';
 
 function writeLine(write, value = '') { write(`${value}\n`); }
 
@@ -1026,8 +1031,44 @@ export async function dispatchShellLine(line, state = {}) {
           await runInteractiveModelTurn(line, state);
           break;
         }
+        {
+          // Explicit slash → portable skill registry (no D1 / R2 / subagents).
+          const skillRuntime = new SkillRuntime({
+            registry: new SkillRegistry({ home: state.home }),
+            contentResolver: new SkillContentResolver(),
+          });
+          const skillResult = await skillRuntime.invoke({ input: line });
+          if (skillResult.matched) {
+            const interactiveStatuses = new Set(['needs_input', 'needs_approval', 'blocked']);
+            if (
+              state.interactive &&
+              interactiveStatuses.has(skillResult.interaction?.status) &&
+              skillResult.interaction?.prompt
+            ) {
+              const choice = await presentAgentSamInteraction(skillResult.interaction, {
+                write,
+                interactive: state.interactive,
+              });
+              if (choice.action === 'create' || String(choice.value || '').startsWith('create')) {
+                await handleSkillInteractionChoice(choice, { write, home: state.home });
+              } else if (choice.action === 'list' || choice.value === 'list') {
+                await handleSkillInteractionChoice(choice, { write, home: state.home });
+              } else if (choice.action === 'install' || choice.value === 'install') {
+                await handleSkillInteractionChoice(choice, { write, home: state.home });
+              }
+            } else if (skillResult.interaction?.prompt?.message) {
+              for (const msgLine of String(skillResult.interaction.prompt.message).split('\n')) {
+                writeLine(write, `  ${msgLine}`);
+              }
+            } else if (skillResult.modelInstructions?.content) {
+              writeLine(write, `  skill ${skillResult.skill?.id} · ${skillResult.receipt?.checksum || 'resolved'}`);
+              writeLine(write, `  (turn instructions ready · ${skillResult.tools?.length || 0} tools declared)`);
+            }
+            break;
+          }
+        }
         writeLine(write, `  Unknown Agent Sam command: ${command}`);
-        writeLine(write, '  Type / or /help for available commands.');
+        writeLine(write, '  Type / or /help for available commands. Use /skills for installable slash skills.');
         return { handled: false, exit: false, cwd: state.cwd };
     }
   } catch (error) {

package/src/commands/skill.js

@@ -0,0 +1,248 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import {
+  SkillRegistry,
+  SkillRuntime,
+  SkillContentResolver,
+  createUserSkill,
+  installSkillFromPath,
+  aliasSkill,
+  removeSkill,
+  readLocalRegistry,
+} from '../skills/index.js';
+
+function writeLine(write, value = '') {
+  write(`${value}\n`);
+}
+
+function help() {
+  return [
+    'AgentSam · skill',
+    '  agentsam skill list',
+    '  agentsam skill create <id>',
+    '  agentsam skill inspect <id>',
+    '  agentsam skill edit <id>          (prints path to edit)',
+    '  agentsam skill install <path|npm-package> [--alias /trigger]',
+    '  agentsam skill alias <id> </trigger>',
+    '  agentsam skill remove <id>',
+    '  agentsam skill publish <id>       (prints package checklist; no network)',
+    '  agentsam skill invoke </trigger> [args...]',
+    '',
+    'Slash triggers are local. Package manifests only suggest a trigger.',
+    'Collisions require an explicit alias — nothing is globally reserved.',
+    '',
+  ].join('\n');
+}
+
+function looksLikeNpmPackage(source) {
+  const s = String(source || '').trim();
+  if (!s) return false;
+  if (s.startsWith('.') || s.startsWith('/') || s.includes('\\')) return false;
+  if (s.startsWith('@')) return true;
+  // bare package name (no path separators)
+  return !s.includes('/') && !s.endsWith('.json');
+}
+
+/**
+ * Download an npm package tarball and return the extracted package root
+ * that contains agentsam.skill.json (or package root for relative resolve).
+ */
+export function resolveNpmSkillPackage(spec, options = {}) {
+  const spawn = options.spawnSyncImpl || spawnSync;
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-skill-npm-'));
+  const pack = spawn('npm', ['pack', spec, '--pack-destination', tmp], {
+    encoding: 'utf8',
+    cwd: options.cwd || process.cwd(),
+    env: options.env || process.env,
+  });
+  if ((pack.status ?? 1) !== 0) {
+    throw new Error(`npm_pack_failed:${spec}:${String(pack.stderr || pack.stdout || '').trim() || 'unknown'}`);
+  }
+  const tgzName = String(pack.stdout || '')
+    .trim()
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .pop();
+  if (!tgzName) throw new Error(`npm_pack_empty:${spec}`);
+  const tgzPath = path.join(tmp, path.basename(tgzName));
+  if (!fs.existsSync(tgzPath)) throw new Error(`npm_pack_missing:${tgzPath}`);
+
+  const extractDir = path.join(tmp, 'pkg');
+  fs.mkdirSync(extractDir, { recursive: true });
+  const tar = spawn('tar', ['-xzf', tgzPath, '-C', extractDir], { encoding: 'utf8' });
+  if ((tar.status ?? 1) !== 0) {
+    throw new Error(`npm_extract_failed:${String(tar.stderr || '').trim() || 'tar failed'}`);
+  }
+  const packageRoot = path.join(extractDir, 'package');
+  const candidates = [
+    path.join(packageRoot, 'agentsam.skill.json'),
+    path.join(packageRoot, 'skill', 'agentsam.skill.json'),
+    path.join(packageRoot, 'skills', 'agentsam.skill.json'),
+  ];
+  for (const file of candidates) {
+    if (fs.existsSync(file)) return path.dirname(file);
+  }
+  // walk one level
+  if (fs.existsSync(packageRoot)) {
+    for (const name of fs.readdirSync(packageRoot)) {
+      const nested = path.join(packageRoot, name, 'agentsam.skill.json');
+      if (fs.existsSync(nested)) return path.dirname(nested);
+    }
+  }
+  throw new Error(`agentsam.skill.json_not_found_in_package:${spec}`);
+}
+
+/**
+ * @param {string[]} argv
+ * @param {{ write?: Function, home?: string, env?: NodeJS.ProcessEnv }} [options]
+ */
+export async function runSkill(argv = [], options = {}) {
+  const write = options.write || ((t) => process.stdout.write(t));
+  const [command = 'list', ...rest] = argv;
+
+  if (command === '--help' || command === '-h' || command === 'help') {
+    write(help());
+    return null;
+  }
+
+  const registry = new SkillRegistry({ home: options.home, env: options.env });
+  const runtime = new SkillRuntime({
+    registry,
+    contentResolver: new SkillContentResolver(),
+  });
+
+  if (command === 'list') {
+    const rows = registry.list();
+    writeLine(write, '');
+    writeLine(write, '  AgentSam · skills');
+    writeLine(write, '');
+    for (const row of rows) {
+      const trig = row.trigger ? row.trigger.padEnd(22) : '(no trigger)'.padEnd(22);
+      writeLine(write, `  ${trig} ${row.id.padEnd(28)} [${row.source}]`);
+      if (row.description) writeLine(write, `    ${row.description}`);
+    }
+    writeLine(write, '');
+    return rows;
+  }
+
+  if (command === 'create') {
+    const id = rest[0];
+    if (!id) throw new Error('skill create requires <id>');
+    const result = createUserSkill(id, { home: options.home, env: options.env });
+    writeLine(write, '');
+    writeLine(write, `  created ${result.manifest.id}`);
+    writeLine(write, `  trigger  ${result.trigger}`);
+    writeLine(write, `  path     ${result.root}`);
+    writeLine(write, '');
+    return result;
+  }
+
+  if (command === 'inspect') {
+    const id = rest[0];
+    if (!id) throw new Error('skill inspect requires <id>');
+    const skill = registry.getById(id);
+    if (!skill) throw new Error(`unknown_skill:${id}`);
+    write(`${JSON.stringify(skill, null, 2)}\n`);
+    return skill;
+  }
+
+  if (command === 'edit') {
+    const id = rest[0];
+    if (!id) throw new Error('skill edit requires <id>');
+    const local = readLocalRegistry({ home: options.home, env: options.env });
+    const entry = local.entries[id];
+    if (!entry) throw new Error(`skill_not_user_editable:${id}`);
+    writeLine(write, entry.manifestPath);
+    writeLine(write, path.join(entry.baseDir, 'SKILL.md'));
+    return entry;
+  }
+
+  if (command === 'install') {
+    const source = rest[0];
+    if (!source) throw new Error('skill install requires <path|npm-package>');
+    let aliasOnCollision;
+    for (let i = 1; i < rest.length; i += 1) {
+      if (rest[i] === '--alias' || rest[i] === '--trigger') aliasOnCollision = rest[++i];
+    }
+
+    let installPath = source;
+    if (looksLikeNpmPackage(source)) {
+      writeLine(write, `  packing ${source}…`);
+      installPath = resolveNpmSkillPackage(source, options);
+    }
+
+    try {
+      const result = installSkillFromPath(installPath, {
+        home: options.home,
+        env: options.env,
+        aliasOnCollision,
+      });
+      writeLine(write, '');
+      writeLine(write, `  installed ${result.id}`);
+      writeLine(write, `  trigger   ${result.trigger}`);
+      writeLine(write, '');
+      return result;
+    } catch (error) {
+      if (error?.code === 'SLASH_COLLISION') {
+        writeLine(write, '');
+        writeLine(write, `  Conflict: ${error.suggested} already owned by ${error.owner}`);
+        writeLine(write, '  Choose an alias:');
+        for (const c of error.candidates || []) {
+          writeLine(write, `    agentsam skill install ${source} --alias ${c}`);
+        }
+        writeLine(write, '');
+        throw error;
+      }
+      throw error;
+    }
+  }
+
+  if (command === 'alias') {
+    const id = rest[0];
+    const trigger = rest[1];
+    if (!id || !trigger) throw new Error('skill alias requires <id> </trigger>');
+    const result = aliasSkill(id, trigger, { home: options.home, env: options.env });
+    writeLine(write, `  ${result.id} → ${result.trigger}`);
+    return result;
+  }
+
+  if (command === 'remove') {
+    const id = rest[0];
+    if (!id) throw new Error('skill remove requires <id>');
+    const result = removeSkill(id, { home: options.home, env: options.env });
+    writeLine(write, result.removed ? `  removed ${id}` : `  ${id} was not installed`);
+    return result;
+  }
+
+  if (command === 'publish') {
+    const id = rest[0];
+    if (!id) throw new Error('skill publish requires <id>');
+    const skill = registry.getById(id);
+    if (!skill) throw new Error(`unknown_skill:${id}`);
+    writeLine(write, '');
+    writeLine(write, '  Publish checklist (no network from portable core):');
+    writeLine(write, '  1. Ensure agentsam.skill.json validates as agentsam.skill.v1');
+    writeLine(write, '  2. npm publish (suggested slash is not globally reserved)');
+    writeLine(write, '  3. Consumers: agentsam skill install <path|@scope/pkg>');
+    writeLine(write, `  skill  ${skill.id}`);
+    writeLine(write, `  slash  ${skill.manifest.slash?.suggested || '(none)'}`);
+    writeLine(write, '');
+    return { id: skill.id, checklist: true };
+  }
+
+  if (command === 'invoke') {
+    const input = rest.join(' ').trim();
+    if (!input.startsWith('/')) throw new Error('skill invoke requires a /trigger');
+    const result = await runtime.invoke({ input });
+    write(`${JSON.stringify(result, null, 2)}\n`);
+    return result;
+  }
+
+  throw new Error(`unknown skill command: ${command}`);
+}
+
+export function skillCommandHelp() {
+  return help();
+}

package/src/commands/skills.js

@@ -1,4 +1,4 @@
-import { getSkill, listSkills, loadSkill } from '../skills/index.js';
+import { getSkill, listSkills, loadSkill } from '../skills/catalog.js';
 
 function parse(argv = []) {
   const out = { id: '', json: false, references: false };

package/src/commands/start-local.js

@@ -45,6 +45,9 @@ export async function runStartLocal(opts = {}) {
   console.log(`  ✓ PTY listening  ${server.url}`);
   console.log(`  ✓ Health         ${server.healthUrl}`);
   console.log(`  ✓ Project root   ${server.cwd}`);
+  console.log(`  ✓ Workspace      ${server.workspace_id}`);
+  console.log(`  ✓ Capability     ${server.capability.capability.slice(0, 12)}… (loopback bootstrap)`);
+  console.log(`  ✓ Runtime file   ${server.runtimeFile}`);
   console.log(`  ✓ Shell          ${server.shell}`);
   console.log(`
   Project services:
@@ -52,6 +55,7 @@ export async function runStartLocal(opts = {}) {
     npm run db:status    → inspect local SQLite
     npx agentsam          → enter Agent Sam
 
+  Studio: open a filesystem workspace rooted at this same directory.
   Press Ctrl+C to stop.
   `);