@jaimevalasek/aioson 1.3.0 → 1.4.0

package/src/backup-provider.js

@@ -0,0 +1,303 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const https = require('node:https');
+const http = require('node:http');
+const { URL } = require('node:url');
+
+// ── S3-compatible provider (AWS S3, Cloudflare R2, MinIO, Backblaze B2) ──
+
+function hmacSha256(key, data) {
+  return crypto.createHmac('sha256', key).update(data).digest();
+}
+
+function sha256Hex(data) {
+  return crypto.createHash('sha256').update(data).digest('hex');
+}
+
+function getSignatureKey(secretKey, dateStamp, region, service) {
+  let key = hmacSha256(`AWS4${secretKey}`, dateStamp);
+  key = hmacSha256(key, region);
+  key = hmacSha256(key, service);
+  key = hmacSha256(key, 'aws4_request');
+  return key;
+}
+
+function signV4(method, url, headers, body, config) {
+  const { accessKeyId, secretAccessKey, region } = config;
+  const now = new Date();
+  const dateStamp = now.toISOString().replace(/[-:]/g, '').slice(0, 8);
+  const amzDate = now.toISOString().replace(/[-:]/g, '').replace(/\.\d+/, '');
+  const service = 's3';
+  const scope = `${dateStamp}/${region}/${service}/aws4_request`;
+
+  const payloadHash = sha256Hex(body || '');
+  headers['x-amz-date'] = amzDate;
+  headers['x-amz-content-sha256'] = payloadHash;
+
+  const sortedHeaders = Object.keys(headers).sort();
+  const signedHeaders = sortedHeaders.map(k => k.toLowerCase()).join(';');
+  const canonicalHeaders = sortedHeaders
+    .map(k => `${k.toLowerCase()}:${headers[k].trim()}`)
+    .join('\n') + '\n';
+
+  const parsed = new URL(url);
+  const canonicalQuery = parsed.searchParams.toString();
+  const canonicalRequest = [
+    method,
+    parsed.pathname,
+    canonicalQuery,
+    canonicalHeaders,
+    signedHeaders,
+    payloadHash
+  ].join('\n');
+
+  const stringToSign = [
+    'AWS4-HMAC-SHA256',
+    amzDate,
+    scope,
+    sha256Hex(canonicalRequest)
+  ].join('\n');
+
+  const signingKey = getSignatureKey(secretAccessKey, dateStamp, region, service);
+  const signature = crypto.createHmac('sha256', signingKey).update(stringToSign).digest('hex');
+
+  headers['authorization'] =
+    `AWS4-HMAC-SHA256 Credential=${accessKeyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+
+  return headers;
+}
+
+function s3Request(method, url, body, config) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const headers = {
+      'host': parsed.host,
+      'content-type': 'application/octet-stream'
+    };
+
+    if (body) {
+      headers['content-length'] = String(Buffer.byteLength(body));
+    }
+
+    signV4(method, url, headers, body || '', config);
+
+    const transport = parsed.protocol === 'https:' ? https : http;
+    const req = transport.request(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+        path: parsed.pathname + parsed.search,
+        method,
+        headers
+      },
+      (res) => {
+        const chunks = [];
+        res.on('data', c => chunks.push(c));
+        res.on('end', () => {
+          resolve({
+            statusCode: res.statusCode,
+            headers: res.headers,
+            body: Buffer.concat(chunks)
+          });
+        });
+      }
+    );
+    req.on('error', reject);
+    req.setTimeout(30000, () => {
+      req.destroy(new Error('S3 request timeout'));
+    });
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+function buildS3Url(config, key) {
+  const endpoint = config.endpoint || `https://s3.${config.region}.amazonaws.com`;
+  const base = endpoint.replace(/\/+$/, '');
+  const prefix = config.prefix ? config.prefix.replace(/\/+$/, '') + '/' : '';
+  return `${base}/${config.bucket}/${prefix}${key}`;
+}
+
+class S3Provider {
+  constructor(config) {
+    this.config = config;
+    if (!config.bucket) throw new Error('S3 provider requires "bucket"');
+    if (!config.accessKeyId) throw new Error('S3 provider requires "accessKeyId"');
+    if (!config.secretAccessKey) throw new Error('S3 provider requires "secretAccessKey"');
+    if (!config.region) this.config.region = 'us-east-1';
+  }
+
+  async upload(key, buffer, contentType = 'application/octet-stream') {
+    const url = buildS3Url(this.config, key);
+    const res = await s3Request('PUT', url, buffer, this.config);
+    if (res.statusCode < 200 || res.statusCode >= 300) {
+      throw new Error(`S3 PUT failed (${res.statusCode}): ${res.body.toString().slice(0, 200)}`);
+    }
+    return { ok: true, key, etag: res.headers.etag || null };
+  }
+
+  async download(key) {
+    const url = buildS3Url(this.config, key);
+    const res = await s3Request('GET', url, null, this.config);
+    if (res.statusCode === 404) return null;
+    if (res.statusCode < 200 || res.statusCode >= 300) {
+      throw new Error(`S3 GET failed (${res.statusCode}): ${res.body.toString().slice(0, 200)}`);
+    }
+    return res.body;
+  }
+
+  async exists(key) {
+    const url = buildS3Url(this.config, key);
+    const res = await s3Request('HEAD', url, null, this.config);
+    return res.statusCode === 200;
+  }
+
+  async list(prefix) {
+    const fullPrefix = this.config.prefix
+      ? `${this.config.prefix.replace(/\/+$/, '')}/${prefix}`
+      : prefix;
+
+    const endpoint = this.config.endpoint || `https://s3.${this.config.region}.amazonaws.com`;
+    const base = endpoint.replace(/\/+$/, '');
+    const url = `${base}/${this.config.bucket}?list-type=2&prefix=${encodeURIComponent(fullPrefix)}&max-keys=1000`;
+    const res = await s3Request('GET', url, null, this.config);
+
+    if (res.statusCode < 200 || res.statusCode >= 300) {
+      throw new Error(`S3 LIST failed (${res.statusCode})`);
+    }
+
+    // Simple XML parse for Key elements
+    const xml = res.body.toString();
+    const items = [];
+    const keyRegex = /<Key>([^<]+)<\/Key>/g;
+    let match;
+    while ((match = keyRegex.exec(xml)) !== null) {
+      const itemKey = match[1];
+      // Strip provider prefix to return relative keys
+      const relKey = this.config.prefix
+        ? itemKey.replace(new RegExp(`^${this.config.prefix.replace(/\/+$/, '')}/`), '')
+        : itemKey;
+      items.push({ key: relKey });
+    }
+    return items;
+  }
+}
+
+// ── Custom HTTP provider ──
+
+function httpFetch(method, url, body, token) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const headers = {
+      'content-type': 'application/octet-stream'
+    };
+    if (token) {
+      headers['authorization'] = `Bearer ${token}`;
+    }
+    if (body) {
+      headers['content-length'] = String(Buffer.byteLength(body));
+    }
+
+    const transport = parsed.protocol === 'https:' ? https : http;
+    const req = transport.request(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+        path: parsed.pathname + parsed.search,
+        method,
+        headers
+      },
+      (res) => {
+        const chunks = [];
+        res.on('data', c => chunks.push(c));
+        res.on('end', () => {
+          resolve({
+            statusCode: res.statusCode,
+            headers: res.headers,
+            body: Buffer.concat(chunks)
+          });
+        });
+      }
+    );
+    req.on('error', reject);
+    req.setTimeout(30000, () => {
+      req.destroy(new Error('HTTP request timeout'));
+    });
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+class HttpProvider {
+  constructor(config) {
+    this.endpoint = (config.endpoint || '').replace(/\/+$/, '');
+    this.token = config.token || config.httpToken || null;
+    this.prefix = config.prefix ? config.prefix.replace(/\/+$/, '') + '/' : '';
+    if (!this.endpoint) throw new Error('HTTP provider requires "endpoint"');
+  }
+
+  _url(key) {
+    return `${this.endpoint}/${this.prefix}${key}`;
+  }
+
+  async upload(key, buffer, contentType = 'application/octet-stream') {
+    const res = await httpFetch('PUT', this._url(key), buffer, this.token);
+    if (res.statusCode < 200 || res.statusCode >= 300) {
+      throw new Error(`HTTP PUT failed (${res.statusCode}): ${res.body.toString().slice(0, 200)}`);
+    }
+    return { ok: true, key };
+  }
+
+  async download(key) {
+    const res = await httpFetch('GET', this._url(key), null, this.token);
+    if (res.statusCode === 404) return null;
+    if (res.statusCode < 200 || res.statusCode >= 300) {
+      throw new Error(`HTTP GET failed (${res.statusCode})`);
+    }
+    return res.body;
+  }
+
+  async exists(key) {
+    const res = await httpFetch('HEAD', this._url(key), null, this.token);
+    return res.statusCode === 200;
+  }
+
+  async list(prefix) {
+    const res = await httpFetch('GET', `${this._url(prefix)}?list=true`, null, this.token);
+    if (res.statusCode < 200 || res.statusCode >= 300) return [];
+    try {
+      return JSON.parse(res.body.toString());
+    } catch {
+      return [];
+    }
+  }
+}
+
+// ── Factory ──
+
+function createProvider(config) {
+  if (!config || !config.provider) {
+    throw new Error('Backup config missing "provider" field. Expected "s3" or "http".');
+  }
+  switch (config.provider) {
+    case 's3':
+      return new S3Provider(config);
+    case 'http':
+      return new HttpProvider(config);
+    default:
+      throw new Error(`Unknown backup provider: "${config.provider}". Use "s3" or "http".`);
+  }
+}
+
+function contentHash(data) {
+  return sha256Hex(typeof data === 'string' ? data : JSON.stringify(data));
+}
+
+module.exports = {
+  createProvider,
+  S3Provider,
+  HttpProvider,
+  contentHash,
+  sha256Hex
+};

package/src/cli.js

@@ -11,6 +11,7 @@ const { runDoctorCommand } = require('./commands/doctor');
 const { runI18nAdd } = require('./commands/i18n-add');
 const { runAgentsList, runAgentPrompt } = require('./commands/agents');
 const { runContextValidate } = require('./commands/context-validate');
+const { runContextPack } = require('./commands/context-pack');
 const { runSetupContext } = require('./commands/setup-context');
 const { runLocaleApply } = require('./commands/locale-apply');
 const { runSmokeTest } = require('./commands/smoke');
@@ -19,6 +20,7 @@ const { runMcpDoctor } = require('./commands/mcp-doctor');
 const { runPackageTest } = require('./commands/package-e2e');
 const { runWorkflowPlan } = require('./commands/workflow-plan');
 const { runWorkflowNext } = require('./commands/workflow-next');
+const { runWorkflowStatus } = require('./commands/workflow-status');
 const { runParallelInit } = require('./commands/parallel-init');
 const { runParallelDoctor } = require('./commands/parallel-doctor');
 const { runParallelAssign } = require('./commands/parallel-assign');
@@ -40,6 +42,12 @@ const { runSquadRepairGenomes } = require('./commands/squad-repair-genomes');
 const { runSquadValidate } = require('./commands/squad-validate');
 const { runSquadExport } = require('./commands/squad-export');
 const { runSquadPipeline } = require('./commands/squad-pipeline');
+const { runSquadAgentCreate } = require('./commands/squad-agent-create');
+const { runSquadInvestigate } = require('./commands/squad-investigate');
+const { runImplementationPlan } = require('./commands/implementation-plan');
+const { runSquadPlan } = require('./commands/squad-plan');
+const { runSquadLearning } = require('./commands/squad-learning');
+const { runLearning } = require('./commands/learning');
 const {
   runRuntimeInit,
   runRuntimeIngest,
@@ -51,14 +59,40 @@ const {
   runRuntimeTaskFail,
   runRuntimeFail,
   runRuntimeStatus,
-  runRuntimeLog
+  runRuntimeLog,
+  runRuntimeSessionStart,
+  runRuntimeSessionLog,
+  runRuntimeSessionFinish,
+  runRuntimeSessionStatus,
+  runDeliver,
+  runOutputStrategyExport,
+  runOutputStrategyImport,
+  runDevlogSync,
+  runRuntimePrune
 } = require('./commands/runtime');
+const {
+  runLiveStart,
+  runRuntimeEmit,
+  runLiveHandoff,
+  runLiveStatus,
+  runLiveClose,
+  runLiveList
+} = require('./commands/live');
 const {
   runCloudImportSquad,
   runCloudImportGenome,
   runCloudPublishGenome,
   runCloudPublishSquad
 } = require('./commands/cloud');
+const {
+  runRuntimeBackup,
+  runRuntimeRestore
+} = require('./commands/backup');
+const {
+  runSkillInstall,
+  runSkillList,
+  runSkillRemove
+} = require('./commands/skill');
 
 const JSON_SUPPORTED_COMMANDS = new Set([
   'init',
@@ -77,6 +111,8 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'doctor',
   'context:validate',
   'context-validate',
+  'context:pack',
+  'context-pack',
   'test:smoke',
   'test-smoke',
   'test:agents',
@@ -89,6 +125,8 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'workflow-plan',
   'workflow:next',
   'workflow-next',
+  'workflow:status',
+  'workflow-status',
   'agent:next',
   'agent-next',
   'parallel:init',
@@ -140,6 +178,24 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'squad-export',
   'squad:pipeline',
   'squad-pipeline',
+  'squad:agent-create',
+  'squad-agent-create',
+  'squad:investigate',
+  'squad-investigate',
+  'plan:show',
+  'plan:status',
+  'plan:checkpoint',
+  'plan:stale',
+  'plan:register',
+  'plan',
+  'squad:plan',
+  'squad-plan',
+  'squad:learning',
+  'squad-learning',
+  'learning',
+  'learning:list',
+  'learning:stats',
+  'learning:promote',
   'runtime:init',
   'runtime-init',
   'runtime:ingest',
@@ -162,6 +218,29 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'runtime-status',
   'runtime:log',
   'runtime-log',
+  'runtime:session:start',
+  'runtime-session-start',
+  'runtime:session:log',
+  'runtime-session-log',
+  'runtime:session:finish',
+  'runtime-session-finish',
+  'runtime:session:status',
+  'runtime-session-status',
+  'runtime:emit',
+  'runtime-emit',
+  'live:start',
+  'live-start',
+  'live:status',
+  'live-status',
+  'live:handoff',
+  'live-handoff',
+  'live:close',
+  'live-close',
+  'live:list',
+  'live-list',
+  'deliver',
+  'output-strategy:export',
+  'output-strategy:import',
   'cloud:import:squad',
   'cloud-import-squad',
   'cloud:import:genome',
@@ -170,6 +249,16 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'cloud-publish-squad',
   'cloud:publish:genome',
   'cloud-publish-genome',
+  'runtime:backup',
+  'runtime-backup',
+  'runtime:restore',
+  'runtime-restore',
+  'skill:install',
+  'skill-install',
+  'skill:list',
+  'skill-list',
+  'skill:remove',
+  'skill-remove',
   'version',
   '--version',
   '-v'
@@ -223,6 +312,7 @@ function printHelp(t, logger) {
   logHelpLine(t, logger, 'cli.help_agents');
   logHelpLine(t, logger, 'cli.help_agent_prompt');
   logHelpLine(t, logger, 'cli.help_context_validate');
+  logHelpLine(t, logger, 'cli.help_context_pack');
   logHelpLine(t, logger, 'cli.help_setup_context');
   logHelpLine(t, logger, 'cli.help_locale_apply');
   logHelpLine(t, logger, 'cli.help_locale_diff');
@@ -231,6 +321,7 @@ function printHelp(t, logger) {
   logHelpLine(t, logger, 'cli.help_test_package');
   logHelpLine(t, logger, 'cli.help_workflow_plan');
   logHelpLine(t, logger, 'cli.help_workflow_next');
+  logHelpLine(t, logger, 'cli.help_workflow_status');
   logHelpLine(t, logger, 'cli.help_parallel_init');
   logHelpLine(t, logger, 'cli.help_parallel_doctor');
   logHelpLine(t, logger, 'cli.help_parallel_assign');
@@ -252,6 +343,10 @@ function printHelp(t, logger) {
   logHelpLine(t, logger, 'cli.help_squad_validate');
   logHelpLine(t, logger, 'cli.help_squad_export');
   logHelpLine(t, logger, 'cli.help_squad_pipeline');
+  logHelpLine(t, logger, 'cli.help_squad_agent_create');
+  logHelpLine(t, logger, 'cli.help_squad_investigate');
+  logHelpLine(t, logger, 'cli.help_squad_learning');
+  logHelpLine(t, logger, 'cli.help_learning');
   logHelpLine(t, logger, 'cli.help_runtime_init');
   logHelpLine(t, logger, 'cli.help_runtime_ingest');
   logHelpLine(t, logger, 'cli.help_runtime_task_start');
@@ -262,6 +357,20 @@ function printHelp(t, logger) {
   logHelpLine(t, logger, 'cli.help_runtime_task_fail');
   logHelpLine(t, logger, 'cli.help_runtime_fail');
   logHelpLine(t, logger, 'cli.help_runtime_status');
+  logHelpLine(t, logger, 'cli.help_runtime_session_start');
+  logHelpLine(t, logger, 'cli.help_runtime_session_log');
+  logHelpLine(t, logger, 'cli.help_runtime_session_finish');
+  logHelpLine(t, logger, 'cli.help_runtime_session_status');
+  logHelpLine(t, logger, 'cli.help_runtime_emit');
+  logHelpLine(t, logger, 'cli.help_live_start');
+  logHelpLine(t, logger, 'cli.help_live_status');
+  logHelpLine(t, logger, 'cli.help_live_handoff');
+  logHelpLine(t, logger, 'cli.help_live_close');
+  logHelpLine(t, logger, 'cli.help_runtime_backup');
+  logHelpLine(t, logger, 'cli.help_runtime_restore');
+  logHelpLine(t, logger, 'cli.help_skill_install');
+  logHelpLine(t, logger, 'cli.help_skill_list');
+  logHelpLine(t, logger, 'cli.help_skill_remove');
   logHelpLine(t, logger, 'cli.help_cloud_import_squad');
   logHelpLine(t, logger, 'cli.help_cloud_import_genome');
   logHelpLine(t, logger, 'cli.help_cloud_publish_squad');
@@ -339,6 +448,8 @@ async function main() {
       result = await runAgentPrompt({ args, options, logger: commandLogger, t });
     } else if (command === 'context:validate' || command === 'context-validate') {
       result = await runContextValidate({ args, options, logger: commandLogger, t });
+    } else if (command === 'context:pack' || command === 'context-pack') {
+      result = await runContextPack({ args, options, logger: commandLogger, t });
     } else if (command === 'setup:context' || command === 'setup-context') {
       result = await runSetupContext({ args, options, logger: commandLogger, t });
     } else if (command === 'locale:apply' || command === 'locale-apply') {
@@ -359,7 +470,17 @@ async function main() {
       command === 'agent:next' ||
       command === 'agent-next'
     ) {
-      result = await runWorkflowNext({ args, options, logger: commandLogger, t });
+      // --status flag routes to workflow:status
+      if (options.status) {
+        result = await runWorkflowStatus({ args, options, logger: commandLogger, t });
+      } else {
+        result = await runWorkflowNext({ args, options, logger: commandLogger, t });
+      }
+    } else if (
+      command === 'workflow:status' ||
+      command === 'workflow-status'
+    ) {
+      result = await runWorkflowStatus({ args, options, logger: commandLogger, t });
     } else if (
       command === 'parallel:init' ||
       command === 'parallel-init' ||
@@ -422,6 +543,21 @@ async function main() {
       result = await runSquadExport({ args, options, logger: commandLogger, t });
     } else if (command === 'squad:pipeline' || command === 'squad-pipeline') {
       result = await runSquadPipeline({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:agent-create' || command === 'squad-agent-create') {
+      result = await runSquadAgentCreate({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:investigate' || command === 'squad-investigate') {
+      result = await runSquadInvestigate({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:plan' || command === 'squad-plan') {
+      result = await runSquadPlan({ args, options, logger: commandLogger, t });
+    } else if (command === 'squad:learning' || command === 'squad-learning') {
+      const sub = args[1] || 'list';
+      result = await runSquadLearning({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command.startsWith('learning:') || command === 'learning') {
+      const sub = command === 'learning' ? (args[1] || 'list') : command.split(':')[1];
+      result = await runLearning({ args, options: { ...options, sub }, logger: commandLogger, t });
+    } else if (command.startsWith('plan:') || command === 'plan') {
+      const sub = command === 'plan' ? (args[1] || 'show') : command.split(':')[1];
+      result = await runImplementationPlan({ args, options: { ...options, sub }, logger: commandLogger, t });
     } else if (command === 'runtime:init' || command === 'runtime-init') {
       result = await runRuntimeInit({ args, options, logger: commandLogger, t });
     } else if (command === 'runtime:ingest' || command === 'runtime-ingest') {
@@ -444,6 +580,46 @@ async function main() {
       result = await runRuntimeStatus({ args, options, logger: commandLogger, t });
     } else if (command === 'runtime:log' || command === 'runtime-log') {
       result = await runRuntimeLog({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:session:start' || command === 'runtime-session-start') {
+      result = await runRuntimeSessionStart({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:session:log' || command === 'runtime-session-log') {
+      result = await runRuntimeSessionLog({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:session:finish' || command === 'runtime-session-finish') {
+      result = await runRuntimeSessionFinish({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:session:status' || command === 'runtime-session-status') {
+      result = await runRuntimeSessionStatus({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:emit' || command === 'runtime-emit') {
+      result = await runRuntimeEmit({ args, options, logger: commandLogger, t });
+    } else if (command === 'live:start' || command === 'live-start') {
+      result = await runLiveStart({ args, options, logger: commandLogger, t });
+    } else if (command === 'live:status' || command === 'live-status') {
+      result = await runLiveStatus({ args, options, logger: commandLogger, t });
+    } else if (command === 'live:handoff' || command === 'live-handoff') {
+      result = await runLiveHandoff({ args, options, logger: commandLogger, t });
+    } else if (command === 'live:close' || command === 'live-close') {
+      result = await runLiveClose({ args, options, logger: commandLogger, t });
+    } else if (command === 'live:list' || command === 'live-list') {
+      result = await runLiveList({ args, options, logger: commandLogger, t });
+    } else if (command === 'deliver') {
+      result = await runDeliver({ args, options, logger: commandLogger, t });
+    } else if (command === 'output-strategy:export') {
+      result = await runOutputStrategyExport({ args, options, logger: commandLogger, t });
+    } else if (command === 'output-strategy:import') {
+      result = await runOutputStrategyImport({ args, options, logger: commandLogger, t });
+    } else if (command === 'devlog:sync' || command === 'devlog-sync') {
+      result = await runDevlogSync({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:prune' || command === 'runtime-prune') {
+      result = await runRuntimePrune({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:backup' || command === 'runtime-backup') {
+      result = await runRuntimeBackup({ args, options, logger: commandLogger, t });
+    } else if (command === 'runtime:restore' || command === 'runtime-restore') {
+      result = await runRuntimeRestore({ args, options, logger: commandLogger, t });
+    } else if (command === 'skill:install' || command === 'skill-install') {
+      result = await runSkillInstall({ args, options, logger: commandLogger, t });
+    } else if (command === 'skill:list' || command === 'skill-list') {
+      result = await runSkillList({ args, options, logger: commandLogger, t });
+    } else if (command === 'skill:remove' || command === 'skill-remove') {
+      result = await runSkillRemove({ args, options, logger: commandLogger, t });
     } else if (command === 'cloud:import:squad' || command === 'cloud-import-squad') {
       result = await runCloudImportSquad({ args, options, logger: commandLogger, t });
     } else if (command === 'cloud:import:genome' || command === 'cloud-import-genome') {

package/src/commands/agents.js

@@ -17,6 +17,18 @@ const {
   classifyDirectAgentRuntime
 } = require('../execution-gateway');
 
+const WORKFLOW_AGENT_IDS = new Set([
+  'setup',
+  'product',
+  'analyst',
+  'architect',
+  'ux-ui',
+  'pm',
+  'orchestrator',
+  'dev',
+  'qa'
+]);
+
 async function resolveLocaleForTarget(targetDir, options) {
   const fromOption = options.language || options.lang;
   if (fromOption) return resolveAgentLocale(fromOption);
@@ -44,7 +56,13 @@ async function runAgentsList({ args, options, logger, t }) {
   for (const agent of agents) {
     const deps = agent.dependsOn.length > 0 ? agent.dependsOn.join(', ') : t('agents.none');
     const instructionPath = await resolveExistingInstructionPath(targetDir, agent, locale);
-    logger.log(t('agents.agent_line', { command: agent.command, id: agent.id }));
+    logger.log(
+      t('agents.agent_line', {
+        label: agent.displayName || agent.id,
+        command: agent.command,
+        id: agent.id
+      })
+    );
     logger.log(t('agents.path_line', { path: instructionPath }));
     logger.log(t('agents.active_path_line', { path: agent.path }));
     logger.log(t('agents.depends_line', { value: deps }));
@@ -76,10 +94,10 @@ async function runAgentPrompt({ args, options, logger, t }) {
   let instructionPath = null;
   let prompt = null;
 
-  const context = await validateProjectContextFile(targetDir);
-  if (context.valid) {
+  if (WORKFLOW_AGENT_IDS.has(requestedAgent)) {
     const loaded = await loadOrCreateState(targetDir, options);
-    if (loaded.state.sequence.includes(requestedAgent)) {
+    const hasWorkflowStage = Boolean(loaded.state.current || loaded.state.next || loaded.state.sequence.length > 0);
+    if (hasWorkflowStage) {
       const workflowResult = await runWorkflowNext({
         args: [targetDir],
         options: {