teamshift 0.1.1 → 0.1.3

package/README.md

@@ -11,9 +11,11 @@ npx teamshift add code-audit-swarm     # adds it to your workspace
 npx teamshift run <team-id> "review services/api for auth mistakes"
 ```
 
-`teamshift teams` lists everything callable, including teams you built yourself
-in the portal. `add` is idempotent — running it twice will not duplicate a team
-or overwrite edits you have made to it.
+`teamshift teams` lists callable teams, including teams you built yourself in the
+portal; `teamshift agents` lists callable individual agents. Keeping the two
+inventories separate prevents a large internal agent library from burying the
+teams a customer actually runs. `add` is idempotent — running it twice will not
+duplicate a team or overwrite edits you have made to it.
 
 ## Parallel fan-out
 
@@ -36,7 +38,9 @@ completed  $1.20   4.0s  find dead code
 ```
 
 `--file prompts.txt` reads one prompt per line. Concurrency is bounded (default
-5) so a large batch does not trip the API's write rate limit.
+5) so a large batch does not trip the API's write rate limit. Completed runs
+print their scrubbed deliverable after the status table; `--json` includes it as
+the outcome's `output` field.
 
 ## Already using Claude Code or Codex?
 
@@ -54,8 +58,8 @@ agent, with no second CLI to learn. Both install commands are in the portal unde
 
 | Code | Meaning |
 | --- | --- |
-| `0` | every run reached a terminal status |
-| `1` | usage error, auth failure, or at least one run failed to dispatch |
+| `0` | every run completed and returned its deliverable |
+| `1` | usage/auth error, timeout, failed run, or missing deliverable |
 | `2` | out of credit — add credits and rerun |
 
 ## Releasing

package/dist/api.js

@@ -73,4 +73,7 @@ export class TeamShiftClient {
         const body = await this.request(`/v1/runs/${runId}`);
         return body.run;
     }
+    getRunResult(runId) {
+        return this.request(`/v1/runs/${runId}/result`);
+    }
 }

package/dist/cli.js

@@ -10,7 +10,8 @@ const USAGE = `teamshift — run agent teams from your terminal
   teamshift whoami                    Show the active key and endpoint
   teamshift catalog                   Browse prebuilt teams you can add
   teamshift add <catalog-id>          Add a prebuilt team to your workspace
-  teamshift teams                     List callable teams and agents
+  teamshift teams                     List callable teams
+  teamshift agents                    List callable agents
   teamshift run <id> "<prompt>"       Run one team, wait, print status and charge
   teamshift run <id> -p "a" -p "b"    Fan out prompts in parallel
   teamshift run <id> --file prompts.txt   One prompt per line, run in parallel
@@ -71,18 +72,16 @@ async function login() {
         rl.close();
     }
 }
-async function listCallable(json) {
+async function listCallable(kind, json) {
     const payload = await requireClient().interop();
+    const items = kind === 'team' ? payload.teams : payload.agents;
     if (json) {
-        console.log(JSON.stringify(payload, null, 2));
+        console.log(JSON.stringify(items, null, 2));
         return;
     }
-    const rows = [
-        ...payload.teams.map((item) => ['team', item.id, item.name]),
-        ...payload.agents.map((item) => ['agent', item.id, item.name]),
-    ];
+    const rows = items.map((item) => [kind, item.id, item.name]);
     if (rows.length === 0) {
-        console.log('Nothing callable yet — create a team in the portal first.');
+        console.log(`No callable ${kind}s yet${kind === 'team' ? ' — add one with `teamshift add <id>`.' : '.'}`);
         return;
     }
     console.log(table(['KIND', 'ID', 'NAME'], rows));
@@ -152,9 +151,20 @@ async function run(args) {
     const serial = outcomes.reduce((sum, outcome) => sum + outcome.elapsedMs, 0);
     console.log(`\n${outcomes.length} run(s) · ${money(total)} total · ${duration(Date.now() - startedAt)} wall clock ` +
         `(${duration(serial)} if run one at a time)`);
+    for (const outcome of outcomes) {
+        if (!outcome.error)
+            continue;
+        console.error(`\n${outcome.status} · ${outcome.runId ?? 'not dispatched'}\n${outcome.error}`);
+    }
+    for (const outcome of outcomes) {
+        if (outcome.output === null || outcome.output === undefined)
+            continue;
+        const output = typeof outcome.output === 'string' ? outcome.output : JSON.stringify(outcome.output, null, 2);
+        console.log(`\n${outcomes.length > 1 ? `[${outcome.prompt}]\n` : ''}${output}`);
+    }
     const failed = outcomes.filter((outcome) => outcome.error).length;
     if (failed > 0) {
-        console.log(`${failed} run(s) failed to dispatch — rerun just those prompts.`);
+        console.log(`${failed} run(s) need attention — inspect the status above before retrying.`);
         process.exitCode = 1;
     }
 }
@@ -186,7 +196,9 @@ export async function main(argv = process.argv.slice(2)) {
             case 'add':
                 return await addFromCatalog(args);
             case 'teams':
-                return await listCallable(args.json);
+                return await listCallable('team', args.json);
+            case 'agents':
+                return await listCallable('agent', args.json);
             case 'run':
                 return await run(args);
             default:

package/dist/run.js

@@ -1,5 +1,33 @@
+import { ApiError } from './api.js';
 import { isTerminal } from './format.js';
 const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export class RunPollingTimeoutError extends Error {
+    runId;
+    latest;
+    constructor(runId, latest) {
+        super(`run ${runId} did not finish before the polling timeout (last status: ${latest.status ?? 'unknown'})`);
+        this.runId = runId;
+        this.latest = latest;
+    }
+}
+const RETRYABLE_RESULT_STATUSES = new Set([404, 409, 502, 503]);
+/** Wait for terminal reconciliation and object-storage visibility to converge. */
+export async function waitForRunResult(client, runId, options = {}) {
+    const { intervalMs = 1000, timeoutMs = 30_000, now = Date.now, sleep = defaultSleep } = options;
+    const startedAt = now();
+    for (;;) {
+        try {
+            return await client.getRunResult(runId);
+        }
+        catch (error) {
+            if (!(error instanceof ApiError) || !RETRYABLE_RESULT_STATUSES.has(error.status))
+                throw error;
+            if (now() - startedAt >= timeoutMs)
+                throw error;
+            await sleep(intervalMs);
+        }
+    }
+}
 /** Poll one run to a terminal status, or give up at the timeout. */
 export async function waitForRun(client, runId, options = {}) {
     const { intervalMs = 2000, timeoutMs = 900_000, now = Date.now, sleep = defaultSleep } = options;
@@ -7,7 +35,7 @@ export async function waitForRun(client, runId, options = {}) {
     let latest = await client.getRun(runId);
     while (!isTerminal(latest.status)) {
         if (now() - startedAt >= timeoutMs)
-            return latest;
+            throw new RunPollingTimeoutError(runId, latest);
         await sleep(intervalMs);
         latest = await client.getRun(runId);
     }
@@ -34,22 +62,43 @@ export async function runBatch(client, kind, id, prompts, options = {}) {
             if (prompt === undefined)
                 return;
             const startedAt = now();
+            let runId = null;
             try {
-                const runId = await client.startRun(kind, id, prompt);
-                const summary = await waitForRun(client, runId, { ...pollOptions, now });
+                runId = await client.startRun(kind, id, prompt);
+                let summary = await waitForRun(client, runId, { ...pollOptions, now });
+                let output = null;
+                let resultError;
+                if (summary.status === 'completed') {
+                    try {
+                        const result = await waitForRunResult(client, runId);
+                        output = result.text ?? result.document;
+                        // The result endpoint opens only after terminal reconciliation has
+                        // settled; refresh so the printed charge is the reconciled cost,
+                        // not the dispatch-time estimate that briefly shares its status.
+                        summary = await client.getRun(runId);
+                    }
+                    catch (error) {
+                        resultError = `result unavailable: ${error instanceof Error ? error.message : String(error)}`;
+                    }
+                }
+                else {
+                    resultError = `run ended with status ${summary.status ?? 'unknown'}`;
+                }
                 results[index] = {
                     prompt,
                     runId,
                     status: String(summary.status ?? 'unknown'),
                     costUsd: summary.cost_estimate_usd ?? null,
                     elapsedMs: now() - startedAt,
+                    output,
+                    ...(resultError ? { error: resultError } : {}),
                 };
             }
             catch (error) {
                 results[index] = {
                     prompt,
-                    runId: null,
-                    status: 'dispatch_failed',
+                    runId,
+                    status: error instanceof RunPollingTimeoutError ? 'poll_timeout' : 'dispatch_failed',
                     costUsd: null,
                     elapsedMs: now() - startedAt,
                     error: error instanceof Error ? error.message : String(error),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "teamshift",
   "private": false,
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Run TeamShift agent teams from your terminal. Metered by usage \u2014 no model key of your own required.",
   "type": "module",
   "bin": {