@orchagent/cli 0.3.94 → 0.3.96

package/dist/commands/dag.js

@@ -217,7 +217,9 @@ function registerDagCommand(program) {
             spinner.stop();
             const msg = e instanceof Error ? e.message : 'Unknown error';
             if (msg.includes('404') || msg.includes('not found') || msg.includes('Not part of')) {
-                throw new errors_1.CliError(`Run ${resolvedRunId.slice(0, 8)}... is not part of an orchestration chain.`);
+                throw new errors_1.CliError(`Run ${resolvedRunId.slice(0, 8)}... is not part of an orchestration chain.\n\n` +
+                    `The DAG view is only available for runs that call other agents via the SDK.\n` +
+                    `Verify that your agent uses the Orchestrator SDK to invoke other agents.`);
             }
             throw e;
         }

package/dist/commands/fork.js

@@ -33,6 +33,24 @@ async function resolveWorkspace(config, workspaceSlug) {
     }
     return workspace;
 }
+async function resolveCurrentWorkspace(config) {
+    const configFile = await (0, config_1.loadConfig)();
+    const response = await (0, api_1.request)(config, 'GET', '/workspaces');
+    // If user has a default workspace configured, use it
+    if (configFile.workspace) {
+        const workspace = response.workspaces.find((w) => w.slug === configFile.workspace);
+        if (workspace) {
+            return workspace;
+        }
+    }
+    // If only one workspace, use it
+    if (response.workspaces.length === 1) {
+        return response.workspaces[0];
+    }
+    // Multiple workspaces and no default — this shouldn't happen in fork flow,
+    // but if we get here, throw an error
+    throw new errors_1.CliError('Multiple workspaces available. Use `orch workspace use <slug>` to set default or `--workspace <slug>` to specify.');
+}
 function registerForkCommand(program) {
     program
         .command('fork <agent>')
@@ -101,7 +119,23 @@ Examples:
             return;
         }
         const forked = result.agent;
-        const targetOrgSlug = forked.org_slug ?? targetWorkspace?.slug ?? 'current-workspace';
+        // Resolve the target workspace slug:
+        // 1. If org_slug is in response, use it (gateway knows what org it created the agent in)
+        // 2. If explicit --workspace was provided, use its slug
+        // 3. Otherwise, resolve current workspace
+        let targetOrgSlug;
+        if (forked.org_slug) {
+            targetOrgSlug = forked.org_slug;
+        }
+        else if (targetWorkspace) {
+            targetOrgSlug = targetWorkspace.slug;
+        }
+        else {
+            write('Resolving current workspace...\n');
+            const currentWorkspace = await resolveCurrentWorkspace(config);
+            targetOrgSlug = currentWorkspace.slug;
+            targetWorkspace = currentWorkspace;
+        }
         write(`\n${chalk_1.default.green('\u2713')} Forked ${org}/${agent}@${version}\n`);
         write(`  New agent: ${targetOrgSlug}/${forked.name}@${forked.version}\n`);
         if (targetWorkspace) {

package/dist/commands/logs.js

@@ -31,7 +31,12 @@ async function resolveWorkspaceId(config, slug) {
     if (response.workspaces.length === 1) {
         return response.workspaces[0].id;
     }
-    // Multiple workspaces — list them and ask the user to pick
+    // Multiple workspaces — try to default to personal workspace
+    const personalWorkspace = response.workspaces.find((w) => w.type === 'personal');
+    if (personalWorkspace) {
+        return personalWorkspace.id;
+    }
+    // Multiple workspaces and no personal workspace found — ask the user to pick
     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>`.');

package/dist/commands/run.js

@@ -37,6 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localCommandForEntrypoint = localCommandForEntrypoint;
+exports.canonicalAgentType = canonicalAgentType;
 exports.inferFileField = inferFileField;
 exports.validateInputSchema = validateInputSchema;
 exports.tryParseJsonObject = tryParseJsonObject;
@@ -97,7 +98,21 @@ function parseAgentRef(value) {
 }
 function canonicalAgentType(typeValue) {
     const normalized = (typeValue || 'agent').toLowerCase();
-    return normalized === 'skill' ? 'skill' : 'agent';
+    // Handle legacy type names: agentic → agent, code → tool
+    if (normalized === 'agentic')
+        return 'agent';
+    if (normalized === 'code')
+        return 'tool';
+    // Return the canonical type, defaulting to 'agent' for unrecognized types
+    if (normalized === 'prompt')
+        return 'prompt';
+    if (normalized === 'tool')
+        return 'tool';
+    if (normalized === 'agent')
+        return 'agent';
+    if (normalized === 'skill')
+        return 'skill';
+    return 'agent';
 }
 function resolveExecutionEngine(agentData) {
     if (agentData.execution_engine === 'direct_llm' || agentData.execution_engine === 'managed_loop' || agentData.execution_engine === 'code_runtime') {
@@ -1900,7 +1915,8 @@ async function executeCloud(agentRef, file, options) {
         }
     }
     // --estimate: show cost estimate before running and ask for confirmation
-    if (options.estimate) {
+    // --estimate-only: show cost estimate and exit without running
+    if (options.estimate || options.estimateOnly) {
         try {
             const est = await (0, api_1.getAgentCostEstimate)(resolved, org, parsed.agent, parsed.version);
             const e = est.estimate;
@@ -1926,7 +1942,11 @@ async function executeCloud(agentRef, file, options) {
                 }
                 process.stderr.write('\n');
             }
-            // Ask for confirmation
+            // If --estimate-only, exit after showing estimate
+            if (options.estimateOnly) {
+                return;
+            }
+            // Otherwise, ask for confirmation (--estimate only)
             const rl = await Promise.resolve().then(() => __importStar(require('readline')));
             const iface = rl.createInterface({ input: process.stdin, output: process.stderr });
             const answer = await new Promise(resolve => {
@@ -1939,7 +1959,10 @@ async function executeCloud(agentRef, file, options) {
             }
         }
         catch {
-            // Non-fatal: if estimate fails, proceed with the run
+            // Non-fatal: if estimate fails, proceed with the run (or exit if --estimate-only)
+            if (options.estimateOnly) {
+                throw new errors_1.CliError('Could not fetch cost estimate.');
+            }
             process.stderr.write(chalk_1.default.gray('Could not fetch cost estimate. Proceeding...\n\n'));
         }
     }
@@ -2864,6 +2887,7 @@ function registerRunCommand(program) {
         .option('--json', 'Output raw JSON')
         .option('--verbose', 'Show sandbox stdout/stderr and debug info (cloud only)')
         .option('--estimate', 'Show cost estimate before running and ask for confirmation')
+        .option('--estimate-only', 'Show cost estimate and exit (for CI/CD automation)')
         .option('--provider <provider>', 'LLM provider (openai, anthropic, gemini, ollama)')
         .option('--model <model>', 'LLM model to use (overrides agent default)')
         .option('--key <key>', 'LLM API key (overrides env vars)')

package/dist/commands/templates/github-weekly-summary.js

@@ -628,13 +628,27 @@ class Analyst:
 
     async def generate_weekly_summary(self, store: ActivityStore) -> str:
         """Generate an intelligent weekly summary from the activity window."""
+        from datetime import datetime, timezone
+
         activity_data = store.serialise_for_llm()
         repos = ", ".join(store.repos)
+        now = datetime.now(timezone.utc)
+        current_date = now.strftime("%d %b %Y")
+
+        # Period range from activity window
+        period_start = store.window.period_start.strftime("%d %b %Y") if store.window and store.window.period_start else "unknown"
+        period_end = store.window.period_end.strftime("%d %b %Y") if store.window and store.window.period_end else current_date
 
         system_prompt = self._summary_prompt.replace(
             "{team_name}", self.team_name
         ).replace(
             "{repos}", repos
+        ).replace(
+            "{current_date}", current_date
+        ).replace(
+            "{period_start}", period_start
+        ).replace(
+            "{period_end}", period_end
         ).replace(
             "{activity_data}", activity_data
         )
@@ -733,6 +747,9 @@ anthropic>=0.40.0
 // ─── prompts/weekly_summary.md ───────────────────────────────────────────────
 exports.TEMPLATE_WEEKLY_SUMMARY_PROMPT = `You are a senior engineering manager analysing your team's GitHub activity for the past week. Your job is to write a concise, insightful weekly summary that a CTO or team lead would actually want to read on Monday morning.
 
+**Current date: {current_date}**
+**Reporting period: {period_start} to {period_end}**
+
 Rules:
 - INTERPRET, don't just list. "3 PRs merged" is useless. "The auth refactor shipped -- 3 PRs merged across 2 repos" is useful.
 - Highlight what SHIPPED (merged PRs, significant commits). This is the headline.

package/dist/commands/test.js

@@ -1061,25 +1061,32 @@ async function runOnce(agentDir, dataJson, verbose, config) {
 function registerTestCommand(program) {
     program
         .command('test [path]')
-        .description('Validate agent configuration and run test suite')
+        .description('Validate configuration and run test suite (fixtures + unit tests)')
         .option('-v, --verbose', 'Show detailed test output')
         .option('-w, --watch', 'Watch for file changes and re-run tests')
         .option('-r, --run', 'Run the agent once with --data input (validate first)')
         .option('-d, --data <json>', 'JSON input for --run mode')
+        .option('--validate-only', 'Run validation only (skip test suite)')
         .addHelpText('after', `
 Examples:
   orch test                    Validate + run tests in current directory
   orch test ./my-agent         Validate + run tests in specified directory
   orch test --verbose          Show detailed test output
   orch test --watch            Watch mode — re-run on file changes
+  orch test --validate-only    Validation only (same as: orch validate)
   orch test --run --data '{"task": "hello"}'   Validate, then run once
 
-What it checks:
+What it does (default):
   1. Validates orchagent.json (type, engine, required files, secrets, etc.)
   2. Runs Python tests (pytest): test_*.py, *_test.py
   3. Runs JS/TS tests (vitest): *.test.ts, *.spec.ts
   4. Runs fixture tests: tests/fixture-*.json
 
+When to use each command:
+  orch validate             Quick validation before publishing (config only)
+  orch test                 Full test suite (config + fixtures + unit tests)
+  orch test --validate-only Same as validate (config only)
+
 Fixture Format (tests/fixture-basic.json):
   {
     "description": "Test description",
@@ -1136,6 +1143,12 @@ Run mode (--run):
         catch {
             // Config not available, fixture tests will use env vars only
         }
+        // --validate-only flag: run validation then exit
+        if (options.validateOnly) {
+            const validation = await validateAgent(agentDir);
+            const isValid = printValidation(validation);
+            process.exit(isValid ? 0 : 1);
+        }
         // Run mode: validate then execute once
         if (options.run) {
             if (!options.data) {

package/dist/commands/validate.js

@@ -41,7 +41,7 @@ function printResult(result, serverIssues) {
     // Header
     const label = m.isSkill ? 'skill' : 'agent';
     const name = m.agentName || '(unknown)';
-    process.stderr.write(`\nValidating ${label}: ${chalk_1.default.bold(name)}\n\n`);
+    process.stderr.write(`\n${chalk_1.default.dim('[validation only]')} Validating ${label}: ${chalk_1.default.bold(name)}\n\n`);
     // Summary line: type, engine, mode
     if (!m.isSkill && m.agentType && m.executionEngine) {
         process.stderr.write(chalk_1.default.dim(`  Type: ${m.agentType} (${m.executionEngine}), Run mode: ${m.runMode || 'on_demand'}\n\n`));
@@ -115,7 +115,18 @@ function registerValidateCommand(program) {
     program
         .command('validate')
         .alias('lint')
-        .description('Validate agent or skill configuration without publishing')
+        .description('Validate configuration only (no tests)')
+        .addHelpText('after', `
+Use 'orch validate' to check configuration before publishing.
+Use 'orch test' to validate + run test suite (fixtures, unit tests, etc).
+
+Options:
+  --json              Output as JSON (for CI/CD pipelines)
+  --server            Also validate against server (requires auth)
+  --profile <name>    Use API key from named profile
+  --url <url>         Agent URL (for code-based agents)
+  --docker            Validate with Dockerfile
+`)
         .option('--profile <name>', 'Use API key from named profile')
         .option('--json', 'Output as JSON (for CI/CD)')
         .option('--server', 'Also run server-side validation (requires auth)')

package/dist/lib/doctor/output.js

@@ -172,6 +172,10 @@ function printHumanOutput(results, summary, verbose) {
         summaryParts.push(chalk_1.default.red(`${summary.errors} error${summary.errors > 1 ? 's' : ''}`));
     }
     process.stdout.write(`Summary: ${summaryParts.join(', ')}\n`);
+    // Hint about verbose flag if not already verbose
+    if (!verbose) {
+        process.stdout.write(chalk_1.default.dim('\nTip: Run with --verbose for detailed information about each check.\n'));
+    }
 }
 /**
  * Format results as JSON output.

package/dist/lib/errors.js

@@ -53,6 +53,27 @@ class CliError extends Error {
     }
 }
 exports.CliError = CliError;
+function dedupeErrorDetail(message, detail) {
+    const normalizedMessage = message.replace(/\r\n/g, '\n').trim();
+    const normalizedDetail = detail.replace(/\r\n/g, '\n').trim();
+    if (!normalizedDetail)
+        return null;
+    if (!normalizedMessage)
+        return normalizedDetail;
+    // Some responses repeat the same text in both `message` and `detail`.
+    if (normalizedDetail === normalizedMessage)
+        return null;
+    // If detail starts with the same first line, keep only the additional context.
+    const detailLines = normalizedDetail.split('\n');
+    if (detailLines[0] === normalizedMessage) {
+        const remainder = detailLines.slice(1).join('\n').trim();
+        return remainder || null;
+    }
+    // No useful extra information.
+    if (normalizedMessage.includes(normalizedDetail))
+        return null;
+    return normalizedDetail;
+}
 function formatError(err) {
     if (err instanceof CliError) {
         return err.message;
@@ -64,8 +85,11 @@ function formatError(err) {
             const code = p.error?.code;
             const detail = p.error?.detail || p.detail;
             let msg = `${anyErr.message} (status ${anyErr.status}${code ? `, ${code}` : ''})`;
-            if (detail)
-                msg += `\n${detail}`;
+            if (typeof detail === 'string') {
+                const dedupedDetail = dedupeErrorDetail(anyErr.message, detail);
+                if (dedupedDetail)
+                    msg += `\n${dedupedDetail}`;
+            }
             return msg;
         }
         return anyErr.message;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orchagent/cli",
-  "version": "0.3.94",
+  "version": "0.3.96",
   "description": "Command-line interface for orchagent — deploy and run AI agents for your team",
   "license": "MIT",
   "author": "orchagent <hello@orchagent.io>",