gipity 1.0.384 → 1.0.387

package/dist/commands/page-test.js

@@ -18,12 +18,33 @@ async function inspectClient(url, waitMs, i) {
 }
 const MAX_HOLD_MS = 15_000; // keep each in-page await under the ~20s browser action timeout
 const MIN_HOLD_MS = 1_000;
-/** Splice per-client values into a user expression. `{{label}}` → the client's
- *  label, `{{i}}` → its 0-based index. Plain string replace (no regex) so the
- *  expression's own characters are never treated as patterns. */
+/** Splice per-client values into a user string (URL, --action, or --observe).
+ *  `{{label}}` → the client's label, `{{i}}` → its 0-based index. Plain string
+ *  replace (no regex) so the string's own characters are never treated as
+ *  patterns. */
 function subst(expr, label, i) {
     return expr.split('{{label}}').join(label).split('{{i}}').join(String(i));
 }
+/** Collect any `{{...}}` placeholders the runner does NOT recognize, so an
+ *  invented token (e.g. `{{name}}`) is flagged instead of passing through
+ *  verbatim into every client's URL/expression. */
+function unknownTokens(...strings) {
+    const out = new Set();
+    for (const s of strings) {
+        for (const m of (s ?? '').match(/\{\{[^}]*\}\}/g) ?? []) {
+            if (m !== '{{i}}' && m !== '{{label}}')
+                out.add(m);
+        }
+    }
+    return [...out];
+}
+/** One-time warning (to stderr, so --json stdout stays clean) for
+ *  unrecognized placeholders left as-is. */
+function warnUnknownTokens(unknown) {
+    if (unknown.length === 0)
+        return;
+    console.error(warning(`⚠ Unrecognized placeholder ${unknown.join(', ')} left as-is — only {{i}} (0-based client index) and {{label}} are substituted per client. Set per-client values with --labels and reference them as {{label}}.`));
+}
 /** Build the statement-body script one client runs: do the one-time action,
  *  then sample `observe` `samples` times across `holdMs`, stamping in-page
  *  start/end so the caller can confirm the clients overlapped. */
@@ -98,11 +119,22 @@ function fmtSamples(samples) {
 async function runInteractive(url, observe, opts) {
     const clients = Math.max(1, parseInt(opts.clients, 10) || 2);
     const stagger = opts.stagger != null ? Math.max(0, parseInt(opts.stagger, 10) || 0) : 0;
-    const hold = Math.min(MAX_HOLD_MS, Math.max(MIN_HOLD_MS, parseInt(opts.hold, 10) || 8000));
+    const rawHold = parseInt(opts.hold, 10) || 8000;
+    const hold = Math.min(MAX_HOLD_MS, Math.max(MIN_HOLD_MS, rawHold));
+    if (rawHold > MAX_HOLD_MS) {
+        // Surface the clamp (to stderr, so --json stdout stays clean) instead of
+        // leaving the agent to infer it from the printed "hold Nms" line.
+        console.error(warning(`--hold ${rawHold}ms exceeds the ${MAX_HOLD_MS}ms per-client cap (each client samples inside one browser eval, bounded by the server's eval budget) — using ${MAX_HOLD_MS}ms. ` +
+            `Co-launch every role in this one command (put {{label}}/{{i}} in the URL) so all clients overlap for the whole window; a separately-started background client overlaps only the sliver of its window that lines up.`));
+    }
     const samples = Math.min(30, Math.max(2, parseInt(opts.samples, 10) || 6));
     const settle = opts.waitFor ? 200 : 1000;
     const labels = (opts.labels ? String(opts.labels).split(',').map((s) => s.trim()) : []).filter(Boolean);
     const labelFor = (i) => labels[i] ?? `client-${i}`;
+    // Only {{label}} and {{i}} are substituted. Warn once on any other {{token}}
+    // (a natural guess like {{name}} or {{index}}) so it isn't sent literally to
+    // every client — the silent wrong-behavior trap of identical clients.
+    warnUnknownTokens(unknownTokens(url, opts.action, observe));
     if (!opts.json) {
         console.log(`${brand('Page test')} ${muted('(interactive)')} ${bold(url)}`);
         console.log(muted(`${clients} client(s), stagger ${stagger}s, hold ${hold}ms, ${samples} samples each`));
@@ -113,8 +145,12 @@ async function runInteractive(url, observe, opts) {
             await sleep(i * stagger * 1000);
             if (!opts.json)
                 console.log(muted(`client ${i} (${labelFor(i)}) joining`));
+            // {{label}}/{{i}} substitute into the URL too, so one invocation can launch
+            // asymmetric roles concurrently (e.g. ?role={{label}} with --labels host,join)
+            // and the overlap check still confirms they coexisted.
+            const clientUrl = subst(url, labelFor(i), i);
             const expr = buildHarness(opts.action ? subst(opts.action, labelFor(i), i) : undefined, subst(observe, labelFor(i), i), labelFor(i), hold, samples);
-            return observeClient(url, expr, i, labelFor(i), settle, hold, opts.waitFor);
+            return observeClient(clientUrl, expr, i, labelFor(i), settle, hold, opts.waitFor);
         })());
     }
     const results = (await Promise.all(runs)).sort((a, b) => a.i - b.i);
@@ -159,6 +195,9 @@ async function runPassive(url, opts) {
     const clients = Math.max(1, parseInt(opts.clients, 10) || 2);
     const stagger = opts.stagger != null ? Math.max(0, parseInt(opts.stagger, 10) || 0) : 12;
     const wait = Math.min(30000, Math.max(2000, parseInt(opts.wait, 10) || 24000));
+    const labels = (opts.labels ? String(opts.labels).split(',').map((s) => s.trim()) : []).filter(Boolean);
+    const labelFor = (i) => labels[i] ?? `client-${i}`;
+    warnUnknownTokens(unknownTokens(url));
     if (!opts.json) {
         console.log(`${brand('Page test')} ${bold(url)}`);
         console.log(`${muted(`${clients} client(s), stagger ${stagger}s, ${wait}ms open each`)}`);
@@ -169,7 +208,7 @@ async function runPassive(url, opts) {
             await sleep(i * stagger * 1000);
             if (!opts.json)
                 console.log(`${muted(`client ${i}${i === 0 ? ' (first)' : ''} starting`)}`);
-            return inspectClient(url, wait, i);
+            return inspectClient(subst(url, labelFor(i), i), wait, i);
         })());
     }
     const results = (await Promise.all(runs)).sort((a, b) => a.i - b.i);
@@ -222,14 +261,14 @@ async function runPassive(url, opts) {
 //  just because the clients never actually ran together.
 export const pageTestCommand = new Command('test')
     .description('Multi-client realtime check: load a URL in N concurrent headless clients; flag console errors, or drive an action and observe shared state (--observe)')
-    .argument('<url>', 'Deployed URL to load in every client')
+    .argument('<url>', 'Deployed URL to load in every client. {{label}}/{{i}} substitute per client in both modes (e.g. ?name=Bot{{i}}, or ?role={{label}} with --labels host,join), so one invocation can give each client a distinct role.')
     .option('--clients <n>', 'Number of headless clients to launch', '2')
     .option('--stagger <s>', 'Seconds between client starts (passive default 12; interactive default 0)')
     .option('--wait <ms>', 'Passive mode: ms each client stays open after load (max 30000)', '24000')
     // Interactive mode (--observe drives it):
     .option('--observe <expr>', 'Interactive: JS expression sampled in each client to read shared state (e.g. presence count). Switches on interactive mode.')
     .option('--action <expr>', 'Interactive: one-time JS run in each client before observing (e.g. fill a name + submit). {{label}}/{{i}} are substituted per client.')
-    .option('--labels <csv>', 'Interactive: per-client labels substituted for {{label}} (default client-0, client-1, …)')
+    .option('--labels <csv>', 'Per-client labels substituted for {{label}} in the URL/--action/--observe (default client-0, client-1, …)')
     .option('--hold <ms>', `Interactive: total observe window per client (${MIN_HOLD_MS}-${MAX_HOLD_MS}ms)`, '8000')
     .option('--samples <k>', 'Interactive: number of observations across the hold window (2-30)', '6')
     .option('--wait-for <selector>', 'Interactive: wait for this CSS selector before running --action (deterministic readiness gate)')
@@ -239,12 +278,22 @@ Examples:
   # Passive: load in 3 staggered clients, flag console errors
   gipity page test "https://dev.gipity.ai/me/app/" --clients 3 --stagger 8
 
+  # Per-client URL params: each client joins under a distinct name (Bot0, Bot1, …)
+  gipity page test "https://dev.gipity.ai/me/app/?name=Bot{{i}}" --clients 2
+
   # Interactive: two concurrent clients each join with a name, then watch the
   # live presence count. The command confirms the clients actually overlapped.
   gipity page test "https://dev.gipity.ai/me/app/" --clients 2 \\
     --action "document.querySelector('#name').value='{{label}}'; document.querySelector('form').requestSubmit();" \\
     --observe "document.querySelectorAll('.present').length" \\
-    --labels Alice,Bob`)
+    --labels Alice,Bob
+
+  # Asymmetric roles in ONE invocation: {{label}} in the URL routes client 0 to
+  # host and client 1 to join. They overlap in time (verified), so the joiner
+  # observes the live state the host is driving — no background-process dance.
+  gipity page test "https://dev.gipity.ai/me/app/?test-action={{label}}" --clients 2 \\
+    --labels host,join \\
+    --observe "document.querySelector('[data-screen]')?.dataset.screen"`)
     .action((url, opts) => run('Page test', async () => {
     if (opts.observe) {
         await runInteractive(url, opts.observe, opts);

package/dist/commands/records.js

@@ -1,9 +1,13 @@
 import { Command } from 'commander';
-import { get, post, put, del } from '../api.js';
+import { get, post, put, patch, del } from '../api.js';
 import { requireConfig } from '../config.js';
 import { bold, muted } from '../colors.js';
 import { run, printList, printResult } from '../helpers/index.js';
 import { confirm } from '../utils.js';
+// All commands hit the app API (https://a.gipity.ai/api/<guid>/records/...),
+// which authorizes the logged-in owner via their Bearer token. (The native
+// Records API is the only records surface that exists server-side; there is no
+// /projects/<guid>/records mirror.)
 export const recordsCommand = new Command('records')
     .description('Manage records');
 recordsCommand
@@ -12,8 +16,38 @@ recordsCommand
     .option('--json', 'Output as JSON')
     .action((opts) => run('List', async () => {
     const config = requireConfig();
-    const res = await get(`/projects/${config.projectGuid}/records-config`);
-    printList(res.data, opts, 'No tables configured for Records API.', t => `${bold(t.table_name)}  ${muted(t.auth_level)}  ${muted(`pk=${t.primary_key_column}`)}  ${muted(`db=${t.database_name}`)}`);
+    const res = await get(`/api/${config.projectGuid}/records-config`);
+    printList(res.data, opts, 'No tables configured for Records API. Configure one with `gipity records config <table> --auth <level>`.', t => `${bold(t.table_name)}  ${muted(t.auth_level)}  ${muted(`pk=${t.primary_key_column}`)}  ${muted(`db=${t.database_name}`)}`);
+}));
+recordsCommand
+    .command('config <table>')
+    .description('Show or set a table\'s Records API config (auth level, search, etc.)')
+    .option('--auth <level>', 'Auth level: public (anonymous writes), member (sign-in), or user')
+    .option('--searchable <bool>', 'Enable full-text search (true/false)')
+    .option('--primary-key <col>', 'Primary key column (default: id)')
+    .option('--soft-delete <col>', 'Soft-delete column (pass "none" to clear)')
+    .option('--json', 'Output as JSON')
+    .action((table, opts) => run('Config', async () => {
+    const config = requireConfig();
+    const base = `/api/${config.projectGuid}/records/${table}/config`;
+    // No setter flags → just show the current config.
+    const setting = opts.auth || opts.searchable !== undefined || opts.primaryKey || opts.softDelete;
+    if (!setting) {
+        const res = await get(base);
+        printResult(JSON.stringify(res.data, null, 2), opts, res.data);
+        return;
+    }
+    const body = {};
+    if (opts.auth)
+        body.auth_level = opts.auth;
+    if (opts.searchable !== undefined)
+        body.searchable = /^(true|1|on|yes)$/i.test(String(opts.searchable));
+    if (opts.primaryKey)
+        body.primary_key_column = opts.primaryKey;
+    if (opts.softDelete)
+        body.soft_delete_column = opts.softDelete === 'none' ? null : opts.softDelete;
+    const res = await patch(base, body);
+    printResult(`Configured "${table}": auth=${res.data.auth_level}, searchable=${res.data.searchable}, pk=${res.data.primary_key_column}`, opts, res.data);
 }));
 recordsCommand
     .command('query <table>')
@@ -35,7 +69,7 @@ recordsCommand
     params.set('offset', opts.offset);
     if (opts.fields)
         params.set('fields', opts.fields);
-    const res = await get(`/projects/${config.projectGuid}/records/${table}?${params}`);
+    const res = await get(`/api/${config.projectGuid}/records/${table}?${params}`);
     if (opts.json) {
         console.log(JSON.stringify(res));
     }
@@ -54,7 +88,7 @@ recordsCommand
     .option('--json', 'Output as JSON')
     .action((table, id, opts) => run('Get', async () => {
     const config = requireConfig();
-    const res = await get(`/projects/${config.projectGuid}/records/${table}/${id}`);
+    const res = await get(`/api/${config.projectGuid}/records/${table}/${id}`);
     console.log(opts.json ? JSON.stringify(res.data) : JSON.stringify(res.data, null, 2));
 }));
 recordsCommand
@@ -65,7 +99,7 @@ recordsCommand
     .action((table, opts) => run('Create', async () => {
     const config = requireConfig();
     const data = JSON.parse(opts.data);
-    const res = await post(`/projects/${config.projectGuid}/records/${table}`, data);
+    const res = await post(`/api/${config.projectGuid}/records/${table}`, data);
     printResult(`Created: ${JSON.stringify(res.data)}`, opts, res.data);
 }));
 recordsCommand
@@ -76,7 +110,7 @@ recordsCommand
     .action((table, id, opts) => run('Update', async () => {
     const config = requireConfig();
     const data = JSON.parse(opts.data);
-    const res = await put(`/projects/${config.projectGuid}/records/${table}/${id}`, data);
+    const res = await put(`/api/${config.projectGuid}/records/${table}/${id}`, data);
     printResult(`Updated: ${JSON.stringify(res.data)}`, opts, res.data);
 }));
 recordsCommand
@@ -88,7 +122,7 @@ recordsCommand
         return;
     }
     const config = requireConfig();
-    await del(`/projects/${config.projectGuid}/records/${table}/${id}`);
+    await del(`/api/${config.projectGuid}/records/${table}/${id}`);
     printResult('Deleted.', { json: false });
 }));
 //# sourceMappingURL=records.js.map

package/dist/commands/remove.js

@@ -0,0 +1,42 @@
+import { Command } from 'commander';
+import { post } from '../api.js';
+import { requireConfig } from '../config.js';
+import { sync } from '../sync.js';
+import { success, muted } from '../colors.js';
+import { run } from '../helpers/index.js';
+import { confirm } from '../utils.js';
+export const removeCommand = new Command('remove')
+    .description('Remove an installed kit from the project (inverse of `gipity add <kit>`).')
+    .argument('<kit>', 'Kit key/directory under src/packages/ to remove')
+    .option('-y, --yes', 'Skip the confirmation prompt')
+    .option('--json', 'Output as JSON')
+    .action((kit, opts) => run('Remove', async () => {
+    const config = requireConfig();
+    if (!opts.yes && !opts.json) {
+        if (!await confirm(`Remove the "${kit}" kit (its files, import-map entries, and gipity.yaml wiring)?`)) {
+            console.log('Cancelled.');
+            return;
+        }
+    }
+    const res = await post(`/projects/${config.projectGuid}/remove`, { name: kit });
+    // Force the pull so the kit's deletions land locally without tripping the
+    // bulk-deletion guard - the removal is an explicit, user-invoked action.
+    const syncResult = await sync({ interactive: false, force: true });
+    const data = res.data;
+    if (opts.json) {
+        console.log(JSON.stringify({ ...data, synced: syncResult.applied }));
+        return;
+    }
+    console.log(success(`Removed the "${data.kit}" kit.`));
+    for (const r of data.removed)
+        console.log(muted(`  - ${r}`));
+    if (data.notes?.length) {
+        console.log('');
+        for (const n of data.notes)
+            console.log(n);
+    }
+    if (syncResult.applied > 0) {
+        console.log(`\nPulled ${syncResult.applied} change(s) to local.`);
+    }
+}));
+//# sourceMappingURL=remove.js.map

package/dist/commands/sandbox.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { readFileSync } from 'fs';
+import { readFileSync, existsSync, statSync } from 'fs';
 import { dirname, extname, relative } from 'path';
 import { post } from '../api.js';
 import { resolveProjectContext, getConfigPath } from '../config.js';
@@ -14,6 +14,19 @@ const LANG_MAP = {
     bash: 'bash',
     sh: 'bash',
 };
+// Interpreter tokens accepted at the head of a `run <interpreter> <file>`
+// invocation (e.g. `gipity sandbox run python build_report.py`), mirroring how
+// you'd launch a script locally. Maps each token to the canonical language.
+const INTERPRETERS = {
+    python: 'python',
+    python3: 'python',
+    py: 'python',
+    node: 'javascript',
+    js: 'javascript',
+    javascript: 'javascript',
+    bash: 'bash',
+    sh: 'bash',
+};
 /** Project-relative path from the process cwd, or undefined when there's
  *  no local config (one-off mode) or the cwd is at/above the project root. */
 function resolveRelativeCwd() {
@@ -29,7 +42,7 @@ function resolveRelativeCwd() {
 export const sandboxCommand = new Command('sandbox')
     .description('Run code in a sandbox');
 sandboxCommand
-    .command('run [code]')
+    .command('run [args...]')
     .description('Run code')
     .option('--language <language>', 'Language: js, py, or bash', 'js')
     .option('--file <path>', 'Read the code body from a file instead of the inline <code> arg; --language is inferred from the extension when not given')
@@ -59,6 +72,8 @@ Examples:
 
   # Run a script file directly (language inferred from .py)
   $ gipity sandbox run --file build_report.py
+  $ gipity sandbox run python build_report.py   # same thing, interpreter shorthand
+  $ gipity sandbox run bash "echo hi; ffmpeg -version"   # inline, language pinned
 
   # Surgical: only these files are mirrored in
   $ gipity sandbox run --language bash \\
@@ -73,31 +88,62 @@ Pre-installed: Python (pandas, numpy, matplotlib, Pillow, scipy, bs4),
 CLI tools (ImageMagick, FFmpeg, webp/cwebp, optipng, jq, pandoc, exiftool,
 GCC/Rust).
 `)
-    .action((code, opts, command) => run('Sandbox', async () => {
+    .action((args = [], opts, command) => run('Sandbox', async () => {
     const { config } = await resolveProjectContext();
-    if (code !== undefined && opts.file) {
+    // Resolve the positional args into either inline code or a script-file path.
+    // `run <interpreter> <file>` (e.g. `run python build_report.py`) is the natural
+    // mental model, so accept it: a leading interpreter token + a path becomes
+    // --file with the language pinned by the interpreter. A single positional is
+    // inline code, same as before.
+    let inlineCode;
+    let filePath = opts.file;
+    let langFromInterp;
+    if (args.length >= 2 && INTERPRETERS[args[0].toLowerCase()] !== undefined) {
+        langFromInterp = INTERPRETERS[args[0].toLowerCase()];
+        const rest = args.slice(1).join(' ');
+        // `run python build_report.py` -> a script file; `run bash "echo hi"` -> inline code.
+        if (existsSync(rest) && statSync(rest).isFile())
+            filePath = rest;
+        else
+            inlineCode = rest;
+    }
+    else if (args.length === 1) {
+        inlineCode = args[0];
+    }
+    else if (args.length > 1) {
+        console.error(clrError('Unrecognized invocation. Pass inline code as a single quoted arg, a script with --file <path>, or use the `run <python|node|bash> <file>` shorthand.'));
+        process.exit(1);
+    }
+    if (inlineCode !== undefined && filePath) {
         console.error(clrError('Pass either an inline <code> arg or --file <path>, not both'));
         process.exit(1);
     }
-    if (code === undefined && !opts.file) {
+    if (inlineCode === undefined && !filePath) {
         console.error(clrError('Provide an inline <code> arg or --file <path>'));
         process.exit(1);
     }
-    let source = code;
-    if (opts.file) {
+    let source = inlineCode;
+    if (filePath) {
         try {
-            source = readFileSync(opts.file, 'utf8');
+            source = readFileSync(filePath, 'utf8');
         }
         catch {
-            console.error(clrError(`Cannot read file: ${opts.file}`));
+            console.error(clrError(`Cannot read file: ${filePath}`));
             process.exit(1);
         }
     }
-    // Infer language from the file extension unless --language was given explicitly.
-    const fromExt = opts.file && command.getOptionValueSource('language') === 'default'
-        ? LANG_MAP[extname(opts.file).slice(1).toLowerCase()]
+    // Language precedence: interpreter token > file extension (unless --language
+    // was passed explicitly) > the --language value (default js).
+    const fromExt = filePath && !langFromInterp && command.getOptionValueSource('language') === 'default'
+        ? LANG_MAP[extname(filePath).slice(1).toLowerCase()]
         : undefined;
-    const language = fromExt || LANG_MAP[opts.language] || opts.language;
+    const language = langFromInterp || fromExt || LANG_MAP[opts.language] || opts.language;
+    // True when the run fell back to the implicit JS default - nothing in the
+    // command shape pinned a language. Used to explain the execution mode if a
+    // shell/Python snippet gets parsed as JavaScript and blows up (see hint below).
+    const usedDefaultJs = !langFromInterp
+        && command.getOptionValueSource('language') === 'default'
+        && language === 'javascript';
     if (!['javascript', 'python', 'bash'].includes(language)) {
         console.error(clrError(`Invalid language: ${opts.language}. Use: js, py, or bash`));
         process.exit(1);
@@ -138,8 +184,15 @@ GCC/Rust).
             for (const f of res.data.outputFiles)
                 console.log(`${f}`);
         }
-        if (res.data.exitCode !== 0)
+        if (res.data.exitCode !== 0) {
+            // A SyntaxError / CJS-loader trace under the implicit JS default almost
+            // always means the input was shell or Python that got run as JavaScript.
+            // The raw Node stack trace never says which mode ran, so name it.
+            if (usedDefaultJs && /SyntaxError|cjs\/loader|wrapSafe/.test(res.data.stderr || '')) {
+                console.error(dim('Hint: ran as JavaScript (the default). For a shell command pass `--language bash` (or `gipity sandbox run bash "<cmd>"`); for Python pass `--language py`.'));
+            }
             process.exit(res.data.exitCode);
+        }
     }
 }));
 //# sourceMappingURL=sandbox.js.map

package/dist/commands/status.js

@@ -2,7 +2,7 @@ import { Command } from 'commander';
 import { existsSync, readFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { homedir } from 'os';
-import { getAuth, getTimeRemaining } from '../auth.js';
+import { getAuth, sessionExpired } from '../auth.js';
 import { getConfig, liveUrl } from '../config.js';
 import { brand, success, warning, muted, error as clrError } from '../colors.js';
 import { GIPITY_PLUGIN_ID, GIPITY_MARKETPLACE_NAME, setupClaudeHooks, ensureGipityPlugin } from '../setup.js';
@@ -44,10 +44,11 @@ export const statusCommand = new Command('status')
                 apiBase: config.apiBase,
                 url: liveUrl(config),
             } : null,
+            // `valid` reflects the refresh token (the real session) - access
+            // tokens auto-renew, so their expiry must not read as "invalid".
             auth: auth ? {
                 email: auth.email,
-                expiresAt: auth.expiresAt,
-                valid: new Date(auth.expiresAt).getTime() > Date.now(),
+                valid: !sessionExpired(),
             } : null,
             plugin: hookCheck,
         }, null, 2));
@@ -67,8 +68,11 @@ export const statusCommand = new Command('status')
     if (!auth) {
         console.log(`${muted('Auth:')} ${warning('not logged in. Run: gipity login')}`);
     }
+    else if (sessionExpired()) {
+        console.log(`${muted('Auth:')} ${warning(`session expired for ${auth.email}. Run: gipity login`)}`);
+    }
     else {
-        console.log(`${muted('Auth:')} ${success(auth.email)} ${muted(`(${getTimeRemaining()})`)}`);
+        console.log(`${muted('Auth:')} ${success(auth.email)}`);
     }
     if (hookCheck) {
         if (hookCheck.ok) {

package/dist/commands/test.js

@@ -100,8 +100,11 @@ async function pollTestStatus(projectGuid, runGuid, opts) {
                     const progress = data.totalFiles === 0
                         ? 'starting up'
                         : `${data.completedFiles}/${data.totalFiles} files`;
+                    // "so far" so a heartbeat line, if captured on its own (tail/grep),
+                    // can't be mistaken for the final tally — the partial count climbing
+                    // toward the total previously read as "tests vanished".
                     const tally = data.passed + data.failed > 0
-                        ? ` (${data.passed} passed${data.failed > 0 ? `, ${data.failed} failed` : ''})`
+                        ? ` (${data.passed} passed${data.failed > 0 ? `, ${data.failed} failed` : ''} so far)`
                         : '';
                     console.log(muted(`  … still running — ${progress}${tally}, ${elapsed}s elapsed`));
                     if (now - startTime >= LONG_RUN_MS && !longRunHintShown) {
@@ -168,17 +171,24 @@ export const testCommand = new Command('test')
     if (data.skipped > 0)
         parts.push(muted(`${data.skipped} skipped`));
     console.log(`${parts.join(', ')} ${muted(`(${data.durationMs}ms)`)}`);
+    // The run's results are stored; re-fetch them (no re-run) by GUID.
+    console.log(muted(`Re-fetch this run's details (no re-run): gipity test status ${runGuid} --json`));
     if (data.failed > 0)
         process.exit(1);
 }));
 // ── Status subcommand (check on a running test) ──────────────────────
 testCommand
     .command('status')
-    .description('Check a test run')
+    .alias('results')
+    .description('Fetch a finished (or running) test run by GUID — full per-test results, no re-run')
     .argument('<runGuid>', 'Test run GUID (e.g. tr_abc123)')
     .option('--json', 'Output as JSON')
     .option('--follow', 'Follow until complete (poll)')
-    .action((runGuid, opts) => run('Status', async () => {
+    // optsWithGlobals: the parent `test` command also declares `--json`, and with
+    // root-level enablePositionalOptions commander attaches a post-subcommand
+    // `--json` to that parent — so the subcommand's own opts would miss it.
+    .action((runGuid, _o, command) => run('Status', async () => {
+    const opts = command.optsWithGlobals();
     const config = requireConfig();
     if (opts.follow) {
         const data = await pollTestStatus(config.projectGuid, runGuid, opts);
@@ -217,7 +227,9 @@ testCommand
     .description('Show recent runs')
     .option('--limit <n>', 'Number of runs to show', '10')
     .option('--json', 'Output as JSON')
-    .action((opts) => run('History', async () => {
+    // optsWithGlobals: see the status subcommand — `--json` lands on the parent.
+    .action((_o, command) => run('History', async () => {
+    const opts = command.optsWithGlobals();
     const config = requireConfig();
     const res = await get(`/projects/${config.projectGuid}/test/history?limit=${opts.limit}`);
     if (opts.json) {

package/dist/commands/text.js

@@ -42,7 +42,7 @@ function formatProfile(a) {
     row('Sentences', a.sentences);
     row('Lines', a.lines);
     row('Paragraphs', a.paragraphs);
-    if (a.words) {
+    if (a.longestWord) {
         row('Longest word', `${a.longestWord} (${[...a.longestWord].length})`);
         row('Shortest word', `${a.shortestWord} (${[...a.shortestWord].length})`);
         row('Avg word length', a.averageWordLength);