@ishlabs/cli 0.8.3 → 0.8.5

package/dist/commands/study-tester.js

@@ -4,7 +4,7 @@
  *
  * Default action: `ish study tester <id>` shows tester details and results.
  */
-import { withClient, readJsonFileOrStdin } from "../lib/command-helpers.js";
+import { withClient, readJsonFileOrStdin, resolveWorkspace } from "../lib/command-helpers.js";
 import { resolveId, tagAlias, ALIAS_PREFIX } from "../lib/alias-store.js";
 import { formatTesterDetail, output } from "../lib/output.js";
 /** Pick the latest iteration on a study (highest order_index, falling back to last). */
@@ -52,12 +52,15 @@ export function attachStudyTesterCommands(study) {
         .command("tester")
         .description("Inspect or manage testers (low-level; usually created via `study run`)")
         .argument("[id]", "Tester ID — pass directly to view tester details and results")
+        .option("--workspace <id>", "Workspace ID; accepted for consistency (workspace is inferred from the tester)")
         .addHelpText("after", "\nExamples:\n  $ ish study tester t-d4e                  # show tester details\n  $ ish study tester create --iteration <id> --profile <id>\n  $ ish study tester batch-create --iteration <id> --file testers.json\n  $ ish study tester delete t-d4e")
-        .action(async (id, _opts, cmd) => {
+        .action(async (id, opts, cmd) => {
         if (!id) {
             cmd.help();
         }
         await withClient(cmd, async (client, globals) => {
+            if (opts.workspace)
+                resolveWorkspace(opts.workspace);
             const data = await client.get(`/testers/${resolveId(id)}`);
             const result = data;
             if (result.id)

package/dist/commands/study.js

@@ -1,7 +1,8 @@
 /**
  * ish study — Manage studies.
  */
-import { withClient, getWebUrl, terminalLink, resolveWorkspace } from "../lib/command-helpers.js";
+import { readFileSync } from "node:fs";
+import { withClient, getWebUrl, terminalLink, resolveWorkspace, confirmDestructive } from "../lib/command-helpers.js";
 import { resolveId, tagAlias, ALIAS_PREFIX } from "../lib/alias-store.js";
 import { loadConfig, saveConfig } from "../config.js";
 import { formatStudyList, formatStudyDetail, formatStudyResults, output, ValidationError } from "../lib/output.js";
@@ -76,7 +77,7 @@ Concept pages: ish docs get-page concepts/study
     });
     study
         .command("create")
-        .description("Create a new study (the persistent shape: modality, tasks, questionnaire)")
+        .description("Create a new study (the persistent shape: modality, tasks, questionnaire). Optionally creates iteration A inline when --content-text or --url is passed.")
         .option("--workspace <id>", "Workspace ID")
         .requiredOption("--name <name>", "Study name")
         .option("--description <description>", "Study description")
@@ -87,13 +88,15 @@ Concept pages: ish docs get-page concepts/study
         .option("--assignments <json>", "Inline JSON array of assignments (escape hatch)")
         .option("--question <text>", "Add a text question to the questionnaire (repeatable; type=text, timing=after)", collectRepeatable, [])
         .option("--questionnaire <path>", "JSON file defining the questionnaire (supports text, slider, likert, single-choice, multiple-choice, number; timing=before|after)")
+        .option("--content-text <text>", "Text content to evaluate, or @filepath to read from file. Creates iteration A inline (text modality only)")
+        .option("--url <url>", "URL to test. Creates iteration A inline (interactive modality only)")
         .addHelpText("after", `
 Note: --workspace is optional if set via \`ish workspace use <alias>\`.
 
 The questionnaire is the set of questions testers answer. Use \`--question\` to
 quickly add simple text questions, or \`--questionnaire <file.json>\` for richer
-types (slider, likert, choice) and custom timing. The two forms are mutually
-exclusive — pick one.
+types (slider, likert, single-choice, multiple-choice, number) and custom
+timing. The two forms are mutually exclusive — pick one.
 
 Examples:
   # Interactive study with one assignment and a single-question questionnaire:
@@ -145,6 +148,31 @@ Next: configure a run with \`ish iteration create --study <id>\`,
                     throw new ValidationError(`Invalid content type "${opts.contentType}" for modality "${opts.modality}".`, validTypes);
                 }
             }
+            // Pattern E (cli half): build an inline iteration A when --content-text
+            // or --url is provided, so a single `study create` produces a study
+            // that's immediately runnable. Without these flags the backend
+            // creates zero iterations and the first `iteration create` becomes A.
+            // The backend requires a non-empty `name` on the inline iteration; we
+            // default to "A" to match the iteration-naming convention.
+            let inlineIteration;
+            if (opts.contentText !== undefined) {
+                if (opts.modality && opts.modality !== "text") {
+                    throw new Error(`--content-text is only valid with --modality text (got "${opts.modality}").`);
+                }
+                const text = opts.contentText.startsWith("@")
+                    ? readFileSync(opts.contentText.slice(1), "utf8")
+                    : opts.contentText;
+                inlineIteration = { name: "A", details: { type: "text", content_text: text } };
+            }
+            else if (opts.url !== undefined) {
+                if (opts.modality && opts.modality !== "interactive") {
+                    throw new Error(`--url is only valid with --modality interactive (got "${opts.modality}").`);
+                }
+                inlineIteration = {
+                    name: "A",
+                    details: { type: "interactive", url: opts.url, platform: "browser" },
+                };
+            }
             const resolvedWs = resolveWorkspace(opts.workspace);
             const body = {
                 product_id: resolvedWs,
@@ -154,6 +182,7 @@ Next: configure a run with \`ish iteration create --study <id>\`,
                 ...(opts.contentType !== undefined && { content_type: opts.contentType }),
                 ...(assignments && { assignments }),
                 ...(interviewQuestions && { interview_questions: interviewQuestions }),
+                ...(inlineIteration && { iteration: inlineIteration }),
             };
             const data = await client.post(`/products/${resolvedWs}/studies`, body);
             if (data.id) {
@@ -198,20 +227,47 @@ Next: configure a run with \`ish iteration create --study <id>\`,
     });
     study
         .command("get")
-        .description("Get study overview (assignments, questions, testers)")
-        .argument("<id>", "Study ID")
-        .addHelpText("after", "\nExamples:\n  $ ish study get <id>\n  $ ish study get <id> --json")
-        .action(async (id, _opts, cmd) => {
+        .description("Get study overview (accepts multiple IDs for batched lookup)")
+        .argument("<ids...>", "Study ID(s) — one or more aliases/UUIDs (space- or comma-separated)")
+        .addHelpText("after", `
+Examples:
+  $ ish study get s-b2c
+  $ ish study get s-b2c --json
+  $ ish study get s-b2c s-d4e s-f0a
+  $ ish study get s-b2c,s-d4e --fields alias,name,modality,status
+
+With multiple IDs, returns a {items:[...], total:N} envelope and uses the
+list table layout in human mode.`)
+        .action(async (ids, _opts, cmd) => {
         await withClient(cmd, async (client, globals) => {
-            const rid = resolveId(id);
-            const data = await client.get(`/studies/${rid}`);
-            const result = data;
-            if (result.id)
-                result.alias = tagAlias(ALIAS_PREFIX.study, String(result.id));
-            formatStudyDetail(result, globals.json);
-            if (!globals.json && data.product_id) {
-                const url = getWebUrl(globals, `/${data.product_id}/${rid}/overview`);
-                console.error(`\n  ${terminalLink(url, "Open in browser ↗")}\n`);
+            const flat = ids.flatMap((s) => s.split(",").map((x) => x.trim()).filter(Boolean));
+            if (flat.length === 0)
+                throw new Error("Provide at least one study id.");
+            if (flat.length === 1) {
+                const rid = resolveId(flat[0]);
+                const data = await client.get(`/studies/${rid}`);
+                const result = data;
+                if (result.id)
+                    result.alias = tagAlias(ALIAS_PREFIX.study, String(result.id));
+                formatStudyDetail(result, globals.json);
+                if (!globals.json && data.product_id) {
+                    const url = getWebUrl(globals, `/${data.product_id}/${rid}/overview`);
+                    console.error(`\n  ${terminalLink(url, "Open in browser ↗")}\n`);
+                }
+                return;
+            }
+            const results = await Promise.all(flat.map(async (raw) => {
+                const data = await client.get(`/studies/${resolveId(raw)}`);
+                const r = data;
+                if (r.id)
+                    r.alias = tagAlias(ALIAS_PREFIX.study, String(r.id));
+                return r;
+            }));
+            if (globals.json) {
+                output({ items: results, total: results.length }, true);
+            }
+            else {
+                formatStudyList(results, false);
             }
         });
     });
@@ -219,6 +275,7 @@ Next: configure a run with \`ish iteration create --study <id>\`,
         .command("results")
         .description("View aggregated results: tester counts, sentiment, interview answers. Returns a stable envelope with empty fields when no runs have completed.")
         .argument("<id>", "Study ID")
+        .option("--workspace <id>", "Workspace ID; accepted for consistency (workspace is inferred from the study)")
         .addHelpText("after", `
 Examples:
   $ ish study results <id>
@@ -319,10 +376,16 @@ Examples:
         .command("delete")
         .description("Delete a study")
         .argument("<id>", "Study ID")
-        .addHelpText("after", "\nExamples:\n  $ ish study delete <id>")
-        .action(async (id, _opts, cmd) => {
+        .option("--workspace <id>", "Workspace ID; accepted for consistency (workspace is inferred from the study)")
+        .option("-y, --yes", "Skip confirmation prompt (required in --json or non-TTY contexts)")
+        .addHelpText("after", "\nExamples:\n  $ ish study delete <id>           # interactive — prompts for confirmation\n  $ ish study delete <id> --yes     # non-interactive\n  $ ish study delete <id> --json --yes")
+        .action(async (id, opts, cmd) => {
         await withClient(cmd, async (client, globals) => {
             const rid = resolveId(id);
+            await confirmDestructive(`Delete study ${tagAlias(ALIAS_PREFIX.study, rid)}? This cannot be undone.`, {
+                yes: opts.yes,
+                json: globals.json,
+            });
             await client.del(`/studies/${rid}`);
             output({ id: rid, alias: tagAlias(ALIAS_PREFIX.study, rid), message: "Study deleted" }, globals.json, { writePath: true });
         });

package/dist/connect.js

@@ -5,7 +5,7 @@ import { spawn, execSync } from "node:child_process";
 import { existsSync, mkdirSync, chmodSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { loadConfig, saveConfig } from "./config.js";
-import { refreshTokens, isTokenExpired, decodeJwtExp } from "./auth.js";
+import { refreshTokens, isTokenExpired, decodeJwtExp, AuthRefreshPermanentError } from "./auth.js";
 import { binDir, cloudflaredBin, simulationsDir } from "./lib/paths.js";
 import { c } from "./lib/colors.js";
 const TUNNEL_URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
@@ -348,7 +348,7 @@ function manualInstallInstructions() {
 function startCloudflared(port, binPath, json) {
     return new Promise((resolve, reject) => {
         if (!json)
-            console.log(`Connecting to localhost:${port}...`);
+            console.error(`Connecting to localhost:${port}...`);
         const proc = spawn(binPath, ["tunnel", "--url", `http://localhost:${port}`], {
             stdio: ["ignore", "pipe", "pipe"],
         });
@@ -368,7 +368,7 @@ function startCloudflared(port, binPath, json) {
                 resolve({ process: proc, tunnelUrl });
             }
         });
-        proc.on("exit", (code) => {
+        proc.on("exit", () => {
             clearTimeout(timeout);
             if (!tunnelUrl) {
                 reject(new Error("cloudflared exited unexpectedly."));
@@ -402,7 +402,14 @@ async function registerTunnel(apiUrl, token, tunnelUrl, port) {
         return false;
     }
 }
-async function deregisterTunnel(apiUrl, token, json) {
+/**
+ * Best-effort deregister. When `suppressAuthFailures` is true (we're already
+ * shutting down because of an auth-permanent failure), 401/403 errors during
+ * deregister are silently swallowed — logging "Failed to deregister: HTTP 401"
+ * right after telling the user their auth expired is ironic and noisy.
+ * Non-auth failures are still logged.
+ */
+async function deregisterTunnel(apiUrl, token, json, suppressAuthFailures = false) {
     try {
         const resp = await fetch(`${apiUrl}${API_BASE}/connect`, {
             method: "DELETE",
@@ -415,13 +422,32 @@ async function deregisterTunnel(apiUrl, token, json) {
             console.log(JSON.stringify({ status: "disconnected" }));
         }
         else {
-            console.log("Disconnected");
+            console.error("Disconnected");
         }
     }
     catch (e) {
+        if (suppressAuthFailures && /HTTP (401|403)/.test(String(e)))
+            return;
         console.error(`Warning: Failed to deregister connection: ${e}`);
     }
 }
+/**
+ * Classify whether a thrown error from the auth refresh path is permanent.
+ * Permanent = "the local config can't recover, user must `ish login` again."
+ * Examples: Supabase `refresh_token_not_found`, `invalid_grant`, any 4xx on
+ * the refresh endpoint. Network blips and 5xx are NOT permanent.
+ *
+ * The typed sentinel from `src/auth.ts` is the primary signal. We also string-
+ * match legacy error messages in case something throws a plain Error.
+ */
+function isPermanentAuthFailure(err) {
+    if (err instanceof AuthRefreshPermanentError)
+        return true;
+    if (err instanceof Error) {
+        return /refresh_token_not_found|invalid_grant|Token refresh failed \(HTTP 4\d\d/i.test(err.message);
+    }
+    return false;
+}
 function processHeartbeatResponse(resp, renderCards) {
     resp.json().then((data) => {
         const sims = data.simulations ?? [];
@@ -437,7 +463,7 @@ function processHeartbeatResponse(resp, renderCards) {
         // Non-fatal: response parsing failed, silently continue
     });
 }
-function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal, json) {
+function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal, onAuthPermanent, json) {
     let consecutiveFailures = 0;
     let stopped = false;
     const interval = setInterval(async () => {
@@ -455,7 +481,7 @@ function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal,
                     const newToken = await doRefresh();
                     onTokenRefreshed(newToken);
                     if (!json)
-                        console.log("Token refreshed.");
+                        console.error("Token refreshed.");
                     // Retry heartbeat with new token
                     const retry = await fetch(`${apiUrl}${API_BASE}/connect/heartbeat`, {
                         method: "POST",
@@ -469,6 +495,15 @@ function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal,
                     return;
                 }
                 catch (refreshErr) {
+                    // Permanent refresh failure (refresh_token_not_found etc.) — no
+                    // amount of retrying will fix this. Bail out immediately with an
+                    // actionable message; don't waste the 3-strike countdown.
+                    if (isPermanentAuthFailure(refreshErr)) {
+                        stopped = true;
+                        clearInterval(interval);
+                        await onAuthPermanent(refreshErr);
+                        return;
+                    }
                     console.error(`Token refresh failed: ${refreshErr}`);
                 }
             }
@@ -499,7 +534,7 @@ function startHeartbeat(apiUrl, getToken, doRefresh, onTokenRefreshed, onFatal,
  * Schedule a proactive token refresh before the JWT expires.
  * Refreshes 10 minutes before expiry.
  */
-function scheduleProactiveRefresh(token, doRefresh, onTokenRefreshed, json) {
+function scheduleProactiveRefresh(token, doRefresh, onTokenRefreshed, onAuthPermanent, json) {
     if (!doRefresh)
         return { stop: () => { } };
     const exp = decodeJwtExp(token);
@@ -514,11 +549,17 @@ function scheduleProactiveRefresh(token, doRefresh, onTokenRefreshed, json) {
             const newToken = await doRefresh();
             onTokenRefreshed(newToken);
             if (!json)
-                console.log("Token proactively refreshed.");
+                console.error("Token proactively refreshed.");
             // Schedule next refresh for the new token
-            scheduleProactiveRefresh(newToken, doRefresh, onTokenRefreshed, json);
+            scheduleProactiveRefresh(newToken, doRefresh, onTokenRefreshed, onAuthPermanent, json);
         }
         catch (e) {
+            // Permanent refresh failure: short-circuit to the actionable message
+            // path instead of letting the next heartbeat eat 3 strikes.
+            if (isPermanentAuthFailure(e)) {
+                await onAuthPermanent(e);
+                return;
+            }
             console.error(`Proactive token refresh failed: ${e}`);
         }
     }, delay);
@@ -572,20 +613,54 @@ export async function runTunnel(port, tokenArg, apiUrlArg, tokenFileArg, outputO
         console.log(`Tunnel URL: ${tunnelUrl} → http://localhost:${port}\n`);
     }
     let shuttingDown = false;
-    const heartbeat = startHeartbeat(apiUrl, () => currentToken, serializedRefresh, onTokenRefreshed, async () => {
+    // Holders for forward references — `onAuthPermanent` needs to stop these
+    // timers, but `startHeartbeat`/`scheduleProactiveRefresh` need
+    // `onAuthPermanent` to wire up. Declared as nullable, assigned just below.
+    let heartbeat = null;
+    let proactiveRefresh = null;
+    // Fast-fail path for non-recoverable auth failures (e.g. Supabase
+    // refresh_token_not_found). Skips the 3-strike heartbeat countdown and
+    // gives the user a single actionable next step.
+    const onAuthPermanent = async (cause) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        heartbeat?.stop();
+        proactiveRefresh?.stop();
+        if (json) {
+            console.error(JSON.stringify({
+                status: "auth_expired",
+                message: `Authentication expired. Run \`ish login\` and re-run \`ish connect ${port}\`.`,
+                detail: "refresh_token expired or revoked; the local config can't recover",
+            }));
+        }
+        else {
+            console.error(`\nAuthentication expired. Run \`ish login\` and re-run \`ish connect ${port}\`.`);
+            console.error("(refresh_token expired or revoked; the local config can't recover)");
+        }
+        if (cause instanceof Error && cause.message) {
+            // Keep the underlying detail discoverable for log scrapers / agents,
+            // without making it the headline.
+            console.error(`Cause: ${cause.message}`);
+        }
+        await deregisterTunnel(apiUrl, currentToken, json, true);
+        cfProcess.kill();
+        process.exit(3);
+    };
+    heartbeat = startHeartbeat(apiUrl, () => currentToken, serializedRefresh, onTokenRefreshed, async () => {
         await deregisterTunnel(apiUrl, currentToken, json);
         cfProcess.kill();
         process.exit(1);
-    }, json);
-    const proactiveRefresh = scheduleProactiveRefresh(currentToken, serializedRefresh, onTokenRefreshed, json);
+    }, onAuthPermanent, json);
+    proactiveRefresh = scheduleProactiveRefresh(currentToken, serializedRefresh, onTokenRefreshed, onAuthPermanent, json);
     const shutdown = async () => {
         if (shuttingDown)
             process.exit(1);
         shuttingDown = true;
         if (!json)
-            console.log("\nShutting down...");
-        heartbeat.stop();
-        proactiveRefresh.stop();
+            console.error("\nShutting down...");
+        heartbeat?.stop();
+        proactiveRefresh?.stop();
         cfProcess.kill();
         await deregisterTunnel(apiUrl, currentToken, json);
         process.exit(0);
@@ -593,12 +668,12 @@ export async function runTunnel(port, tokenArg, apiUrlArg, tokenFileArg, outputO
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
     if (!json && !quiet) {
-        console.log("Press Ctrl+C to disconnect.\n");
+        console.error("Press Ctrl+C to disconnect.\n");
     }
     cfProcess.on("exit", async () => {
         if (!shuttingDown) {
-            heartbeat.stop();
-            proactiveRefresh.stop();
+            heartbeat?.stop();
+            proactiveRefresh?.stop();
             await deregisterTunnel(apiUrl, currentToken, json);
             process.exit(0);
         }

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { program, Option } from "commander";
 import { runTunnel } from "./connect.js";
-import { login, getAppUrl } from "./auth.js";
+import { login, getAppUrl, decodeJwtClaims } from "./auth.js";
 import { loadConfig, saveConfig } from "./config.js";
 import { upgrade } from "./upgrade.js";
 import { registerWorkspaceCommands } from "./commands/workspace.js";
@@ -14,8 +14,12 @@ import { registerAskCommands } from "./commands/ask.js";
 import { registerDocsCommands } from "./commands/docs.js";
 import { registerInitCommands } from "./commands/init.js";
 import { AGENT_HELP_FOOTER } from "./lib/docs.js";
-import { runInline, EXIT_USAGE } from "./lib/command-helpers.js";
+import { runInline, EXIT_USAGE, injectGlobalWorkspaceOption } from "./lib/command-helpers.js";
+import { resolveApiUrl, resolveToken } from "./lib/auth.js";
+import { ApiClient } from "./lib/api-client.js";
+import { tagAlias, ALIAS_PREFIX } from "./lib/alias-store.js";
 import { output } from "./lib/output.js";
+import { ishDir } from "./lib/paths.js";
 import pkg from "../package.json" with { type: "json" };
 const { version } = pkg;
 program
@@ -65,7 +69,10 @@ program
     .option("--token-file <path>", "Read auth token from a file (preferred over --token / ISH_TOKEN)")
     .option("--api-url <url>", "Backend API URL (default: ISH_API_URL or https://api.ishlabs.io)")
     .addOption(new Option("--dev", "Use local dev API (http://localhost:8000)").hideHelp())
+    .option("--workspace <id>", "Default workspace ID; per-subcommand --workspace overrides")
     .option("--json", "Output as JSON (auto-enabled when piped)")
+    .option("--get <field>", "Extract a single field from the JSON response and print only its value (implies --json internally; supports dotted paths e.g. tester_profile.name)")
+    .option("--human", "Force human-readable output even when stdout is piped (overrides JSON-when-piped auto-detection)")
     .option("--fields <fields>", "Comma-separated fields to include in JSON output (e.g. alias,name,status)")
     .option("--verbose", "Include full UUIDs and timestamps in JSON output")
     .option("--no-color", "Disable colored output (also honored: NO_COLOR env var)")
@@ -98,6 +105,118 @@ program
         output({ message: "Logged out" }, globals.json);
     });
 });
+program
+    .command("status")
+    .alias("whoami")
+    .description("Show active session — user, workspace, study, ask")
+    .addHelpText("after", "\nFirst command to run when starting cold. Outputs the active workspace,\nstudy, and ask handles plus token validity. Doesn't error on no-token —\nreturns user: null with a hint instead. JSON safe for piping.")
+    .action(async (_opts, cmd) => {
+    await runInline(cmd, async (globals) => {
+        const apiUrl = resolveApiUrl(globals.apiUrl, globals.dev);
+        const config = loadConfig();
+        // Try to resolve a token; on auth failure, return a no-token status
+        // instead of throwing so the command works pre-login.
+        let token;
+        let tokenError;
+        try {
+            token = await resolveToken(globals.token, apiUrl, globals.tokenFile);
+        }
+        catch (err) {
+            tokenError = err instanceof Error ? err.message : String(err);
+        }
+        let user = null;
+        if (token) {
+            const claims = decodeJwtClaims(token);
+            const exp = typeof claims?.exp === "number" ? claims.exp : 0;
+            const expiresIn = exp ? Math.max(0, exp - Math.floor(Date.now() / 1000)) : 0;
+            user = {
+                email: typeof claims?.email === "string" ? claims.email : null,
+                token_valid: expiresIn > 0,
+                expires_in_seconds: expiresIn,
+            };
+        }
+        // Resolve names of active resources. Failures are non-fatal — we still
+        // return the saved IDs so the user knows what's configured.
+        const client = token ? new ApiClient({ apiUrl, token }) : null;
+        let workspace = null;
+        if (config.workspace) {
+            workspace = {
+                id: config.workspace,
+                alias: tagAlias(ALIAS_PREFIX.workspace, config.workspace),
+            };
+            if (client) {
+                try {
+                    const ws = await client.get(`/products/${config.workspace}`);
+                    if (ws?.name)
+                        workspace.name = ws.name;
+                }
+                catch { /* keep id+alias only */ }
+            }
+        }
+        let study = null;
+        if (config.study) {
+            study = {
+                id: config.study,
+                alias: tagAlias(ALIAS_PREFIX.study, config.study),
+            };
+            if (client) {
+                try {
+                    const s = await client.get(`/studies/${config.study}`);
+                    if (s?.name)
+                        study.name = s.name;
+                }
+                catch { /* keep id+alias only */ }
+            }
+        }
+        let ask = null;
+        if (config.ask) {
+            ask = {
+                id: config.ask,
+                alias: tagAlias(ALIAS_PREFIX.ask, config.ask),
+            };
+            if (client) {
+                try {
+                    const a = await client.get(`/asks/${config.ask}`);
+                    if (a?.name)
+                        ask.name = a.name;
+                }
+                catch { /* keep id+alias only */ }
+            }
+        }
+        const payload = {
+            user,
+            workspace,
+            study,
+            ask,
+            api_url: apiUrl,
+            home: ishDir(),
+        };
+        if (tokenError && !token)
+            payload.hint = `Run \`ish login\`. (${tokenError})`;
+        if (globals.json) {
+            output(payload, true);
+            return;
+        }
+        // Human output
+        const fmtSeconds = (s) => {
+            if (s <= 0)
+                return "expired";
+            const m = Math.floor(s / 60);
+            const h = Math.floor(m / 60);
+            if (h > 0)
+                return `${h}h${m % 60}m`;
+            return `${m}m`;
+        };
+        console.log(`User:       ${user ? `${user.email ?? "(no email)"}  (token ${user.token_valid ? "valid" : "expired"}, expires in ${fmtSeconds(user.expires_in_seconds)})` : "(not logged in — run `ish login`)"}`);
+        console.log(`Workspace:  ${workspace ? `${workspace.name ?? "(name unavailable)"} (${workspace.alias})` : "—"}`);
+        console.log(`Study:      ${study ? `${study.name ?? "(name unavailable)"} (${study.alias})` : "—"}`);
+        console.log(`Ask:        ${ask ? `${ask.name ?? "(name unavailable)"} (${ask.alias})` : "—"}`);
+        console.log(`Home:       ${ishDir()}`);
+        console.log(`API:        ${apiUrl}`);
+        if (tokenError && !token)
+            console.error(`\nHint: ${payload.hint}`);
+    });
+});
 program
     .command("connect")
     .description("Expose your localhost to Ish via a Cloudflare tunnel")
@@ -134,4 +253,5 @@ program
     .action(async (options) => {
     await upgrade(version, options.release);
 });
+injectGlobalWorkspaceOption(program);
 program.parse();

package/dist/lib/api-client.js

@@ -31,15 +31,30 @@ export class ApiError extends Error {
     error_code;
     retryable;
     constructor(status, statusText, body) {
-        const msg = typeof body === "object" && body !== null && "detail" in body
-            ? String(body.detail)
-            : `HTTP ${status} ${statusText}`;
+        // FastAPI HTTPException(detail=...) wraps detail under a top-level "detail" key.
+        // When detail is a structured object (our convention for typed errors),
+        // pull the message off detail.detail and prefer detail.error_code.
+        let detail;
+        let bodyErrorCode;
+        if (typeof body === "object" && body !== null && "detail" in body) {
+            detail = body.detail;
+            if (typeof detail === "object" && detail !== null && "error_code" in detail
+                && typeof detail.error_code === "string") {
+                bodyErrorCode = detail.error_code;
+            }
+        }
+        const detailMsg = typeof detail === "string"
+            ? detail
+            : (typeof detail === "object" && detail !== null && "detail" in detail
+                ? String(detail.detail)
+                : undefined);
+        const msg = detailMsg ?? `HTTP ${status} ${statusText}`;
         super(msg);
         this.status = status;
         this.statusText = statusText;
         this.body = body;
         this.name = "ApiError";
-        this.error_code = mapErrorCode(status);
+        this.error_code = bodyErrorCode ?? mapErrorCode(status);
         this.retryable = isRetryable(status);
     }
 }
@@ -176,7 +191,9 @@ export class ApiClient {
         return this.handleResponse(res);
     }
     async del(path, opts) {
-        const timeout = opts?.timeout ?? DEFAULT_TIMEOUT_MS;
+        // Deletes typically cascade (rounds → responses → testers → audience),
+        // so default to a longer timeout than the standard 15s.
+        const timeout = opts?.timeout ?? 60_000;
         const url = `${this.baseUrl}${path}`;
         let res;
         try {
@@ -187,8 +204,13 @@ export class ApiClient {
             });
         }
         catch (err) {
-            if (isAbortTimeout(err))
-                throw timeoutError("DELETE", timeout);
+            if (isAbortTimeout(err)) {
+                const seconds = Math.round(timeout / 1000);
+                throw new ApiError(408, "Request Timeout", {
+                    detail: `DELETE request timed out after ${seconds}s. The deletion may have completed server-side — ` +
+                        `re-fetch the resource (e.g. \`ish ask get <id>\`) before retrying to avoid a 404.`,
+                });
+            }
             if (err instanceof TypeError)
                 throw networkError(url);
             throw err;