@ishlabs/cli 0.17.7 → 0.18.0

package/dist/commands/{profile.js → person.js}

@@ -1,39 +1,38 @@
 /**
- * ish profile — Manage profiles, audience generation, and source uploads.
+ * ish person — Manage people, generation, and source uploads.
  */
 import fs from "node:fs";
 import { withClient, readJsonFileOrStdin, resolveWorkspace } from "../lib/command-helpers.js";
 import { resolveId, tagAlias, ALIAS_PREFIX } from "../lib/alias-store.js";
-import { formatTesterProfileList, formatGeneratedProfileList, output, } from "../lib/output.js";
+import { formatPersonList, output, } from "../lib/output.js";
 import { resolveTextContent } from "../lib/upload.js";
-import { isUuid, resolveSourceRef } from "../lib/profile-sources.js";
+import { isUuid, pollGenerationJobUntilDone, resolveSourceRef, } from "../lib/profile-sources.js";
 import { assertEnumValue, EDUCATION_LEVELS, EVIDENCE_SOURCES, HOUSEHOLDS, LOCALE_TYPES, INCOME_LEVELS, EMPLOYMENT_STATUSES, } from "../lib/enums.js";
 import { validateAccessibilityProfile } from "../lib/accessibility-profile.js";
 function collect(value, prev) {
     return prev.concat(value);
 }
-export function registerProfileCommands(program) {
-    const profile = program
-        .command("profile")
-        .alias("tester-profile")
-        .description("Manage profiles, audience generation, and source uploads")
+export function registerPersonCommands(program) {
+    const person = program
+        .command("person")
+        .description("Manage people, generation, and source uploads")
         .addHelpText("after", `
-A tester profile is a reusable audience persona scoped to a workspace.
-\`ish profile generate\` produces profiles from a written brief and/or sources
-(transcripts, audio, images, PDFs). Distinct from a "tester" (\`t-\`), which is one
-instance of a profile inside one iteration.
+A person is a reusable persona scoped to a workspace.
+\`ish person generate\` produces people from a written brief and/or sources
+(transcripts, audio, images, PDFs). Distinct from a "participant" (\`pt-\`), which is one
+instance of a person inside one iteration.
 
-Concept pages: ish docs get-page concepts/profile
+Concept pages: ish docs get-page concepts/person
                 ish docs get-page concepts/source
-                ish docs get-page concepts/audience`);
-    profile
+                ish docs get-page concepts/people`);
+    person
         .command("list")
-        .description("List profiles (defaults to simulatable AI profiles)")
+        .description("List people (defaults to simulatable AI people)")
         .option("--workspace <id>", "Filter by workspace ID")
-        .option("--search <query>", "Substring match against profile name")
-        .option("--bio <text>", "Substring match against profile bio")
-        .option("--occupation <text>", "Substring match against profile occupation (repeatable)", collect, [])
-        .option("--type <type>", "Profile type: ai, human, all (default: ai)", "ai")
+        .option("--search <query>", "Substring match against person name")
+        .option("--bio <text>", "Substring match against person bio")
+        .option("--occupation <text>", "Substring match against person occupation (repeatable)", collect, [])
+        .option("--type <type>", "Person type: ai, human, all (default: ai)", "ai")
         .option("--gender <gender>", "Filter by gender (repeatable)", collect, [])
         .option("--country <country>", "Filter by country code, e.g. US (repeatable)", collect, [])
         .option("--min-age <n>", "Minimum age")
@@ -42,16 +41,16 @@ Concept pages: ish docs get-page concepts/profile
         .option("--offset <n>", "Offset for pagination", "0")
         .addHelpText("after", `
 Examples:
-  $ ish profile list
-  $ ish profile list --search "engineer" --country US
-  $ ish profile list --bio "voice-first user"
-  $ ish profile list --occupation founder --occupation designer
-  $ ish profile list --gender female --gender male --country US --country GB
-  $ ish profile list --type all --json
+  $ ish person list
+  $ ish person list --search "engineer" --country US
+  $ ish person list --bio "voice-first user"
+  $ ish person list --occupation founder --occupation designer
+  $ ish person list --gender female --gender male --country US --country GB
+  $ ish person list --type all --json
 
   # Pagination: default --limit is 50, iterate with --offset.
-  $ ish profile list --limit 100
-  $ ish profile list --limit 100 --offset 100   # next page
+  $ ish person list --limit 100
+  $ ish person list --limit 100 --offset 100   # next page
   # When more results exist, a stderr hint surfaces the next --offset / --limit.`)
         .action(async (opts, cmd) => {
         await withClient(cmd, async (client, globals) => {
@@ -76,8 +75,8 @@ Examples:
                 params.min_age = opts.minAge;
             if (opts.maxAge)
                 params.max_age = opts.maxAge;
-            const data = await client.get("/tester-profiles", params);
-            formatTesterProfileList(data, globals.json, parseInt(opts.limit, 10));
+            const data = await client.get("/people", params);
+            formatPersonList(data, globals.json, parseInt(opts.limit, 10));
             // Pattern H1: when there's more data, surface a stderr hint so agents
             // know `--limit / --offset` exist without re-reading help. Stderr only,
             // so it doesn't pollute machine-readable stdout — that means we DON'T
@@ -85,7 +84,7 @@ Examples:
             // exactly when the agent needs it most). --quiet is the explicit
             // opt-out for progress chatter.
             //
-            // The raw `/tester-profiles` envelope is `{items, total, limit, offset}`
+            // The raw `/people` envelope is `{items, total, limit, offset}`
             // — `has_more` and `returned` are synthesized client-side by `wrapList`
             // only when the response is rendered. Compute them locally here so the
             // hint actually fires; reading `data.has_more` directly would always
@@ -103,55 +102,61 @@ Examples:
             }
         });
     });
-    profile
+    person
         .command("create")
-        .description("Create a profile from an exact JSON spec (no LLM)")
-        .requiredOption("--file <path>", "JSON file with profile data")
+        .description("Create a person from an exact JSON spec (no LLM)")
+        .requiredOption("--file <path>", "JSON file with person data")
         .option("--workspace <id>", "Workspace (product) ID; falls back to active workspace")
-        .addHelpText("after", "\nExamples:\n  $ ish profile create --file profile.json\n\n  Expected JSON: { \"name\": \"...\", \"type\": \"ai\", \"gender\": \"female\", \"country\": \"US\", \"occupation\": \"...\", \"bio\": \"...\" }")
+        .addHelpText("after", "\nExamples:\n  $ ish person create --file profile.json\n\n  Expected JSON: { \"name\": \"...\", \"type\": \"ai\", \"gender\": \"female\", \"country\": \"US\", \"occupation\": \"...\", \"bio\": \"...\" }")
         .action(async (opts, cmd) => {
         await withClient(cmd, async (client, globals) => {
             const body = await readJsonFileOrStdin(opts.file);
             if (opts.workspace || body.product_id == null) {
                 body.product_id = resolveWorkspace(opts.workspace);
             }
-            const data = await client.post("/tester-profiles", body);
+            const data = await client.post("/people", body);
             const result = data;
             if (result.id)
-                result.alias = tagAlias(ALIAS_PREFIX.testerProfile, String(result.id));
+                result.alias = tagAlias(ALIAS_PREFIX.person, String(result.id));
             output(result, globals.json, { writePath: true });
         });
     });
-    profile
+    person
         .command("generate")
-        .description("Generate one or many profiles via LLM (audience generation)")
-        .option("--description <text>", "Audience description (use @path to read from file)")
+        .description("Generate people plus evidence-grounded scenarios from a brief and/or sources")
+        .option("--description <text>", "Description / researcher brief (use @path to read from file)")
         .option("--description-file <path>", "Read description from a file")
         .option("--source <id-or-path>", "Source UUID or local file path; auto-uploads paths (repeatable)", collect, [])
-        .option("--source-description <text>", "Per-source context note (paired with --source by index, repeatable). Only applies to local-path sources — for already-uploaded aliases the description is whatever was set at upload time.", collect, [])
+        .option("--source-description <text>", "Per-source researcher note — how the person reacted to THAT file. Paired with --source by index (repeatable). Only applies to local-path sources; for already-uploaded aliases the note is whatever was set at upload time.", collect, [])
         .option("--diarize", "Apply speaker diarization to audio sources (silently ignored for text/image)")
-        .option("--count <n>", "Number of profiles to generate (1-10). Omit to let the model propose")
-        .option("--propose-count", "Print the LLM's suggested audience size for a single processed source and exit (no generation)")
+        .option("--count <n>", "Number of people to generate (1-10). Omit to let the model propose a count")
+        .option("--propose-count", "Print the LLM's suggested count for a single processed source and exit (no generation)")
         .option("--workspace <id>", "Workspace (product) ID; falls back to active workspace")
+        .option("--no-scenarios", "Skip fetching the evidence-grounded scenarios for each generated person")
         .option("--no-wait", "Don't poll source-processing status. Only relevant when --source is a local path (paths get auto-uploaded and processed).")
-        .option("--timeout <seconds>", "Source-processing poll timeout in seconds. Only relevant when --source is a local path.", "300")
-        .option("--include-simulation-config", "Include the full simulation_config (system prompt + model settings) on each generated profile in JSON output")
+        .option("--source-timeout <seconds>", "Source-processing poll timeout in seconds. Only relevant when --source is a local path.", "300")
+        .option("--timeout <seconds>", "Generation-job poll timeout in seconds (default 600). The job keeps running server-side past this; re-poll, don't re-enqueue.", "600")
         .addHelpText("after", `
-Examples:
-  # Generate 3 profiles from a description
-  $ ish profile generate --description "Tech-savvy millennials in the US who use mobile banking" --count 3
+Generation is an async job: ish enqueues it, polls until the people plus
+their evidence-grounded scenarios are ready (~30-60s), then prints them. The
+job reads your brief and any uploaded sources (transcripts, emails, PDFs,
+audio, images) describing how real people reacted, and grounds each generated
+scenario in those reactions. Provide --description (>=10 chars) and/or --source.
 
-  # Generate one profile from a transcript (auto-uploads the file)
-  $ ish profile generate --source ./interviews/sarah.txt --count 1
+Examples:
+  # Generate 3 people from a description
+  $ ish person generate --description "Tech-savvy millennials in the US who use mobile banking" --count 3
 
-  # Generate 5 profiles from an audio call + a written brief
-  $ ish profile generate --description "Voices behind support tickets" --source ./call.mp3 --diarize --count 5
+  # Ground a person in how someone reacted to a real artifact
+  $ ish source upload ./proposal.eml --description "called this proposal lazy and vague"
+  # → ps-3a4
+  $ ish person generate --description "Skeptical enterprise buyer" --source ps-3a4 --count 1 --json
 
-  # Use a previously-uploaded source by alias
-  $ ish profile generate --source tps-3a4 --count 2
+  # Inline source upload with a per-file researcher note
+  $ ish person generate --description "Voices behind support tickets" --source ./call.mp3 --source-description "frustrated about repeated transfers" --diarize --count 5
 
-  # Ask the LLM how many profiles a processed source warrants (no generation)
-  $ ish profile generate --source tps-3a4 --propose-count`)
+  # Ask the LLM how many people a processed source warrants (no generation)
+  $ ish person generate --source ps-3a4 --propose-count`)
         .action(async (opts, cmd) => {
         await withClient(cmd, async (client, globals) => {
             const productId = resolveWorkspace(opts.workspace);
@@ -167,9 +172,9 @@ Examples:
                 const raw = opts.source[0];
                 const id = isUuid(raw) ? raw : tryResolveSourceAlias(raw);
                 if (!id) {
-                    throw new Error("--propose-count expects an uploaded source ID or alias (e.g. tps-3a4). Upload first with `ish source upload`.");
+                    throw new Error("--propose-count expects an uploaded source ID or alias (e.g. ps-3a4). Upload first with `ish source upload`.");
                 }
-                const data = await client.post(`/tester-profiles/sources/${id}/propose-count`, undefined, { timeout: 60_000 });
+                const data = await client.post(`/people/attachments/${id}/propose-count`, undefined, { timeout: 60_000 });
                 output(data, globals.json);
                 return;
             }
@@ -183,7 +188,24 @@ Examples:
             if (!description && opts.source.length === 0) {
                 throw new Error("Provide --description, --description-file, or at least one --source.");
             }
-            const timeoutMs = Math.max(1, parseInt(opts.timeout, 10)) * 1000;
+            // The backend requires a description of >=10 chars when one is given.
+            // Catch it before uploading sources / enqueueing so the agent gets a
+            // fast, local validation error rather than a 422 mid-flight.
+            if (description !== undefined && description.trim().length > 0 && description.trim().length < 10) {
+                throw new Error("--description must be at least 10 characters when provided.");
+            }
+            let count;
+            if (opts.count) {
+                const n = parseInt(opts.count, 10);
+                if (Number.isNaN(n) || n < 1 || n > 10) {
+                    throw new Error("--count must be an integer between 1 and 10.");
+                }
+                count = n;
+            }
+            // --timeout bounds the generation-job poll; --source-timeout bounds the
+            // (separate) source-processing poll that only runs for local-path sources.
+            const jobTimeoutMs = Math.max(1, parseInt(opts.timeout, 10)) * 1000;
+            const sourceTimeoutMs = Math.max(1, parseInt(opts.sourceTimeout, 10)) * 1000;
             const wait = opts.wait !== false;
             if (opts.sourceDescription.length > opts.source.length) {
                 throw new Error(`Got ${opts.sourceDescription.length} --source-description value(s) but only ${opts.source.length} --source value(s). Each --source-description is paired with --source by position; provide one --source per --source-description.`);
@@ -196,13 +218,13 @@ Examples:
                 // Treat as alias if it matches our prefix pattern.
                 const candidate = isUuid(raw) ? raw : tryResolveSourceAlias(raw);
                 if (candidate) {
-                    // Already-uploaded source: the backend's GenerateAudienceRequest accepts
-                    // only source_upload_ids, no per-source description override. The
-                    // description set at upload time (ConfirmSourceUploadRequest.description)
-                    // is what the LLM sees. Silently dropping a CLI-supplied description here
-                    // is the M3 bug — error out instead so the user knows.
+                    // Already-uploaded source: the job request carries only
+                    // source_upload_ids, no per-source description override. The
+                    // researcher note set at upload time (the confirm `description`) is
+                    // what the pipeline reads. Silently dropping a CLI-supplied note
+                    // here is the M3 bug — error out instead so the user knows.
                     if (desc !== undefined) {
-                        throw new Error(`--source-description for "${raw}" is ignored because that source is already uploaded — the description set at upload time is what generate uses.\n` +
+                        throw new Error(`--source-description for "${raw}" is ignored because that source is already uploaded — the note set at upload time is what generate uses.\n` +
                             "Either:\n" +
                             "  - Drop --source-description for this source, OR\n" +
                             "  - Re-upload via path: --source <local-path> --source-description \"...\"");
@@ -215,7 +237,7 @@ Examples:
                     description: desc,
                     diarize: opts.diarize,
                     wait,
-                    timeoutMs,
+                    timeoutMs: sourceTimeoutMs,
                     quiet: globals.quiet,
                 });
                 sourceIds.push(id);
@@ -227,48 +249,61 @@ Examples:
                 body.description = description;
             if (sourceIds.length > 0)
                 body.source_upload_ids = sourceIds;
-            if (opts.count) {
-                const n = parseInt(opts.count, 10);
-                if (Number.isNaN(n) || n < 1 || n > 10) {
-                    throw new Error("--count must be an integer between 1 and 10.");
-                }
-                body.count = n;
-            }
-            // Pattern D1: emit stderr progress before the LLM call so agents (and
-            // humans) see something is happening during the ~10–20s wait. Mirrors
-            // the `--wait` ergonomics on `ask create` / `study run`.
+            if (count !== undefined)
+                body.count = count;
+            // Enqueue the agentic generation job. It turns the evidence bundle
+            // (brief + sources describing real reactions) into people plus
+            // scenarios grounded in those reactions — runs ~30-60s.
             if (!globals.quiet) {
-                const target = body.count ? `${body.count} profile${body.count === 1 ? "" : "s"}` : "profiles";
-                console.error(`  generating ${target}...`);
-            }
-            // /generate is LLM-backed and slow.
-            const profiles = await client.post("/tester-profiles/generate", body, { timeout: 180_000 });
+                const target = count ? `${count} person${count === 1 ? "" : "s"}` : "people";
+                console.error(`  enqueuing generation job for ${target}...`);
+            }
+            const job = await client.post("/people/generation-jobs", body, { timeout: 60_000 });
+            const final = await pollGenerationJobUntilDone(client, job.id, {
+                timeoutMs: jobTimeoutMs,
+                quiet: globals.quiet,
+            });
+            if (final.status === "failed") {
+                throw new Error(`Generation job failed: ${final.error ?? "unknown error"}`);
+            }
+            const personIds = final.person_ids ?? [];
             if (!globals.quiet) {
-                console.error(`  generated ${profiles.length} profile${profiles.length === 1 ? "" : "s"}`);
-            }
-            // simulation_config is the inlined system prompt + model settings — ~3.5KB
-            // of mostly-identical boilerplate per profile. Strip it from the default
-            // JSON output; users who need it can pass --include-simulation-config or
-            // fetch it later via `profile get --json`.
-            const trimmed = opts.includeSimulationConfig
-                ? profiles
-                : profiles.map((p) => {
-                    const { simulation_config: _drop, ...rest } = p;
-                    return rest;
-                });
-            formatGeneratedProfileList(trimmed, globals.json);
+                console.error(`  generated ${personIds.length} person${personIds.length === 1 ? "" : "s"}`);
+            }
+            // Fetch each generated person (and, unless --no-scenarios, its
+            // evidence-grounded scenarios) so the output is the people
+            // themselves rather than bare ids.
+            const fetchScenarios = opts.scenarios !== false;
+            const people = await Promise.all(personIds.map(async (pid) => {
+                const person = await client.get(`/people/${pid}`);
+                const record = person;
+                record.alias = tagAlias(ALIAS_PREFIX.person, pid);
+                if (fetchScenarios) {
+                    const scenarios = await client.get(`/people/${pid}/scenarios`);
+                    record.scenarios = scenarios;
+                }
+                return record;
+            }));
+            if (globals.json) {
+                output({
+                    job: { id: job.id, status: final.status, person_ids: personIds },
+                    people,
+                }, true);
+                return;
+            }
+            formatPersonList(people, false);
         });
     });
-    profile
+    person
         .command("get")
-        .description("Get profile details (accepts multiple IDs for batched lookup)")
-        .argument("<ids...>", "Profile ID(s) — one or more aliases/UUIDs (space- or comma-separated)")
+        .description("Get person details (accepts multiple IDs for batched lookup)")
+        .argument("<ids...>", "Person ID(s) — one or more aliases/UUIDs (space- or comma-separated)")
         .addHelpText("after", `
 Examples:
-  $ ish profile get tp-1b9
-  $ ish profile get tp-1b9 --json
-  $ ish profile get tp-1b9 tp-fc1 tp-2fc
-  $ ish profile get tp-1b9,tp-fc1,tp-2fc --fields alias,name,country,occupation
+  $ ish person get p-1b9
+  $ ish person get p-1b9 --json
+  $ ish person get p-1b9 p-fc1 p-2fc
+  $ ish person get p-1b9,p-fc1,p-2fc --fields alias,name,country,occupation
 
 With multiple IDs, returns a {items:[...], total:N} envelope and uses the
 list table layout in human mode. Use --fields to project per-item.`)
@@ -276,38 +311,38 @@ list table layout in human mode. Use --fields to project per-item.`)
         await withClient(cmd, async (client, globals) => {
             const flat = ids.flatMap((s) => s.split(",").map((x) => x.trim()).filter(Boolean));
             if (flat.length === 0)
-                throw new Error("Provide at least one profile id.");
+                throw new Error("Provide at least one person id.");
             if (flat.length === 1) {
-                const data = await client.get(`/tester-profiles/${resolveId(flat[0])}`);
+                const data = await client.get(`/people/${resolveId(flat[0])}`);
                 const result = data;
                 if (result.id)
-                    result.alias = tagAlias(ALIAS_PREFIX.testerProfile, String(result.id));
+                    result.alias = tagAlias(ALIAS_PREFIX.person, String(result.id));
                 output(result, globals.json);
                 return;
             }
             const results = await Promise.all(flat.map(async (raw) => {
-                const data = await client.get(`/tester-profiles/${resolveId(raw)}`);
+                const data = await client.get(`/people/${resolveId(raw)}`);
                 const r = data;
                 if (r.id)
-                    r.alias = tagAlias(ALIAS_PREFIX.testerProfile, String(r.id));
+                    r.alias = tagAlias(ALIAS_PREFIX.person, String(r.id));
                 return r;
             }));
             if (globals.json) {
                 output({ items: results, total: results.length }, true);
             }
             else {
-                formatTesterProfileList(results, false);
+                formatPersonList(results, false);
             }
         });
     });
-    profile
+    person
         .command("update")
-        .description("Update a profile")
-        .argument("<id>", "Profile ID")
+        .description("Update a person")
+        .argument("<id>", "Person ID")
         .option("--file <path>", "JSON file with update data (escape hatch for fields not covered by inline flags)")
-        .option("--name <text>", "Profile name")
-        .option("--description <text>", "Profile description")
-        .option("--bio <text>", "Profile bio")
+        .option("--name <text>", "Person name")
+        .option("--description <text>", "Person description")
+        .option("--bio <text>", "Person bio")
         .option("--occupation <text>", "Occupation")
         .option("--country <code>", "Country code, e.g. US")
         .option("--gender <g>", "Gender, e.g. female")
@@ -320,13 +355,13 @@ list table layout in human mode. Use --fields to project per-item.`)
         .option("--accessibility-profile <json-or-path>", "AccessibilityProfile v1.0 as an inline JSON string OR a path to a JSON file. Empty object {} is the canonical default. Validated client-side against the spec before submit.")
         .addHelpText("after", `
 Examples:
-  $ ish profile update <id> --bio "Edited bio"
-  $ ish profile update <id> --name "Alice" --country US --education-level bachelor
-  $ ish profile update <id> --household couple_with_kids --locale-type suburban
-  $ ish profile update <id> --income-level middle --employment-status employed_full_time
-  $ ish profile update <id> --accessibility-profile '{"version":"1.0","visual":{"uses_screen_reader":true,"text_size":"large"},"cognitive":{"reduce_motion":true},"assistive_tech":["VoiceOver"]}'
-  $ ish profile update <id> --accessibility-profile ./a11y.json
-  $ ish profile update <id> --file updates.json
+  $ ish person update <id> --bio "Edited bio"
+  $ ish person update <id> --name "Alice" --country US --education-level bachelor
+  $ ish person update <id> --household couple_with_kids --locale-type suburban
+  $ ish person update <id> --income-level middle --employment-status employed_full_time
+  $ ish person update <id> --accessibility-profile '{"version":"1.0","visual":{"uses_screen_reader":true,"text_size":"large"},"cognitive":{"reduce_motion":true},"assistive_tech":["VoiceOver"]}'
+  $ ish person update <id> --accessibility-profile ./a11y.json
+  $ ish person update <id> --file updates.json
 
 Inline flags compose into the patch body. --file is an escape hatch when you
 need fields not covered by the inline flags. When both are provided, inline
@@ -381,31 +416,31 @@ Schema: https://ishlabs.io/spec/accessibility-profile-schema.v1.json`)
             if (Object.keys(body).length === 0) {
                 throw new Error("Nothing to update. Provide --file or at least one inline flag (e.g. --bio).");
             }
-            const data = await client.put(`/tester-profiles/${resolveId(id)}`, body);
+            const data = await client.put(`/people/${resolveId(id)}`, body);
             const result = data;
             if (result.id)
-                result.alias = tagAlias(ALIAS_PREFIX.testerProfile, String(result.id));
+                result.alias = tagAlias(ALIAS_PREFIX.person, String(result.id));
             output(result, globals.json, { writePath: true });
         });
     });
-    profile
+    person
         .command("delete")
-        .description("Delete a profile")
-        .argument("<id>", "Profile ID")
-        .option("--workspace <id>", "Workspace ID; accepted for consistency (workspace is inferred from the profile)")
-        .addHelpText("after", "\nExamples:\n  $ ish profile delete <id>")
+        .description("Delete a person")
+        .argument("<id>", "Person ID")
+        .option("--workspace <id>", "Workspace ID; accepted for consistency (workspace is inferred from the person)")
+        .addHelpText("after", "\nExamples:\n  $ ish person delete <id>")
         .action(async (id, _opts, cmd) => {
         await withClient(cmd, async (client, globals) => {
             const rid = resolveId(id);
-            await client.del(`/tester-profiles/${rid}`);
-            output({ id: rid, alias: tagAlias(ALIAS_PREFIX.testerProfile, rid), message: "Profile deleted" }, globals.json, { writePath: true });
+            await client.del(`/people/${rid}`);
+            output({ id: rid, alias: tagAlias(ALIAS_PREFIX.person, rid), message: "Profile deleted" }, globals.json, { writePath: true });
         });
     });
-    profile
+    person
         .command("suggest-scenarios")
-        .description("Ask the LLM for scenario probes to craft a specific simulated tester")
+        .description("Ask the LLM for scenario probes to craft a specific simulated person")
         .option("--workspace <id>", "Workspace (product) ID; falls back to active workspace")
-        .option("--context <text>", "What you already know about this tester. Use @path to read from file.")
+        .option("--context <text>", "What you already know about this participant. Use @path to read from file.")
         .option("--context-file <path>", "Read --context from a file")
         .option("--count <n>", "Number of scenarios to return (1-10, default 5)")
         .option("--previous-answers <json-or-@path>", "Answers already collected this session. Inline JSON, @/path/to.json, or - for stdin. Array of {type, prompt, answer}; max 40.")
@@ -413,23 +448,23 @@ Schema: https://ishlabs.io/spec/accessibility-profile-schema.v1.json`)
         .addHelpText("after", `
 Examples:
   # Bare invocation: 5 scenarios from a free-form context blob
-  $ ish profile suggest-scenarios --context "Mid-career engineer who handles oncall for a Stripe-using fintech"
+  $ ish person suggest-scenarios --context "Mid-career engineer who handles oncall for a Stripe-using fintech"
 
   # Load context from a file, ask for 3 scenarios
-  $ ish profile suggest-scenarios --context-file ./persona-notes.md --count 3
+  $ ish person suggest-scenarios --context-file ./persona-notes.md --count 3
 
   # Follow-up probe: skip prompts already shown, build on prior answers
-  $ ish profile suggest-scenarios \\
+  $ ish person suggest-scenarios \\
       --context "$(cat notes.md)" \\
       --count 3 \\
       --already-surfaced '["How do you triage 02:00 pages?"]' \\
       --previous-answers @./answers.json
 
   # Capture just the first scenario's type
-  $ ish profile suggest-scenarios --context "..." --count 1 --get scenarios[0].type
+  $ ish person suggest-scenarios --context "..." --count 1 --get scenarios[0].type
 
-The loop: suggest → answer locally → persist via \`ish profile evidence add <id>\` (read back with \`evidence list\`).
-See \`ish docs get-page guides/build-specific-tester\` for the full workflow.`)
+The loop: suggest → answer locally → persist via \`ish person evidence add <id>\` (read back with \`evidence list\`).
+See \`ish docs get-page guides/build-specific-participant\` for the full workflow.`)
         .action(async (opts, cmd) => {
         await withClient(cmd, async (client, globals) => {
             const productId = resolveWorkspace(opts.workspace);
@@ -493,44 +528,44 @@ See \`ish docs get-page guides/build-specific-tester\` for the full workflow.`)
                 const target = body.count ?? 5;
                 console.error(`  suggesting ${target} scenario${target === 1 ? "" : "s"}...`);
             }
-            const data = await client.post("/tester-profiles/suggest-scenarios", body, { timeout: 180_000 });
+            const data = await client.post("/people/suggest-scenarios", body, { timeout: 180_000 });
             output(data, globals.json);
         });
     });
-    const evidence = profile
+    const evidence = person
         .command("evidence")
-        .description("Manage scenario-answer evidence on a tester profile")
+        .description("Manage scenario-answer evidence on a person")
         .addHelpText("after", `
 Evidence rows persist answers to \`suggest-scenarios\` probes onto a
-specific profile. The \`source\` field on every trace is the same enum
+specific person. The \`source\` field on every trace is the same enum
 as the \`type\` field on a suggested scenario — copy verbatim when
 building a traces.json.
 
-Guide: ish docs get-page guides/build-specific-tester`);
+Guide: ish docs get-page guides/build-specific-participant`);
     evidence
         .command("add")
-        .description("Persist scenario answers as structured evidence on a profile")
-        .argument("<id>", "Profile ID (alias or UUID)")
+        .description("Persist scenario answers as structured evidence on a person")
+        .argument("<id>", "Person ID (alias or UUID)")
         .option("--traces <json-or-@path>", `Array of {text, source, scenario_prompt?, raw_response?} where source ∈ ${EVIDENCE_SOURCES.join("|")}. Inline JSON, @/path/to.json, or - for stdin.`)
         .option("--traces-file <path>", "Read --traces from a JSON file")
         .addHelpText("after", `
 Examples:
   # Inline JSON for a single trace
-  $ ish profile evidence add tp-d4e --traces '[{"text":"I would page my staff engineer first.","source":"situation","scenario_prompt":"PagerDuty fires at 02:00."}]'
+  $ ish person evidence add p-d4e --traces '[{"text":"I would page my staff engineer first.","source":"situation","scenario_prompt":"PagerDuty fires at 02:00."}]'
 
   # From a file
-  $ ish profile evidence add tp-d4e --traces-file ./answers.json
+  $ ish person evidence add p-d4e --traces-file ./answers.json
 
   # From stdin (pipe-friendly)
-  $ jq -c '.traces' session.json | ish profile evidence add tp-d4e --traces -
+  $ jq -c '.traces' session.json | ish person evidence add p-d4e --traces -
 
   # Project the response
-  $ ish profile evidence add tp-d4e --traces-file ./answers.json --fields id,source,created_at
+  $ ish person evidence add p-d4e --traces-file ./answers.json --fields id,source,created_at
 
 Valid source values: ${EVIDENCE_SOURCES.join(", ")}.
 \`source\` on a trace = \`type\` on a suggested scenario — same enum.
-Pair with \`ish profile suggest-scenarios\` to drive the iterative probe → answer loop.
-Verify with \`ish profile evidence list <id>\`.`)
+Pair with \`ish person suggest-scenarios\` to drive the iterative probe → answer loop.
+Verify with \`ish person evidence list <id>\`.`)
         .action(async (id, opts, cmd) => {
         await withClient(cmd, async (client, globals) => {
             if (opts.traces && opts.tracesFile) {
@@ -571,9 +606,9 @@ Verify with \`ish profile evidence list <id>\`.`)
             const rid = resolveId(id);
             const body = { traces };
             if (!globals.quiet) {
-                console.error(`  persisting ${traces.length} evidence trace${traces.length === 1 ? "" : "s"} on ${tagAlias(ALIAS_PREFIX.testerProfile, rid)}...`);
+                console.error(`  persisting ${traces.length} evidence trace${traces.length === 1 ? "" : "s"} on ${tagAlias(ALIAS_PREFIX.person, rid)}...`);
             }
-            const data = await client.post(`/tester-profiles/${rid}/scenarios`, body);
+            const data = await client.post(`/people/${rid}/scenarios`, body);
             if (globals.json) {
                 output({ items: data, total: data.length }, true);
             }
@@ -584,24 +619,24 @@ Verify with \`ish profile evidence list <id>\`.`)
     });
     evidence
         .command("list")
-        .description("List evidence traces persisted on a tester profile (newest first)")
-        .argument("<id>", "Profile ID (alias or UUID)")
+        .description("List evidence traces persisted on a person (newest first)")
+        .argument("<id>", "Person ID (alias or UUID)")
         .addHelpText("after", `
 Examples:
-  # Read back every trace on a profile
-  $ ish profile evidence list tp-d4e
+  # Read back every trace on a person
+  $ ish person evidence list p-d4e
 
   # Project per-row fields
-  $ ish profile evidence list tp-d4e --fields id,source,scenario_prompt
+  $ ish person evidence list p-d4e --fields id,source,scenario_prompt
 
   # Capture just the sources, one per line (auto-descends into items)
-  $ ish profile evidence list tp-d4e --get source
+  $ ish person evidence list p-d4e --get source
 
 Returns a {items, total} envelope. Use the same id you passed to \`evidence add\`.`)
         .action(async (id, _opts, cmd) => {
         await withClient(cmd, async (client, globals) => {
             const rid = resolveId(id);
-            const data = await client.get(`/tester-profiles/${rid}/scenarios`);
+            const data = await client.get(`/people/${rid}/scenarios`);
             if (globals.json) {
                 output({ items: data, total: data.length }, true);
             }
@@ -639,12 +674,12 @@ async function parseJsonFlag(value, flagName) {
     throw new Error(`${flagName} expects inline JSON (starting with { or [), an @path reference (@/path/to/file.json), or '-' for stdin.`);
 }
 /**
- * If the value matches the testerProfileSource alias pattern (e.g. "tps-3a4"),
+ * If the value matches the personSource alias pattern (e.g. "ps-3a4"),
  * resolve it to the underlying UUID. Otherwise return undefined so the caller
  * falls back to treating the value as a path.
  */
 function tryResolveSourceAlias(value) {
-    if (!/^tps-[0-9a-f]{3,}$/.test(value))
+    if (!/^ps-[0-9a-f]{3,}$/.test(value))
         return undefined;
     try {
         return resolveId(value);