@orchagent/cli 0.3.90 → 0.3.92

package/dist/commands/scaffold.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerScaffoldCommand = registerScaffoldCommand;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const agent_ref_1 = require("../lib/agent-ref");
+const errors_1 = require("../lib/errors");
+const analytics_1 = require("../lib/analytics");
+const output_1 = require("../lib/output");
+const scaffold_orchestration_1 = require("../lib/scaffold-orchestration");
+async function fileExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function asCanonicalType(value) {
+    const normalized = String(value || 'agent').trim().toLowerCase();
+    if (normalized === 'agentic')
+        return 'agent';
+    if (normalized === 'code')
+        return 'tool';
+    return normalized;
+}
+function asObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function formatDependencyNotFound(org, agent, version) {
+    return `Dependency agent not found: ${org}/${agent}@${version}`;
+}
+function throwDependencyResolutionError(err, org, agent, version) {
+    if (err instanceof api_1.ApiError) {
+        if (err.status === 404) {
+            throw new errors_1.CliError(formatDependencyNotFound(org, agent, version));
+        }
+        if (err.status === 401) {
+            throw new errors_1.CliError(`Authentication required to resolve ${org}/${agent}@${version}. Run \`orch login\` first.`);
+        }
+        throw new errors_1.CliError(`Failed to resolve ${org}/${agent}@${version}: ${err.message} (HTTP ${err.status})`);
+    }
+    throw err;
+}
+function assertDependencyIsCallable(agent, org, name, version) {
+    const canonicalType = asCanonicalType(agent.type);
+    if (canonicalType === 'skill') {
+        throw new errors_1.CliError(`Dependency ${org}/${name}@${version} is a skill. Skills are not callable agents.`);
+    }
+    if (agent.callable === false) {
+        throw new errors_1.CliError(`Dependency ${org}/${name}@${version} has callable: false and cannot be used for orchestration.`);
+    }
+}
+async function resolveDependencies(config, rawRefs) {
+    const workspaceByOrg = new Map();
+    const workspaceForOrg = async (org) => {
+        if (!workspaceByOrg.has(org)) {
+            workspaceByOrg.set(org, (0, api_1.resolveWorkspaceIdForOrg)(config, org).catch(() => undefined));
+        }
+        return workspaceByOrg.get(org);
+    };
+    const resolved = await Promise.all(rawRefs.map(async (rawRef) => {
+        const parsed = (0, agent_ref_1.parseAgentRef)(rawRef);
+        const org = parsed.org || config.defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError(`Missing org in '${rawRef}'. Use org/agent[@version] format or set default org with \`orch config set default_org <org>\`.`);
+        }
+        const workspaceId = await workspaceForOrg(org);
+        let depAgent;
+        try {
+            depAgent = await (0, api_1.getAgentWithFallback)(config, org, parsed.agent, parsed.version, workspaceId);
+        }
+        catch (err) {
+            throwDependencyResolutionError(err, org, parsed.agent, parsed.version);
+        }
+        const pinnedVersion = depAgent.version || parsed.version;
+        assertDependencyIsCallable(depAgent, org, parsed.agent, pinnedVersion);
+        return {
+            org,
+            name: parsed.agent,
+            version: pinnedVersion,
+            description: typeof depAgent.description === 'string' ? depAgent.description : undefined,
+            inputSchema: asObject(depAgent.input_schema),
+        };
+    }));
+    const deduped = (0, scaffold_orchestration_1.dedupeOrchestrationDependencies)(resolved);
+    if (deduped.conflicts.length > 0) {
+        const details = deduped.conflicts
+            .map((conflict) => `- ${conflict.id}: ${conflict.versions.join(', ')}`)
+            .join('\n');
+        throw new errors_1.CliError(`Conflicting dependency versions provided:\n${details}\nUse a single version per dependency.`);
+    }
+    return {
+        dependencies: deduped.dependencies,
+        duplicates: deduped.duplicates,
+    };
+}
+async function ensureOutputDirectory(outputDir) {
+    const exists = await fileExists(outputDir);
+    if (!exists) {
+        await promises_1.default.mkdir(outputDir, { recursive: true });
+        return;
+    }
+    const stat = await promises_1.default.stat(outputDir);
+    if (!stat.isDirectory()) {
+        throw new errors_1.CliError(`Output path exists but is not a directory: ${outputDir}`);
+    }
+}
+function registerScaffoldCommand(program) {
+    const scaffold = program
+        .command('scaffold')
+        .description('Scaffold projects from existing agents')
+        .action(() => { scaffold.help(); });
+    scaffold
+        .command('orchestration <agents...>')
+        .description('Generate a managed-loop orchestrator scaffold from published dependency agents')
+        .option('--profile <name>', 'Use API key from named profile')
+        .option('--name <name>', 'Orchestrator name (default: output directory name)')
+        .option('--output <dir>', 'Output directory (default: current directory)')
+        .option('--force', 'Overwrite existing scaffold files')
+        .option('--json', 'Print scaffold summary as JSON')
+        .action(async (agents, options) => {
+        const config = await (0, config_1.getResolvedConfig)({}, options.profile);
+        const outputDir = path_1.default.resolve(options.output || process.cwd());
+        await ensureOutputDirectory(outputDir);
+        const manifestName = (options.name || path_1.default.basename(outputDir)).trim();
+        const nameErrors = (0, scaffold_orchestration_1.validateScaffoldAgentName)(manifestName);
+        if (nameErrors.length > 0) {
+            throw new errors_1.CliError(nameErrors.join('\n'));
+        }
+        const manifestPath = path_1.default.join(outputDir, 'orchagent.json');
+        const promptPath = path_1.default.join(outputDir, 'prompt.md');
+        const schemaPath = path_1.default.join(outputDir, 'schema.json');
+        const targetFiles = [manifestPath, promptPath, schemaPath];
+        if (!options.force) {
+            const existing = (await Promise.all(targetFiles.map(async (filePath) => (await fileExists(filePath) ? filePath : null)))).filter((filePath) => Boolean(filePath));
+            if (existing.length > 0) {
+                const rel = existing.map((f) => path_1.default.relative(outputDir, f));
+                throw new errors_1.CliError(`Refusing to overwrite existing files in ${outputDir}: ${rel.join(', ')}. Re-run with --force to overwrite.`);
+            }
+        }
+        const { dependencies, duplicates } = await resolveDependencies(config, agents);
+        if (dependencies.length === 0) {
+            throw new errors_1.CliError('No dependency agents were resolved.');
+        }
+        const customTools = (0, scaffold_orchestration_1.buildOrchestrationCustomTools)(dependencies);
+        const manifest = (0, scaffold_orchestration_1.buildOrchestrationManifest)({
+            name: manifestName,
+            dependencies,
+            customTools,
+        });
+        const prompt = (0, scaffold_orchestration_1.buildOrchestrationPrompt)({
+            name: manifestName,
+            dependencies,
+            customTools,
+        });
+        const schema = (0, scaffold_orchestration_1.buildOrchestrationSchema)();
+        await promises_1.default.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+        await promises_1.default.writeFile(promptPath, prompt);
+        await promises_1.default.writeFile(schemaPath, JSON.stringify(schema, null, 2) + '\n');
+        await (0, analytics_1.track)('cli_scaffold_orchestration', {
+            dependency_count: dependencies.length,
+            duplicates_removed: duplicates.length,
+            output_custom: Boolean(options.output),
+            force: Boolean(options.force),
+            json: Boolean(options.json),
+        });
+        if (options.json) {
+            (0, output_1.printJson)({
+                name: manifestName,
+                output_dir: outputDir,
+                dependencies: dependencies.map((dep) => (0, scaffold_orchestration_1.dependencyRef)(dep)),
+                custom_tools: customTools.map((tool) => tool.name),
+                files: ['orchagent.json', 'prompt.md', 'schema.json'],
+                duplicates_removed: duplicates,
+            });
+            return;
+        }
+        process.stdout.write(`Scaffolded orchestrator "${manifestName}" in ${outputDir}\n`);
+        process.stdout.write('\nDependencies:\n');
+        for (const dep of dependencies) {
+            process.stdout.write(`  - ${(0, scaffold_orchestration_1.dependencyRef)(dep)}\n`);
+        }
+        if (duplicates.length > 0) {
+            process.stdout.write('\nRemoved duplicate dependency refs:\n');
+            for (const dup of duplicates) {
+                process.stdout.write(`  - ${dup}\n`);
+            }
+        }
+        process.stdout.write('\nFiles written:\n');
+        process.stdout.write('  - orchagent.json\n');
+        process.stdout.write('  - prompt.md\n');
+        process.stdout.write('  - schema.json\n');
+        process.stdout.write('\nNext steps:\n');
+        if (path_1.default.resolve(outputDir) !== path_1.default.resolve(process.cwd())) {
+            process.stdout.write(`  1. cd ${outputDir}\n`);
+            process.stdout.write('  2. Review prompt.md and schema.json\n');
+            process.stdout.write('  3. Publish: orch publish\n');
+        }
+        else {
+            process.stdout.write('  1. Review prompt.md and schema.json\n');
+            process.stdout.write('  2. Publish: orch publish\n');
+        }
+    });
+}

package/dist/commands/schedule.js

@@ -19,15 +19,24 @@ const api_2 = require("../lib/api");
 async function resolveWorkspaceId(config, slug) {
     const configFile = await (0, config_1.loadConfig)();
     const targetSlug = slug ?? configFile.workspace;
-    if (!targetSlug) {
-        throw new errors_1.CliError('No workspace specified. Use --workspace <slug> or run `orch workspace use <slug>` first.');
-    }
     const response = await (0, api_1.request)(config, 'GET', '/workspaces');
-    const workspace = response.workspaces.find((w) => w.slug === targetSlug);
-    if (!workspace) {
-        throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+    if (targetSlug) {
+        const workspace = response.workspaces.find((w) => w.slug === targetSlug);
+        if (!workspace) {
+            throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+        }
+        return workspace.id;
+    }
+    // No workspace specified — auto-select if user has exactly one
+    if (response.workspaces.length === 0) {
+        throw new errors_1.CliError('No workspaces found. Create one with `orch workspace create <name>`.');
     }
-    return workspace.id;
+    if (response.workspaces.length === 1) {
+        return response.workspaces[0].id;
+    }
+    const slugs = response.workspaces.map((w) => w.slug).join(', ');
+    throw new errors_1.CliError(`Multiple workspaces available: ${slugs}\n` +
+        'Specify one with --workspace <slug> or run `orch workspace use <slug>`.');
 }
 function formatDate(iso) {
     if (!iso)
@@ -148,6 +157,8 @@ function registerScheduleCommand(program) {
         .option('--input <json>', 'Input data as JSON string')
         .option('--provider <provider>', 'LLM provider (anthropic, openai, gemini)')
         .option('--pin-version', 'Pin to this version (disable auto-update on publish)')
+        .option('--alert-webhook <url>', 'Webhook URL to POST on failure (HTTPS required)')
+        .option('--alert-on-failure-count <n>', 'Number of consecutive failures before alerting (default: 3)', parseInt)
         .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
         .action(async (agentArg, options) => {
         const config = await (0, config_1.getResolvedConfig)();
@@ -162,8 +173,13 @@ function registerScheduleCommand(program) {
         }
         const workspaceId = await resolveWorkspaceId(config, options.workspace);
         const ref = (0, agent_ref_1.parseAgentRef)(agentArg);
+        const configFile = await (0, config_1.loadConfig)();
+        const org = ref.org ?? configFile.workspace ?? config.defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError('Missing org. Use org/agent format or set default org.');
+        }
         // Resolve agent to get the ID (pass workspace context for private agents)
-        const agent = await (0, api_2.getAgentWithFallback)(config, ref.org, ref.agent, ref.version, workspaceId);
+        const agent = await (0, api_2.getAgentWithFallback)(config, org, ref.agent, ref.version, workspaceId);
         // Parse input data
         let inputData;
         if (options.input) {
@@ -190,6 +206,10 @@ function registerScheduleCommand(program) {
             body.llm_provider = options.provider;
         if (options.pinVersion)
             body.auto_update = false;
+        if (options.alertWebhook)
+            body.alert_webhook_url = options.alertWebhook;
+        if (options.alertOnFailureCount)
+            body.alert_on_failure_count = options.alertOnFailureCount;
         const result = await (0, api_1.request)(config, 'POST', `/workspaces/${workspaceId}/schedules`, {
             body: JSON.stringify(body),
             headers: { 'Content-Type': 'application/json' },
@@ -210,13 +230,17 @@ function registerScheduleCommand(program) {
         }
         else {
             if (s.webhook_url) {
-                process.stdout.write(`\n  ${chalk_1.default.bold('Webhook URL')} (save this — secret shown once):\n`);
+                process.stdout.write(`\n  ${chalk_1.default.bold('Webhook URL')} (save this — retrieve later with ${chalk_1.default.cyan('orch schedule info --reveal')}):\n`);
                 process.stdout.write(`  ${s.webhook_url}\n`);
             }
         }
         if (s.llm_provider) {
             process.stdout.write(`  Provider:    ${s.llm_provider}\n`);
         }
+        if (s.alert_webhook_url) {
+            process.stdout.write(`  Alert URL:   ${s.alert_webhook_url}\n`);
+            process.stdout.write(`  Alert after: ${s.alert_on_failure_count ?? 3} consecutive failures\n`);
+        }
         process.stdout.write('\n');
     });
     // orch schedule update <schedule-id>
@@ -231,6 +255,9 @@ function registerScheduleCommand(program) {
         .option('--disable', 'Disable the schedule')
         .option('--auto-update', 'Enable auto-update on publish')
         .option('--pin-version', 'Pin to current version (disable auto-update)')
+        .option('--alert-webhook <url>', 'Webhook URL to POST on failure (HTTPS required)')
+        .option('--alert-on-failure-count <n>', 'Number of consecutive failures before alerting', parseInt)
+        .option('--clear-alert-webhook', 'Remove the alert webhook URL')
         .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
         .action(async (scheduleId, options) => {
         const config = await (0, config_1.getResolvedConfig)();
@@ -243,6 +270,9 @@ function registerScheduleCommand(program) {
         if (options.autoUpdate && options.pinVersion) {
             throw new errors_1.CliError('Cannot use both --auto-update and --pin-version');
         }
+        if (options.alertWebhook && options.clearAlertWebhook) {
+            throw new errors_1.CliError('Cannot use both --alert-webhook and --clear-alert-webhook');
+        }
         const workspaceId = await resolveWorkspaceId(config, options.workspace);
         const updates = {};
         if (options.cron)
@@ -259,6 +289,12 @@ function registerScheduleCommand(program) {
             updates.auto_update = true;
         if (options.pinVersion)
             updates.auto_update = false;
+        if (options.alertWebhook)
+            updates.alert_webhook_url = options.alertWebhook;
+        if (options.alertOnFailureCount)
+            updates.alert_on_failure_count = options.alertOnFailureCount;
+        if (options.clearAlertWebhook)
+            updates.alert_webhook_url = '';
         if (options.input) {
             try {
                 updates.input_data = JSON.parse(options.input);
@@ -285,6 +321,13 @@ function registerScheduleCommand(program) {
         if (s.next_run_at) {
             process.stdout.write(`  Next:    ${formatDate(s.next_run_at)}\n`);
         }
+        if (s.alert_webhook_url) {
+            process.stdout.write(`  Alert:   ${s.alert_webhook_url}\n`);
+            process.stdout.write(`  After:   ${s.alert_on_failure_count ?? 3} failures\n`);
+        }
+        else if (options.clearAlertWebhook) {
+            process.stdout.write(`  Alert:   ${chalk_1.default.gray('removed')}\n`);
+        }
         process.stdout.write('\n');
     });
     // orch schedule delete <schedule-id>
@@ -401,8 +444,11 @@ function registerScheduleCommand(program) {
         if (s.webhook_url) {
             process.stdout.write(`  Webhook:    ${s.webhook_url}\n`);
         }
-        else if (s.schedule_type === 'webhook' && !options.reveal) {
-            process.stdout.write(`  Webhook:    ${chalk_1.default.gray('(redacted — use --reveal to show)')}\n`);
+        else if (s.schedule_type === 'webhook' && options.reveal) {
+            process.stdout.write(`  Webhook:    ${chalk_1.default.red('Failed to reveal — you may need owner permissions')}\n`);
+        }
+        else if (s.schedule_type === 'webhook') {
+            process.stdout.write(`  Webhook:    ${chalk_1.default.gray('(redacted — use --reveal to show, or regenerate-webhook if lost)')}\n`);
         }
         process.stdout.write(`  Enabled:    ${s.enabled ? chalk_1.default.green('yes') : chalk_1.default.red('no')}\n`);
         process.stdout.write(`  Auto-update: ${s.auto_update === false ? chalk_1.default.yellow('pinned') : chalk_1.default.green('yes')}\n`);
@@ -498,4 +544,59 @@ function registerScheduleCommand(program) {
         process.stdout.write(`${table.toString()}\n`);
         process.stdout.write(chalk_1.default.gray(`\n${result.total} run${result.total !== 1 ? 's' : ''} total\n`));
     });
+    // orch schedule test-alert <schedule-id>
+    schedule
+        .command('test-alert <schedule-id>')
+        .description('Send a test alert to the schedule\'s configured webhook URL')
+        .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
+        .action(async (partialScheduleId, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orch login` first.');
+        }
+        const workspaceId = await resolveWorkspaceId(config, options.workspace);
+        const scheduleId = await resolveScheduleId(config, partialScheduleId, workspaceId);
+        process.stdout.write('Sending test alert...\n');
+        const result = await (0, api_1.request)(config, 'POST', `/workspaces/${workspaceId}/schedules/${scheduleId}/test-alert`);
+        if (result.success) {
+            process.stdout.write(chalk_1.default.green('\u2713') + ' Test alert delivered successfully\n');
+        }
+        else {
+            process.stdout.write(chalk_1.default.red('\u2717') + ' Test alert delivery failed\n');
+        }
+    });
+    // orch schedule regenerate-webhook <schedule-id>
+    schedule
+        .command('regenerate-webhook <schedule-id>')
+        .description('Regenerate the webhook secret (invalidates old URL)')
+        .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .action(async (partialScheduleId, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orch login` first.');
+        }
+        const workspaceId = await resolveWorkspaceId(config, options.workspace);
+        const scheduleId = await resolveScheduleId(config, partialScheduleId, workspaceId);
+        if (!options.yes) {
+            const rl = promises_1.default.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const answer = await rl.question(chalk_1.default.yellow('Warning: This will invalidate the current webhook URL.\n') +
+                'Any integrations using the old URL will stop working.\n' +
+                'Regenerate webhook secret? (y/N): ');
+            rl.close();
+            if (answer.trim().toLowerCase() !== 'y' && answer.trim().toLowerCase() !== 'yes') {
+                process.stdout.write('Cancelled.\n');
+                return;
+            }
+        }
+        const result = await (0, api_1.request)(config, 'POST', `/workspaces/${workspaceId}/schedules/${scheduleId}/regenerate-webhook`);
+        process.stdout.write(chalk_1.default.green('\u2713') + ' Webhook secret regenerated\n\n');
+        process.stdout.write(`  ${chalk_1.default.bold('New Webhook URL')} (save this — retrieve later with ${chalk_1.default.cyan('orch schedule info --reveal')}):\n`);
+        process.stdout.write(`  ${result.webhook_url}\n\n`);
+        process.stdout.write(chalk_1.default.yellow('  The old webhook URL no longer works.\n'));
+        process.stdout.write('\n');
+    });
 }

package/dist/commands/secrets.js

@@ -17,15 +17,24 @@ const SECRET_NAME_REGEX = /^[A-Z][A-Z0-9_]*$/;
 async function resolveWorkspaceId(config, slug) {
     const configFile = await (0, config_1.loadConfig)();
     const targetSlug = slug ?? configFile.workspace;
-    if (!targetSlug) {
-        throw new errors_1.CliError('No workspace specified. Use --workspace <slug> or run `orch workspace use <slug>` first.');
-    }
     const response = await (0, api_1.request)(config, 'GET', '/workspaces');
-    const workspace = response.workspaces.find((w) => w.slug === targetSlug);
-    if (!workspace) {
-        throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+    if (targetSlug) {
+        const workspace = response.workspaces.find((w) => w.slug === targetSlug);
+        if (!workspace) {
+            throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+        }
+        return workspace.id;
+    }
+    // No workspace specified — auto-select if user has exactly one
+    if (response.workspaces.length === 0) {
+        throw new errors_1.CliError('No workspaces found. Create one with `orch workspace create <name>`.');
+    }
+    if (response.workspaces.length === 1) {
+        return response.workspaces[0].id;
     }
-    return workspace.id;
+    const slugs = response.workspaces.map((w) => w.slug).join(', ');
+    throw new errors_1.CliError(`Multiple workspaces available: ${slugs}\n` +
+        'Specify one with --workspace <slug> or run `orch workspace use <slug>`.');
 }
 function formatDate(iso) {
     if (!iso)

package/dist/commands/service.js

@@ -17,15 +17,24 @@ const spinner_1 = require("../lib/spinner");
 async function resolveWorkspaceId(config, slug) {
     const configFile = await (0, config_1.loadConfig)();
     const targetSlug = slug ?? configFile.workspace;
-    if (!targetSlug) {
-        throw new errors_1.CliError('No workspace specified. Use --workspace <slug> or run `orch workspace use <slug>` first.');
-    }
     const response = await (0, api_1.request)(config, 'GET', '/workspaces');
-    const workspace = response.workspaces.find((w) => w.slug === targetSlug);
-    if (!workspace) {
-        throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+    if (targetSlug) {
+        const workspace = response.workspaces.find((w) => w.slug === targetSlug);
+        if (!workspace) {
+            throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+        }
+        return workspace.id;
+    }
+    // No workspace specified — auto-select if user has exactly one
+    if (response.workspaces.length === 0) {
+        throw new errors_1.CliError('No workspaces found. Create one with `orch workspace create <name>`.');
+    }
+    if (response.workspaces.length === 1) {
+        return response.workspaces[0].id;
     }
-    return workspace.id;
+    const slugs = response.workspaces.map((w) => w.slug).join(', ');
+    throw new errors_1.CliError(`Multiple workspaces available: ${slugs}\n` +
+        'Specify one with --workspace <slug> or run `orch workspace use <slug>`.');
 }
 function formatDate(iso) {
     if (!iso)

package/dist/commands/skill.js

@@ -40,11 +40,13 @@ exports.registerSkillCommand = registerSkillCommand;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const errors_1 = require("../lib/errors");
 const analytics_1 = require("../lib/analytics");
 const installed_1 = require("../lib/installed");
+const agents_1 = require("./agents");
 const package_json_1 = __importDefault(require("../../package.json"));
 const DEFAULT_VERSION = 'latest';
 function stripFrontmatter(content) {
@@ -208,15 +210,89 @@ function registerSkillCommand(program) {
     // orch skill list
     skill
         .command('list')
-        .description('Browse available skills')
+        .description('List your published and installed skills')
         .option('--json', 'Output raw JSON')
-        .action(async () => {
-        process.stdout.write('Install a skill:\n' +
-            '  orch skill install <org>/<skill-name>\n\n' +
-            'View installed skills:\n' +
-            '  orch update --check\n\n' +
-            'Learn more: https://docs.orchagent.io/skills\n');
-        process.exit(0);
+        .action(async (options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        const jsonMode = options.json === true;
+        // Fetch published skills (only if authenticated)
+        let publishedSkills = [];
+        if (config.apiKey) {
+            const configFile = await (0, config_1.loadConfig)();
+            const orgSlug = configFile.workspace ?? config.defaultOrg;
+            const workspaceId = orgSlug ? await (0, api_1.resolveWorkspaceIdForOrg)(config, orgSlug) : undefined;
+            const allAgents = await (0, api_1.listMyAgents)(config, workspaceId);
+            publishedSkills = allAgents.filter(a => a.type === 'skill');
+        }
+        // Fetch locally installed skills
+        const installed = await (0, installed_1.getInstalled)();
+        // JSON output
+        if (jsonMode) {
+            const { agents: latestSkills } = (0, agents_1.latestOnly)(publishedSkills);
+            process.stdout.write(JSON.stringify({
+                published: latestSkills,
+                installed,
+            }, null, 2) + '\n');
+            return;
+        }
+        // Empty state
+        if (publishedSkills.length === 0 && installed.length === 0) {
+            process.stdout.write('No skills found.\n\n' +
+                'Install a skill:\n' +
+                '  orch skill install <org>/<skill-name>\n\n' +
+                'Create a skill:\n' +
+                '  orch skill create <name>\n');
+            return;
+        }
+        // Published skills table
+        if (publishedSkills.length > 0) {
+            const { agents: latestSkills, versionCounts } = (0, agents_1.latestOnly)(publishedSkills);
+            const Table = (await Promise.resolve().then(() => __importStar(require('cli-table3')))).default;
+            const table = new Table({
+                head: [
+                    chalk_1.default.bold('Skill'),
+                    chalk_1.default.bold('Version'),
+                    chalk_1.default.bold('Description'),
+                ],
+            });
+            for (const skill of latestSkills) {
+                const desc = skill.description
+                    ? skill.description.length > 60
+                        ? skill.description.slice(0, 57) + '...'
+                        : skill.description
+                    : '-';
+                let version = skill.version;
+                const count = versionCounts.get(skill.name) ?? 1;
+                if (count > 1) {
+                    version = `${skill.version} (${count} total)`;
+                }
+                table.push([skill.name, version, desc]);
+            }
+            process.stdout.write(`Published Skills\n${table.toString()}\n`);
+            process.stdout.write(`\n${latestSkills.length} skill${latestSkills.length === 1 ? '' : 's'}`);
+            if (publishedSkills.length > latestSkills.length) {
+                process.stdout.write(` (${publishedSkills.length} versions total)`);
+            }
+            process.stdout.write('\n');
+        }
+        // Installed skills table
+        if (installed.length > 0) {
+            const Table = (await Promise.resolve().then(() => __importStar(require('cli-table3')))).default;
+            const table = new Table({
+                head: [
+                    chalk_1.default.bold('Skill'),
+                    chalk_1.default.bold('Version'),
+                    chalk_1.default.bold('Tool'),
+                    chalk_1.default.bold('Scope'),
+                ],
+            });
+            for (const entry of installed) {
+                table.push([entry.agent, entry.version, entry.format, entry.scope]);
+            }
+            if (publishedSkills.length > 0)
+                process.stdout.write('\n');
+            process.stdout.write(`Installed Skills\n${table.toString()}\n`);
+        }
     });
     // orch skill create [name]
     skill