usertold 1.18.0 → 1.20.0

package/usertold

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import process$2 from 'node:process';
-import { readFile, rm, mkdir, writeFile } from 'node:fs/promises';
+import { readFile, mkdir, writeFile, rm } from 'node:fs/promises';
 import os from 'node:os';
 import path, { extname } from 'node:path';
 import { randomBytes, createHash } from 'node:crypto';
@@ -9,6 +9,34 @@ import { spawn } from 'node:child_process';
 import { setTimeout as setTimeout$1 } from 'node:timers/promises';
 import { createInterface } from 'node:readline';
 
+const CANONICAL_WIDGET_EMBED_ORIGIN = 'https://usertold.ai';
+function resolveWidgetEmbedOriginForEnvironment(env) {
+    switch(env){
+        case 'production':
+            return CANONICAL_WIDGET_EMBED_ORIGIN;
+        case 'stage':
+        case 'staging':
+            return 'https://usertold-stage.krasnoperov.me';
+        case 'local':
+            return 'https://local.krasnoperov.me:3001';
+        default:
+            throw new Error(`Unknown environment "${env}". Valid options: production, stage, local`);
+    }
+}
+function buildWidgetScriptSrc(origin) {
+    return `${origin.replace(/\/+$/, '')}/v1/widget.js`;
+}
+function buildWidgetEmbedSnippet(params) {
+    const attrs = [
+        params.async ? 'async' : null,
+        `src="${buildWidgetScriptSrc(params.origin)}"`,
+        `data-project-key="${params.projectKey}"`,
+        params.screenerId ? `data-screener-id="${params.screenerId}"` : null,
+        params.studyId ? `data-study-id="${params.studyId}"` : null
+    ].filter(Boolean);
+    return `<script ${attrs.join(' ')}></script>`;
+}
+
 const DEFAULT_ENVIRONMENT = 'production';
 const CONFIG_DIR_NAME = 'usertold-cli';
 const CONFIG_FILE_NAME = 'config.json';
@@ -55,6 +83,27 @@ async function loadStoredConfig(environment) {
     const env = environment || DEFAULT_ENVIRONMENT;
     return multiConfig.configs[env] || null;
 }
+async function loadCurrentProjectRef(environment) {
+    const multiConfig = await loadMultiEnvConfig();
+    if (!multiConfig) return null;
+    const env = environment || DEFAULT_ENVIRONMENT;
+    const currentProjectRef = multiConfig.preferences?.[env]?.currentProjectRef;
+    return typeof currentProjectRef === 'string' && currentProjectRef.length > 0 ? currentProjectRef : null;
+}
+async function saveCurrentProjectRef(environment, projectRef) {
+    const multiConfig = await loadMultiEnvConfig() || {
+        configs: {}
+    };
+    const preferences = multiConfig.preferences ?? {};
+    preferences[environment] = {
+        ...preferences[environment],
+        currentProjectRef: projectRef
+    };
+    await saveMultiEnvConfig({
+        ...multiConfig,
+        preferences
+    });
+}
 async function removeConfig(environment) {
     if (!environment) {
         // Remove all configs
@@ -84,17 +133,7 @@ function resolveBaseUrl(env) {
     if (process.env.USERTOLD_API_BASE) {
         return process.env.USERTOLD_API_BASE.replace(/\/$/, '');
     }
-    switch(env){
-        case 'production':
-            return 'https://usertold.ai';
-        case 'stage':
-        case 'staging':
-            return 'https://usertold-stage.krasnoperov.me';
-        case 'local':
-            return 'https://local.krasnoperov.me:3001';
-        default:
-            throw new Error(`Unknown environment "${env}". Valid options: production, stage, local`);
-    }
+    return resolveWidgetEmbedOriginForEnvironment(env);
 }
 
 const EXIT_ERROR = 1;
@@ -533,6 +572,11 @@ function isCloudflare1010Response(response) {
     return text.includes('access denied') && text.includes("browser's signature");
 }
 
+const SENSITIVE_OUTPUT_KEYS = new Set([
+    'secret_key',
+    'wrapped_dek',
+    'settings_json'
+]);
 /**
  * Returns true when output should be JSON:
  * - --json flag
@@ -545,35 +589,36 @@ function isCloudflare1010Response(response) {
     return false;
 }
 function printOutput(data, parsed) {
+    const safeData = redactSensitiveOutput(data);
     if (isJsonOutput(parsed)) {
-        console.log(JSON.stringify(data, null, 2));
+        console.log(JSON.stringify(safeData, null, 2));
         return;
     }
-    if (Array.isArray(data)) {
-        printTable(data);
+    if (Array.isArray(safeData)) {
+        printTable(safeData);
         return;
     }
-    if (isRecord(data)) {
-        const arrayEntry = findFirstArrayEntry(data);
+    if (isRecord(safeData)) {
+        const arrayEntry = findFirstArrayEntry(safeData);
         if (arrayEntry) {
             const [key, value] = arrayEntry;
             console.log(`${key}:`);
             printTable(value);
-            const meta = Object.fromEntries(Object.entries(data).filter(([entryKey])=>entryKey !== key));
+            const meta = Object.fromEntries(Object.entries(safeData).filter(([entryKey])=>entryKey !== key));
             if (Object.keys(meta).length > 0) {
                 console.log('');
                 printObject(meta);
             }
             return;
         }
-        printObject(data);
+        printObject(safeData);
         return;
     }
-    if (data === null || data === undefined) {
+    if (safeData === null || safeData === undefined) {
         console.log('(empty)');
         return;
     }
-    console.log(String(data));
+    console.log(String(safeData));
 }
 function printTable(rows) {
     if (rows.length === 0) {
@@ -647,6 +692,22 @@ function truncate(value, max) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function redactSensitiveOutput(value) {
+    if (Array.isArray(value)) {
+        return value.map(redactSensitiveOutput);
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    const redacted = {};
+    for (const [key, child] of Object.entries(value)){
+        if (SENSITIVE_OUTPUT_KEYS.has(key)) {
+            continue;
+        }
+        redacted[key] = redactSensitiveOutput(child);
+    }
+    return redacted;
+}
 
 const DEFAULT_CLIENT_ID = 'usertold-cli';
 const DEFAULT_REDIRECT_PORT = 8765;
@@ -655,7 +716,7 @@ const AUTH_SCOPES = 'openid profile email';
  * Detect how the CLI was invoked and return the appropriate command string.
  * Examples:
  * - "usertold" when installed globally or run as bundled binary
- * - "npm run cli" when run via package.json script (local dev)
+ * - "pnpm run cli" when run via package.json script (local dev)
  * - "npx usertold" when run via npx
  */ function detectCliCommand() {
     const argv = process.argv;
@@ -663,9 +724,9 @@ const AUTH_SCOPES = 'openid profile email';
     if (argv[1]?.includes('usertold')) {
         return 'usertold';
     }
-    // Check if run via npm/yarn run
-    if (argv[1]?.includes('npm') || process.env.npm_lifecycle_event) {
-        return 'npm run cli';
+    // Check if run via package manager script
+    if (argv[1]?.includes('pnpm') || argv[1]?.includes('npm') || process.env.npm_lifecycle_event) {
+        return 'pnpm run cli';
     }
     // Check if run via npx
     if (argv[0]?.includes('npx') || process.env.npm_execpath?.includes('npx')) {
@@ -1154,7 +1215,11 @@ async function handleLogout(parsed) {
     }
 }
 
-const FLAGS$e = {
+// `status` is kept as a runtime alias for `whoami` in the switch below but is
+// intentionally absent here so it does not surface in `usertold introspect`
+// or in the AUTH_HELP Commands list. Remove the case entirely in the next
+// minor to retire the alias.
+const FLAGS$d = {
     login: [
         'token',
         'no-browser',
@@ -1164,9 +1229,6 @@ const FLAGS$e = {
     whoami: [
         'no-verify'
     ],
-    status: [
-        'no-verify'
-    ],
     token: []
 };
 async function handleAuthCommand(subcommand, parsed) {
@@ -1176,20 +1238,20 @@ async function handleAuthCommand(subcommand, parsed) {
     }
     switch(subcommand){
         case 'login':
-            validateFlags(parsed, FLAGS$e.login);
+            validateFlags(parsed, FLAGS$d.login);
             await handleLogin(parsed);
             return;
         case 'logout':
-            validateFlags(parsed, FLAGS$e.logout);
+            validateFlags(parsed, FLAGS$d.logout);
             await handleLogout(parsed);
             return;
         case 'whoami':
         case 'status':
-            validateFlags(parsed, FLAGS$e.whoami);
+            validateFlags(parsed, FLAGS$d.whoami);
             await handleWhoami(parsed);
             return;
         case 'token':
-            validateFlags(parsed, FLAGS$e.token);
+            validateFlags(parsed, FLAGS$d.token);
             await handleToken(parsed);
             return;
         default:
@@ -1204,7 +1266,6 @@ Commands:
   login [--env <env>]        Authenticate and store bearer token
   logout [--env <env>]       Remove credentials (or all envs if omitted)
   whoami [--env <env>]       Show current authenticated user/profile and personal_org_handle
-  status                     Alias for whoami
   token [--env <env>]        Output current token for piping
 
 Options:
@@ -1214,16 +1275,19 @@ Options:
   --no-verify                Skip server-side token verification (whoami)
 
 Discovery:
-  Run \`usertold auth whoami --json\` and read \`profile.personal_org_handle\`
-  before \`usertold project create <orgHandle>\` or \`usertold init --org <orgHandle>\`.
+  \`usertold project list\`, \`usertold project create\`, and \`usertold init\`
+  default to \`profile.personal_org_handle\`. Pass --org only when targeting
+  a different workspace.
 
 Examples:
   usertold auth login
   usertold auth logout
   usertold auth whoami
   usertold auth whoami --json
-  usertold auth status
   usertold auth token --json
+
+Deprecated aliases (kept for backward compatibility, will be removed in a future release):
+  status                     Use \`whoami\` instead
 `;
 function printAuthHelp() {
     console.log(AUTH_HELP);
@@ -6050,6 +6114,90 @@ function getCreditPacks(environment) {
 }
 /** Display-only alias (credits/cents/label are identical across environments). */ getCreditPacks();
 
+const TARGET_SURFACES = [
+    'product_under_test',
+    'usertold_widget_interview',
+    'interviewer_conductor_behavior',
+    'ambiguous_needs_review'
+];
+const TARGET_SURFACE_FILTERS = [
+    ...TARGET_SURFACES,
+    'all'
+];
+const TARGET_SURFACE_SET = new Set(TARGET_SURFACES);
+function isTargetSurface(value) {
+    return typeof value === 'string' && TARGET_SURFACE_SET.has(value);
+}
+function normalizeTargetSurface(value) {
+    return isTargetSurface(value) ? value : 'product_under_test';
+}
+
+const TASK_STATUSES = [
+    'backlog',
+    'ready',
+    'in_progress',
+    'done',
+    'wont_fix'
+];
+const CLOSED_TASK_STATUSES = [
+    'done',
+    'wont_fix'
+];
+const TASK_STATUS_TRANSITION_SOURCES = [
+    'user',
+    'mcp',
+    'linear_webhook',
+    'github_webhook',
+    // Legacy value retained so historical status rows remain readable.
+    'impact_measurement',
+    'consolidation_reopen',
+    'system'
+];
+new Set(TASK_STATUSES);
+new Set(CLOSED_TASK_STATUSES);
+new Set(TASK_STATUS_TRANSITION_SOURCES);
+
+const USER_DISPLAY_NAME_MAX_LENGTH = 80;
+const WORKSPACE_HANDLE_MIN_LENGTH = 3;
+const WORKSPACE_HANDLE_MAX_LENGTH = 64;
+const WORKSPACE_NAME_MAX_LENGTH = 80;
+const WORKSPACE_HANDLE_PATTERN = /^[a-z0-9](?:[a-z0-9-]{1,62}[a-z0-9])$/;
+function hasControlCharacters(value) {
+    for(let index = 0; index < value.length; index += 1){
+        const code = value.charCodeAt(index);
+        if (code <= 31 || code === 127) {
+            return true;
+        }
+    }
+    return false;
+}
+function validateWorkspaceName(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return 'Organization name is required';
+    }
+    if (trimmed.length > WORKSPACE_NAME_MAX_LENGTH) {
+        return `Organization name must be ${WORKSPACE_NAME_MAX_LENGTH} characters or fewer`;
+    }
+    if (hasControlCharacters(trimmed)) {
+        return 'Organization name cannot include control characters';
+    }
+    return null;
+}
+function validateWorkspaceHandle(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return 'Workspace handle is required';
+    }
+    if (trimmed.length < WORKSPACE_HANDLE_MIN_LENGTH || trimmed.length > WORKSPACE_HANDLE_MAX_LENGTH) {
+        return `Workspace handle must be ${WORKSPACE_HANDLE_MIN_LENGTH}-${WORKSPACE_HANDLE_MAX_LENGTH} characters`;
+    }
+    if (!WORKSPACE_HANDLE_PATTERN.test(trimmed)) {
+        return 'Use lowercase letters, numbers, and hyphens. Start and end with a letter or number.';
+    }
+    return null;
+}
+
 // ============================================================================
 // Shared API Request Contracts — Zod schemas are the single source of truth.
 // Types are derived via z.infer<>.
@@ -6072,7 +6220,8 @@ const ApiTaskCreateRequestSchema = object({
     effort_estimate: string().nullable().optional()
 });
 const ApiTaskPatchRequestSchema = ApiTaskCreateRequestSchema.partial().extend({
-    status: string().optional()
+    status: _enum(TASK_STATUSES).optional(),
+    status_reason: string().nullable().optional()
 });
 const ApiTaskCreateFromSignalsRequestSchema = object({
     title: string(),
@@ -6081,8 +6230,10 @@ const ApiTaskCreateFromSignalsRequestSchema = object({
     signal_ids: array(string()).min(1)
 });
 const ApiTaskListQuerySchema = object({
-    status: string().optional(),
+    status: _enum(TASK_STATUSES).optional(),
     type: string().optional(),
+    target_surface: _enum(TARGET_SURFACE_FILTERS).optional(),
+    include_closed: string().optional(),
     session_id: string().optional(),
     min_priority: string().optional(),
     limit: string().optional(),
@@ -6091,6 +6242,7 @@ const ApiTaskListQuerySchema = object({
 // --- Signals ---
 const ApiSessionSignalCreateRequestSchema = object({
     signal_type: string(),
+    target_surface: _enum(TARGET_SURFACES).optional(),
     quote: string(),
     context: string().optional(),
     timestamp_ms: number().optional(),
@@ -6099,10 +6251,13 @@ const ApiSessionSignalCreateRequestSchema = object({
 });
 const ApiSignalPatchRequestSchema = object({
     signal_type: string().optional(),
+    target_surface: _enum(TARGET_SURFACES).nullable().optional(),
     confidence: number().optional(),
+    intensity: number().nullable().optional(),
     quote: string().optional(),
     analysis: string().nullable().optional(),
     context: string().nullable().optional(),
+    timestamp_ms: number().nullable().optional(),
     headline: string().nullable().optional(),
     claim: string().nullable().optional(),
     reconstruction: string().nullable().optional()
@@ -6133,12 +6288,22 @@ const ApiSignalBulkDeleteRequestSchema = object({
 });
 const ApiSignalListQuerySchema = object({
     type: string().optional(),
+    target_surface: _enum(TARGET_SURFACE_FILTERS).optional(),
     session_id: string().optional(),
     task_id: string().optional(),
     search: string().optional(),
     min_confidence: string().optional(),
     dismissed: string().optional(),
+    include_closed: string().optional(),
     review_status: string().optional(),
+    review_state: _enum([
+        'active',
+        'needs_review',
+        'active_linked',
+        'active_unlinked',
+        'possible_recurrence',
+        'resolved'
+    ]).optional(),
     limit: string().optional(),
     offset: string().optional()
 });
@@ -6285,13 +6450,13 @@ const ApiSessionProcessingStatusRequestSchema = object({
 });
 // --- User ---
 const ApiUserProfileUpdateRequestSchema = object({
-    name: string().optional()
+    name: string().max(USER_DISPLAY_NAME_MAX_LENGTH).refine((value)=>!hasControlCharacters(value), 'Name cannot include control characters').optional()
 });
 // --- Auth ---
 const ApiAuthOnboardingRequestSchema = object({
     acceptTerms: boolean(),
-    personalOrgHandle: string().optional(),
-    personalOrgName: string().optional()
+    personalOrgHandle: string().max(WORKSPACE_HANDLE_MAX_LENGTH).refine((value)=>validateWorkspaceHandle(value) === null, 'Workspace handle is invalid').optional(),
+    personalOrgName: string().max(WORKSPACE_NAME_MAX_LENGTH).refine((value)=>validateWorkspaceName(value) === null, 'Organization name is invalid').optional()
 });
 const ApiOAuthApprovalDecisionRequestSchema = object({
     requestId: string(),
@@ -6324,6 +6489,9 @@ const ApiSdkSessionCreateRequestSchema = object({
     interview_mode: _enum(INTERVIEW_MODES).optional(),
     study_id: string().optional()
 });
+const ApiSdkSessionConsentRequestSchema = object({
+    consent_copy_version: string().min(1).max(64)
+});
 const ApiSdkUploadStartRequestSchema = object({
     session_id: string()
 });
@@ -6369,7 +6537,22 @@ const ApiConductorCheckpointRequestSchema = object({
         fromTitle: string().optional(),
         targetUrl: string().optional(),
         ts: number()
-    }).optional()
+    }).optional(),
+    // Widget telemetry events that must land even if the WS is mid-reconnect at
+    // unload time. The checkpoint API uses sendBeacon / fetch keepalive, so it
+    // survives page death; the WS queue does not. The DO persists each entry to
+    // session_events as event_type=`widget.<name>`. Capped to keep beacon
+    // payloads small — the only intended caller is the STS navigation
+    // terminator, but the array shape leaves room for adjacent terminators
+    // (e.g. tts_turn_completed) without another schema change.
+    widget_events: array(object({
+        name: string().min(1).max(64),
+        ts: number(),
+        data: record(string(), unknown())
+    })).max(8).optional()
+});
+const ApiConductorRealtimeCallRequestSchema = object({
+    sdp: string().min(1)
 });
 // --- Billing request schemas ---
 const ApiBillingCheckoutRequestSchema = object({
@@ -6380,6 +6563,12 @@ const ApiBillingEventsQuerySchema = object({
     limit: string().optional(),
     offset: string().optional()
 });
+const ApiAdminCreditsGrantRequestSchema = object({
+    email: string().trim().toLowerCase().email(),
+    credits: number().int().positive().max(100000),
+    reason: string().trim().min(1).max(160),
+    grant_id: string().trim().min(1).max(160).optional()
+});
 
 const ApiSuccessResponseSchema = object({
     success: boolean()
@@ -6407,7 +6596,6 @@ const ApiProjectSchema = object({
     github_installation_id: string().nullable(),
     linear_team_id: string().nullable(),
     public_key: string(),
-    secret_key: string(),
     created_at: string(),
     updated_at: string()
 });
@@ -6422,7 +6610,8 @@ const ApiProjectsListResponseSchema = object({
 });
 const ApiProjectDetailResponseSchema = object({
     project: ApiProjectSchema,
-    members: array(ApiProjectMemberSchema)
+    members: array(ApiProjectMemberSchema),
+    current_user_org_role: string().nullable()
 });
 const ApiProjectMutationResponseSchema = object({
     project: ApiProjectSchema
@@ -6640,11 +6829,46 @@ const ApiEnrichedTimelineEntrySchema = object({
     meta: record(string(), unknown()).optional()
 });
 
+const ApiSignalLinkedTaskSchema = object({
+    id: string(),
+    title: string(),
+    status: _enum(TASK_STATUSES),
+    linear_issue_id: string().nullable().optional(),
+    linear_issue_url: string().nullable().optional(),
+    linear_issue_status: string().nullable().optional()
+});
+const ApiSignalEvidenceResolutionSchema = object({
+    task_id: string().optional(),
+    resolved_at: string().nullable(),
+    resolved_by_provider: string().nullable(),
+    resolved_by_provider_issue_id: string().nullable(),
+    resolution_reason: string().nullable()
+});
+const ApiSignalRecurrenceCandidateSchema = object({
+    id: string(),
+    related_task_id: string(),
+    related_resolved_signal_id: string().nullable(),
+    confidence: number(),
+    reason: string().nullable(),
+    status: _enum([
+        'candidate',
+        'confirmed',
+        'dismissed'
+    ]),
+    created_at: string(),
+    reviewed_at: string().nullable(),
+    related_task: object({
+        id: string(),
+        title: string(),
+        status: _enum(TASK_STATUSES)
+    }).nullable().optional()
+});
 const ApiSignalSchema = object({
     id: string(),
     project_id: string(),
     session_id: string(),
     signal_type: string(),
+    target_surface: _enum(TARGET_SURFACES),
     confidence: number(),
     intensity: number().nullable(),
     quote: string(),
@@ -6674,11 +6898,22 @@ const ApiSignalSchema = object({
     dismissed_reason: string().nullable(),
     dismissed_by: string().nullable(),
     source: string().nullable(),
-    created_at: string()
+    created_at: string(),
+    linked_task: ApiSignalLinkedTaskSchema.nullable().optional(),
+    evidence_resolution: ApiSignalEvidenceResolutionSchema.nullable().optional(),
+    recurrence_candidates: array(ApiSignalRecurrenceCandidateSchema).optional()
 });
 const ApiSignalsListResponseSchema = object({
     signals: array(ApiSignalSchema),
-    total: number()
+    total: number(),
+    inbox_counts: object({
+        active: number(),
+        needs_review: number(),
+        active_linked: number(),
+        active_unlinked: number(),
+        possible_recurrence: number(),
+        resolved: number()
+    }).optional()
 });
 const ApiSignalResponseSchema = object({
     signal: ApiSignalSchema
@@ -6701,7 +6936,8 @@ const ApiTaskSchema = object({
     title: string(),
     description: string().nullable(),
     task_type: string(),
-    status: string(),
+    target_surface: _enum(TARGET_SURFACES),
+    status: _enum(TASK_STATUSES),
     priority_score: number(),
     priority_label: string(),
     effort_estimate: string().nullable(),
@@ -6711,14 +6947,55 @@ const ApiTaskSchema = object({
     implementation_pr_url: string().nullable(),
     implementation_pr_number: number().nullable(),
     deployed_at: string().nullable(),
-    baseline_signal_rate: number().nullable(),
-    current_signal_rate: number().nullable(),
-    impact_score: number().nullable(),
-    measurement_started_at: string().nullable(),
-    measurement_completed_at: string().nullable(),
     created_at: string(),
     updated_at: string()
 });
+const ApiTaskStatusHistorySchema = object({
+    id: string(),
+    task_id: string(),
+    project_id: string(),
+    from_status: _enum(TASK_STATUSES).nullable(),
+    to_status: _enum(TASK_STATUSES),
+    source: _enum(TASK_STATUS_TRANSITION_SOURCES),
+    reason: string().nullable(),
+    actor_id: string().nullable(),
+    created_at: string()
+});
+const ApiTaskRelatedTaskSchema = object({
+    relation_id: string(),
+    relation_type: string(),
+    reason: string().nullable(),
+    score: number().nullable(),
+    source: string(),
+    created_at: string(),
+    updated_at: string(),
+    task: ApiTaskSchema
+});
+const ApiTaskEvidenceResolutionSchema = object({
+    resolved_at: string().nullable(),
+    resolved_by_provider: string().nullable(),
+    resolved_by_provider_issue_id: string().nullable(),
+    resolution_reason: string().nullable()
+});
+const ApiTaskEvidenceSignalSchema = ApiSignalSchema.extend({
+    evidence_resolution: ApiTaskEvidenceResolutionSchema.nullable().optional()
+});
+const ApiTaskRecurrenceCandidateSchema = object({
+    id: string(),
+    project_id: string(),
+    new_signal_id: string(),
+    related_task_id: string(),
+    related_resolved_signal_id: string().nullable(),
+    confidence: number(),
+    reason: string().nullable(),
+    status: _enum([
+        'candidate',
+        'confirmed',
+        'dismissed'
+    ]),
+    created_at: string(),
+    reviewed_at: string().nullable()
+});
 const ApiProviderStateSchema = object({
     id: string(),
     task_id: string(),
@@ -6732,21 +7009,20 @@ const ApiProviderStateSchema = object({
     created_at: string(),
     updated_at: string()
 });
-const ApiTaskImpactResultSchema = object({
-    taskId: string(),
-    baselineRate: number(),
-    currentRate: number(),
-    reductionPercent: number(),
-    sessionsAnalyzed: number(),
-    measurementDays: number()
-});
 const ApiTasksListResponseSchema = object({
-    tasks: array(ApiTaskSchema),
+    tasks: array(ApiTaskSchema.extend({
+        relation_count: number().optional(),
+        provider_states: array(ApiProviderStateSchema).optional(),
+        recurrence_candidates: array(ApiTaskRecurrenceCandidateSchema).optional()
+    })),
     total: number()
 });
 const ApiTaskDetailResponseSchema = object({
     task: ApiTaskSchema,
-    signals: array(ApiSignalSchema)
+    signals: array(ApiTaskEvidenceSignalSchema),
+    status_history: array(ApiTaskStatusHistorySchema).optional(),
+    related_tasks: array(ApiTaskRelatedTaskSchema).optional(),
+    recurrence_candidates: array(ApiTaskRecurrenceCandidateSchema).optional()
 });
 const ApiTaskResponseSchema = object({
     task: ApiTaskSchema
@@ -6754,9 +7030,6 @@ const ApiTaskResponseSchema = object({
 const ApiTaskProviderStateResponseSchema = object({
     providers: array(ApiProviderStateSchema)
 });
-const ApiTaskMeasureImpactResponseSchema = object({
-    impact: ApiTaskImpactResultSchema
-});
 const ApiReadyTasksResponseSchema = object({
     tasks: array(ApiTaskSchema)
 });
@@ -6998,18 +7271,37 @@ const ApiOAuthDynamicClientRegistrationResponseSchema = object({
     client_secret_expires_at: number()
 });
 
+const BILLING_EVENT_DISPLAY_KINDS = [
+    'purchase',
+    'bonus',
+    'usage',
+    'other'
+];
+const BILLING_EVENT_AMOUNT_DIRECTIONS = [
+    'credit',
+    'debit',
+    'neutral'
+];
+
 const ApiBillingEventSchema = object({
     id: string(),
     user_id: number(),
     session_id: string(),
     project_id: string(),
     event_type: string(),
+    display_label: string(),
+    display_kind: _enum(BILLING_EVENT_DISPLAY_KINDS),
+    amount_direction: _enum(BILLING_EVENT_AMOUNT_DIRECTIONS),
     amount_cents: number(),
+    signed_amount_cents: number(),
     polar_synced: number(),
     created_at: string()
 });
 const ApiBillingStatusSchema = object({
     credit_balance_cents: number(),
+    available_interview_count: number(),
+    grace_debt_cents: number(),
+    grace_debt_limit_cents: number(),
     has_payment_method: boolean(),
     accrued_usage_cents: number(),
     spending_cap_cents: number(),
@@ -7066,7 +7358,14 @@ const ApiGitHubSelectRepoResponseSchema = object({
 });
 
 const ApiSdkSessionCreateResponseSchema = object({
-    session_id: string()
+    session_id: string(),
+    session_token: string()
+});
+const ApiSdkRuntimeSessionTokenResponseSchema = object({
+    session_token: string()
+});
+const ApiSdkSessionConsentResponseSchema = object({
+    success: literal(true)
 });
 const ApiSdkAudioUploadResponseSchema = object({
     success: boolean()
@@ -7088,6 +7387,16 @@ const ApiConductorCheckpointResponseSchema = object({
     success: boolean(),
     checkpointed: boolean()
 });
+const ApiConductorOriginGuardErrorResponseSchema = object({
+    error: string(),
+    code: _enum([
+        'origin_required',
+        'origin_invalid',
+        'origin_not_allowed'
+    ]),
+    retryable: literal(false),
+    action: string()
+});
 const ApiConductorTranscriptionSecretResponseSchema = object({
     client_secret: string(),
     expires_at: number(),
@@ -7097,7 +7406,15 @@ const ApiConductorSTSSecretResponseSchema = object({
     client_secret: string(),
     expires_at: number(),
     model: string(),
-    voice: string()
+    voice: string(),
+    reasoning_enabled: boolean()
+});
+const ApiConductorRealtimeCallResponseSchema = object({
+    sdp: string(),
+    call_id: string().nullable(),
+    model: string(),
+    reasoning_enabled: boolean(),
+    sideband_enabled: boolean()
 });
 const ApiConductorEndResponseSchema = object({
     success: boolean(),
@@ -7148,6 +7465,7 @@ const ApiSdkScreenerResponseSchema = object({
 const ApiSdkScreenerSubmitResponseSchema = object({
     qualified: boolean(),
     session_id: string().optional(),
+    session_token: string().optional(),
     study_id: string().nullable().optional(),
     study_handle: string().nullable().optional(),
     message: string()
@@ -7177,6 +7495,13 @@ const ApiOverviewResponseSchema = object({
         total: number(),
         by_status: record(string(), number())
     }),
+    attention: object({
+        recent_sessions_with_evidence: number(),
+        active_evidence: number(),
+        tasks_awaiting_handoff: number(),
+        tasks_in_linear: number(),
+        recurrence_candidates: number()
+    }),
     screeners: object({
         total: number(),
         active: number(),
@@ -7262,6 +7587,19 @@ const ApiAdminEmbedBackfillResponseSchema = object({
     signals_failed: number(),
     tasks_failed: number()
 });
+const ApiAdminCreditsGrantResponseSchema = object({
+    user_id: number(),
+    email: string(),
+    credits: number(),
+    amount_cents: number(),
+    event_type: literal('credits.bonus'),
+    grant_key: string(),
+    reason: string(),
+    applied: boolean(),
+    credit_balance_cents: number(),
+    available_interview_count: number(),
+    grace_debt_cents: number()
+});
 
 const ApiAuthGithubLoginQuerySchema = object({
     return_to: string().optional()
@@ -7469,6 +7807,11 @@ const LinearTaskPushResponseSchema = object({
     pushed: boolean(),
     alreadyPushed: boolean()
 });
+const LinearDisconnectResponseSchema = ApiSuccessResponseSchema.extend({
+    unlinkedOrg: boolean(),
+    revokedInstallation: boolean(),
+    remainingActiveOrgLinks: number().int().nonnegative()
+});
 const linearApiContracts = {
     linearConnect: defineContract({
         method: 'GET',
@@ -7481,6 +7824,17 @@ const linearApiContracts = {
         }),
         response: unknown()
     }),
+    linearClaim: defineContract({
+        method: 'GET',
+        path: '/api/orgs/:orgHandle/linear/claim',
+        pathParams: [
+            'orgHandle'
+        ],
+        query: object({
+            return_to: string().optional()
+        }),
+        response: unknown()
+    }),
     linearCallback: defineContract({
         method: 'GET',
         path: '/api/linear/callback',
@@ -7506,7 +7860,7 @@ const linearApiContracts = {
         pathParams: [
             'orgHandle'
         ],
-        response: ApiSuccessResponseSchema
+        response: LinearDisconnectResponseSchema
     }),
     linearTeams: defineContract({
         method: 'GET',
@@ -7565,6 +7919,13 @@ const adminApiContracts = {
         path: '/api/admin/embed-backfill',
         pathParams: [],
         response: ApiAdminEmbedBackfillResponseSchema
+    }),
+    adminCreditsGrant: defineContract({
+        method: 'POST',
+        path: '/api/admin/credits/grant',
+        pathParams: [],
+        body: ApiAdminCreditsGrantRequestSchema,
+        response: ApiAdminCreditsGrantResponseSchema
     })
 };
 
@@ -7577,6 +7938,7 @@ const ApiOAuthAuthorizeQuerySchema = object({
     response_type: string().optional(),
     code_challenge: string().optional(),
     code_challenge_method: string().optional(),
+    scope: string().optional(),
     state: string().optional()
 });
 const ApiOAuthTokenRequestSchema = object({
@@ -7930,6 +8292,12 @@ const screenersApiContracts = {
     })
 };
 
+const conductorOriginGuardResponses = {
+    403: {
+        description: 'Origin rejected by conductor runtime guard',
+        schema: ApiConductorOriginGuardErrorResponseSchema
+    }
+};
 const sdkApiContracts = {
     sdkSessionCreate: defineContract({
         method: 'POST',
@@ -7938,6 +8306,23 @@ const sdkApiContracts = {
         body: ApiSdkSessionCreateRequestSchema,
         response: ApiSdkSessionCreateResponseSchema
     }),
+    sdkSessionRuntimeToken: defineContract({
+        method: 'POST',
+        path: '/api/sdk/sessions/:sessionId/runtime-token',
+        pathParams: [
+            'sessionId'
+        ],
+        response: ApiSdkRuntimeSessionTokenResponseSchema
+    }),
+    sdkSessionConsent: defineContract({
+        method: 'POST',
+        path: '/api/sdk/sessions/:sessionId/consent',
+        pathParams: [
+            'sessionId'
+        ],
+        body: ApiSdkSessionConsentRequestSchema,
+        response: ApiSdkSessionConsentResponseSchema
+    }),
     sdkAudioUpload: defineContract({
         method: 'POST',
         path: '/api/sdk/audio/upload',
@@ -7959,7 +8344,8 @@ const sdkApiContracts = {
             'sessionId'
         ],
         body: ApiConductorCheckpointRequestSchema,
-        response: ApiConductorCheckpointResponseSchema
+        response: ApiConductorCheckpointResponseSchema,
+        responses: conductorOriginGuardResponses
     }),
     conductorWs: defineContract({
         method: 'GET',
@@ -7970,7 +8356,8 @@ const sdkApiContracts = {
         // WebSocket upgrade endpoint — returns 101 Switching Protocols, not JSON.
         // z.unknown() is used because the contract system requires a response schema
         // but no JSON body is returned. See conductor.ts route for 101/426 docs.
-        response: unknown().describe('WebSocket upgrade — no JSON response body')
+        response: unknown().describe('WebSocket upgrade — no JSON response body'),
+        responses: conductorOriginGuardResponses
     }),
     conductorTranscriptionSecret: defineContract({
         method: 'POST',
@@ -7978,7 +8365,8 @@ const sdkApiContracts = {
         pathParams: [
             'sessionId'
         ],
-        response: ApiConductorTranscriptionSecretResponseSchema
+        response: ApiConductorTranscriptionSecretResponseSchema,
+        responses: conductorOriginGuardResponses
     }),
     conductorSTSSecret: defineContract({
         method: 'POST',
@@ -7986,7 +8374,18 @@ const sdkApiContracts = {
         pathParams: [
             'sessionId'
         ],
-        response: ApiConductorSTSSecretResponseSchema
+        response: ApiConductorSTSSecretResponseSchema,
+        responses: conductorOriginGuardResponses
+    }),
+    conductorRealtimeCall: defineContract({
+        method: 'POST',
+        path: '/api/sdk/conductor/:sessionId/realtime-call',
+        pathParams: [
+            'sessionId'
+        ],
+        body: ApiConductorRealtimeCallRequestSchema,
+        response: ApiConductorRealtimeCallResponseSchema,
+        responses: conductorOriginGuardResponses
     }),
     conductorEnd: defineContract({
         method: 'POST',
@@ -7994,7 +8393,8 @@ const sdkApiContracts = {
         pathParams: [
             'sessionId'
         ],
-        response: ApiConductorEndResponseSchema
+        response: ApiConductorEndResponseSchema,
+        responses: conductorOriginGuardResponses
     })
 };
 
@@ -8586,16 +8986,6 @@ const tasksApiContracts = {
         ],
         response: ApiSuccessResponseSchema
     }),
-    taskMeasureImpact: defineContract({
-        method: 'POST',
-        path: '/api/orgs/:orgHandle/projects/:projectHandle/tasks/:taskId/measure',
-        pathParams: [
-            'orgHandle',
-            'projectHandle',
-            'taskId'
-        ],
-        response: ApiTaskMeasureImpactResponseSchema
-    }),
     taskProviderState: defineContract({
         method: 'GET',
         path: '/api/orgs/:orgHandle/projects/:projectHandle/tasks/:taskId/provider-state',
@@ -8938,10 +9328,6 @@ const dashboardApiRouteMeta = {
         method: 'DELETE',
         path: '/api/orgs/:orgHandle/projects/:projectHandle/tasks/:taskId'
     },
-    taskMeasureImpact: {
-        method: 'POST',
-        path: '/api/orgs/:orgHandle/projects/:projectHandle/tasks/:taskId/measure'
-    },
     taskProviderState: {
         method: 'GET',
         path: '/api/orgs/:orgHandle/projects/:projectHandle/tasks/:taskId/provider-state'
@@ -9090,6 +9476,10 @@ const dashboardApiRouteMeta = {
         method: 'GET',
         path: '/api/orgs/:orgHandle/linear/connect'
     },
+    linearClaim: {
+        method: 'GET',
+        path: '/api/orgs/:orgHandle/linear/claim'
+    },
     linearCallback: {
         method: 'GET',
         path: '/api/linear/callback'
@@ -9130,6 +9520,14 @@ const dashboardApiRouteMeta = {
         method: 'POST',
         path: '/api/sdk/sessions'
     },
+    sdkSessionRuntimeToken: {
+        method: 'POST',
+        path: '/api/sdk/sessions/:sessionId/runtime-token'
+    },
+    sdkSessionConsent: {
+        method: 'POST',
+        path: '/api/sdk/sessions/:sessionId/consent'
+    },
     sdkAudioUpload: {
         method: 'POST',
         path: '/api/sdk/audio/upload'
@@ -9154,6 +9552,10 @@ const dashboardApiRouteMeta = {
         method: 'POST',
         path: '/api/sdk/conductor/:sessionId/sts-secret'
     },
+    conductorRealtimeCall: {
+        method: 'POST',
+        path: '/api/sdk/conductor/:sessionId/realtime-call'
+    },
     conductorEnd: {
         method: 'POST',
         path: '/api/sdk/conductor/:sessionId/end'
@@ -9193,6 +9595,10 @@ const dashboardApiRouteMeta = {
     adminEmbedBackfill: {
         method: 'POST',
         path: '/api/admin/embed-backfill'
+    },
+    adminCreditsGrant: {
+        method: 'POST',
+        path: '/api/admin/credits/grant'
     }
 };
 function buildDashboardApiPath$1(keyOrPath, params = {}, query) {
@@ -9351,7 +9757,7 @@ function requestContractJson(key, options) {
 function requestProjectContract(options) {
     const project = requireCanonicalProjectRef(options.projectRef, options.sourceLabel ?? '<projectRef>');
     const scopedPathParams = {
-        ...options.pathParams ?? {},
+        ...options.pathParams,
         orgHandle: project.orgHandle,
         projectHandle: project.projectHandle
     };
@@ -9399,7 +9805,7 @@ async function requestContractBinary(key, options) {
 async function requestProjectContractText(key, options) {
     const project = requireCanonicalProjectRef(options.projectRef, options.sourceLabel ?? '<projectRef>');
     const scopedPathParams = {
-        ...options.pathParams ?? {},
+        ...options.pathParams,
         orgHandle: project.orgHandle,
         projectHandle: project.projectHandle
     };
@@ -9411,7 +9817,7 @@ async function requestProjectContractText(key, options) {
 async function requestProjectContractBinary(key, options) {
     const project = requireCanonicalProjectRef(options.projectRef, options.sourceLabel ?? '<projectRef>');
     const scopedPathParams = {
-        ...options.pathParams ?? {},
+        ...options.pathParams,
         orgHandle: project.orgHandle,
         projectHandle: project.projectHandle
     };
@@ -9436,90 +9842,290 @@ function mergeHeaders(defaults, overrides) {
         return undefined;
     }
     return {
-        ...defaults ?? {},
-        ...overrides ?? {}
+        ...defaults,
+        ...overrides
     };
 }
 
-const FLAGS$d = {
-    list: [
-        'org'
-    ],
-    create: [
-        'name',
-        'handle',
-        'description',
-        'repo',
-        'org'
-    ],
-    get: [],
-    update: [
-        'name',
-        'handle',
-        'description',
-        'repo',
-        'branch'
-    ],
-    delete: [],
-    snippet: [],
-    status: []
-};
-async function handleProjectCommand(subcommand, parsed) {
-    if (!subcommand || hasHelpFlag(parsed) || subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
-        printProjectHelp();
-        return;
+async function resolveDefaultOrgHandle(env, commandLabel) {
+    const profile = await requestContractJson('userProfileGet', {
+        env
+    });
+    const orgHandle = profile.personal_org_handle;
+    if (!orgHandle) {
+        failArgs(`No default organization handle is available for "${commandLabel}". ` + 'Run "usertold auth whoami --json" to inspect your profile, or pass an org handle explicitly.');
     }
-    const env = parseEnvironment(parsed);
-    switch(subcommand){
-        case 'list':
-            {
-                validateFlags(parsed, FLAGS$d.list);
-                const hasOrgOption = parsed.options.org && parsed.options.org !== 'true';
-                const orgHandle = hasOrgOption ? parsed.options.org : requireOrgHandleForProjectSetup(parsed, 'project list');
-                assertNoExtraPositionals(parsed, hasOrgOption ? 0 : 1);
-                const data = await requestContractJson('projectList', {
-                    env,
-                    pathParams: {
-                        orgHandle
-                    }
-                });
-                printOutput(data, parsed);
-                return;
-            }
-        case 'create':
-            {
-                validateFlags(parsed, FLAGS$d.create);
-                const hasOrgOption = parsed.options.org && parsed.options.org !== 'true';
-                const orgHandle = hasOrgOption ? parsed.options.org : requireOrgHandleForProjectSetup(parsed, 'project create');
-                assertNoExtraPositionals(parsed, hasOrgOption ? 0 : 1);
-                const name = requireOption(parsed, 'name');
-                const body = {
-                    name
-                };
-                if (parsed.options.handle && parsed.options.handle !== 'true') {
-                    body.handle = parsed.options.handle;
-                }
-                if (parsed.options.description && parsed.options.description !== 'true') {
-                    body.description = parsed.options.description;
-                }
-                if (parsed.options.repo && parsed.options.repo !== 'true') {
-                    body.github_repo_url = parsed.options.repo;
-                }
-                const data = await requestContractJson('projectCreate', {
-                    env,
-                    pathParams: {
-                        orgHandle
-                    },
-                    body
-                });
-                printOutput(data, parsed);
+    return orgHandle;
+}
+async function resolveProjectRefWithDefaults(projectRef, env, sourceLabel = '<projectRef>') {
+    const value = projectRef.trim();
+    if (!value) {
+        failArgs(`Missing ${sourceLabel}. Run "usertold project list" or "usertold project use <projectRef>".`);
+    }
+    if (value.includes('/') || value.startsWith('prj_')) {
+        return resolveProjectRefToCanonical(value, env);
+    }
+    const orgHandle = await resolveDefaultOrgHandle(env, sourceLabel);
+    return {
+        orgHandle,
+        projectHandle: value
+    };
+}
+async function consumeProjectRef(parsed, env, options) {
+    const explicitProjectRef = parsed.positionals.length > options.resourceArgCount;
+    const rawProjectRef = explicitProjectRef ? parsed.positionals[0] : await requireCurrentProjectRef(env, options.commandLabel);
+    const args = explicitProjectRef ? parsed.positionals.slice(1) : parsed.positionals;
+    if (args.length < options.resourceArgCount) {
+        failArgs(`Missing required argument for "${options.commandLabel}". ` + `Expected ${options.resourceArgCount} resource argument(s) after the project.`);
+    }
+    assertNoExtraPositionals({
+        ...parsed,
+        positionals: args
+    }, options.resourceArgCount);
+    const canonical = await resolveProjectRefWithDefaults(rawProjectRef, env, '<projectRef>');
+    return {
+        projectRef: `${canonical.orgHandle}/${canonical.projectHandle}`,
+        args,
+        usedCurrentProject: !explicitProjectRef
+    };
+}
+async function requireCurrentProjectRef(env, commandLabel) {
+    const currentProjectRef = await loadCurrentProjectRef(env);
+    if (!currentProjectRef) {
+        failArgs(`Missing project for "${commandLabel}". ` + 'Pass <projectRef>, or set a default with "usertold project use <projectRef>".');
+    }
+    return currentProjectRef;
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function formatDuration$1(seconds) {
+    if (seconds === null || seconds < 0) return '-';
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins}m ${secs}s`;
+}
+function formatDate(iso) {
+    const d = new Date(iso);
+    return d.toLocaleDateString('en-US', {
+        month: 'short',
+        day: 'numeric'
+    });
+}
+function check(value) {
+    return value ? '[x]' : '[ ]';
+}
+function formatSignalBreakdown(byType) {
+    const parts = Object.entries(byType).sort((a, b)=>b[1] - a[1]).map(([type, count])=>`${count} ${type}`);
+    return parts.length > 0 ? ` (${parts.join(', ')})` : '';
+}
+function formatTaskBreakdown(byStatus) {
+    const parts = Object.entries(byStatus).sort((a, b)=>b[1] - a[1]).map(([status, count])=>`${count} ${status}`);
+    return parts.length > 0 ? ` (${parts.join(', ')})` : '';
+}
+function formatOverview(data) {
+    const { sessions, signals, tasks, screeners, setup, recent_sessions, top_tasks } = data;
+    console.log(`Sessions:    ${sessions.total} total (${sessions.completed} completed, ${sessions.active} active)`);
+    console.log(`Signals:     ${signals.total} total${formatSignalBreakdown(signals.by_type)}`);
+    console.log(`Tasks:       ${tasks.total} total${formatTaskBreakdown(tasks.by_status)}`);
+    console.log(`Screeners:   ${screeners.total} total (${screeners.active} active, ${screeners.total_views} views, ${screeners.total_qualified} qualified)`);
+    console.log('');
+    console.log('Setup:');
+    console.log(`  ${check(setup.has_api_keys)} API keys configured`);
+    console.log(`  ${check(setup.has_active_study)} Active study`);
+    console.log(`  ${check(setup.has_active_screener)} Active screener`);
+    console.log(`  ${check(setup.has_linked_active_screener)} Active screener linked to study`);
+    console.log(`  ${check(setup.has_sessions)} Has sessions`);
+    if (recent_sessions.length > 0) {
+        console.log('');
+        console.log('Recent sessions:');
+        for (const s of recent_sessions){
+            const name = s.participant_name || 'anonymous';
+            const dur = formatDuration$1(s.duration_seconds);
+            const date = formatDate(s.created_at);
+            const id = s.id.length > 12 ? `${s.id.slice(0, 12)}...` : s.id;
+            console.log(`  ${id}  ${s.status.padEnd(10)}  ${dur.padEnd(8)}  ${String(s.signal_count).padStart(2)} signals  ${date}  ${name}`);
+        }
+    }
+    if (top_tasks.length > 0) {
+        console.log('');
+        console.log('Top tasks:');
+        for (const t of top_tasks){
+            const id = t.id.length > 12 ? `${t.id.slice(0, 12)}...` : t.id;
+            const title = t.title.length > 50 ? `${t.title.slice(0, 47)}...` : t.title;
+            console.log(`  ${id}  p${String(t.priority_score).padStart(2)}  ${String(t.signal_count).padStart(2)} signals  ${title}`);
+        }
+    }
+}
+// ─── Command ─────────────────────────────────────────────────────────────────
+async function handleOverviewCommand(parsed) {
+    if (hasHelpFlag(parsed)) {
+        printOverviewHelp();
+        return;
+    }
+    const env = parseEnvironment(parsed);
+    const { projectRef } = await consumeProjectRef(parsed, env, {
+        resourceArgCount: 0,
+        commandLabel: 'overview'
+    });
+    const data = await requestProjectContract({
+        env,
+        key: 'overview',
+        projectRef,
+        sourceLabel: '<projectRef>'
+    });
+    if (isJsonOutput(parsed)) {
+        printOutput(data, parsed);
+    } else {
+        formatOverview(data);
+    }
+}
+const OVERVIEW_HELP = `
+Usage:
+  usertold overview [projectRef] [options]
+
+  Displays dashboard overview for a project: session counts, signal breakdown,
+  task status, screener summary, recent sessions, and top tasks.
+
+Options:
+  --env <env>                stage | production | local
+  --json                     JSON output
+
+Examples:
+  usertold project use acme/checkout
+  usertold overview
+  usertold overview acme/checkout
+  usertold overview acme/checkout --json
+`;
+function printOverviewHelp() {
+    console.log(OVERVIEW_HELP);
+}
+
+const FLAGS$c = {
+    list: [
+        'org'
+    ],
+    use: [],
+    current: [],
+    create: [
+        'name',
+        'handle',
+        'description',
+        'repo',
+        'org'
+    ],
+    get: [],
+    update: [
+        'name',
+        'handle',
+        'description',
+        'repo',
+        'branch'
+    ],
+    delete: [],
+    snippet: [],
+    status: [],
+    overview: []
+};
+async function handleProjectCommand(subcommand, parsed) {
+    if (!subcommand || hasHelpFlag(parsed) || subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+        printProjectHelp();
+        return;
+    }
+    const env = parseEnvironment(parsed);
+    switch(subcommand){
+        case 'list':
+            {
+                validateFlags(parsed, FLAGS$c.list);
+                const hasOrgOption = parsed.options.org && parsed.options.org !== 'true';
+                const positionalOrgHandle = parsed.positionals[0];
+                const orgHandle = hasOrgOption ? parsed.options.org : positionalOrgHandle ?? await resolveDefaultOrgHandle(env, 'project list');
+                assertNoExtraPositionals(parsed, hasOrgOption ? 0 : positionalOrgHandle ? 1 : 0);
+                const data = await requestContractJson('projectList', {
+                    env,
+                    pathParams: {
+                        orgHandle
+                    }
+                });
+                printOutput(data, parsed);
                 return;
             }
-        case 'get':
+        case 'use':
             {
-                validateFlags(parsed, FLAGS$d.get);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
+                validateFlags(parsed, FLAGS$c.use);
+                const rawProjectRef = requirePositional(parsed, 0, '<projectRef>');
                 assertNoExtraPositionals(parsed, 1);
+                const project = await resolveProjectRefWithDefaults(rawProjectRef, env, '<projectRef>');
+                const data = await requestContractJson('projectGet', {
+                    env,
+                    pathParams: {
+                        orgHandle: project.orgHandle,
+                        projectHandle: project.projectHandle
+                    }
+                });
+                const projectRef = `${project.orgHandle}/${project.projectHandle}`;
+                await saveCurrentProjectRef(env, projectRef);
+                if (isJsonOutput(parsed)) {
+                    printOutput({
+                        current_project: projectRef,
+                        project: data.project
+                    }, parsed);
+                } else {
+                    console.log(`Current project (${env}): ${projectRef}`);
+                }
+                return;
+            }
+        case 'current':
+            {
+                validateFlags(parsed, FLAGS$c.current);
+                assertNoExtraPositionals(parsed, 0);
+                const project = await resolveProjectRefWithDefaults(await requireCurrentProjectRef(env, 'project current'), env);
+                const projectRef = `${project.orgHandle}/${project.projectHandle}`;
+                if (isJsonOutput(parsed)) {
+                    console.log(JSON.stringify({
+                        current_project: projectRef
+                    }, null, 2));
+                } else {
+                    console.log(`Current project (${env}): ${projectRef}`);
+                }
+                return;
+            }
+        case 'create':
+            {
+                validateFlags(parsed, FLAGS$c.create);
+                const hasOrgOption = parsed.options.org && parsed.options.org !== 'true';
+                const positionalOrgHandle = parsed.positionals[0];
+                const orgHandle = hasOrgOption ? parsed.options.org : positionalOrgHandle ?? await resolveDefaultOrgHandle(env, 'project create');
+                assertNoExtraPositionals(parsed, hasOrgOption ? 0 : positionalOrgHandle ? 1 : 0);
+                const name = requireOption(parsed, 'name');
+                const body = {
+                    name
+                };
+                if (parsed.options.handle && parsed.options.handle !== 'true') {
+                    body.handle = parsed.options.handle;
+                }
+                if (parsed.options.description && parsed.options.description !== 'true') {
+                    body.description = parsed.options.description;
+                }
+                if (parsed.options.repo && parsed.options.repo !== 'true') {
+                    body.github_repo_url = parsed.options.repo;
+                }
+                const data = await requestContractJson('projectCreate', {
+                    env,
+                    pathParams: {
+                        orgHandle
+                    },
+                    body
+                });
+                printOutput(data, parsed);
+                return;
+            }
+        case 'get':
+            {
+                validateFlags(parsed, FLAGS$c.get);
+                const { projectRef } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'project get'
+                });
                 const { orgHandle, projectHandle } = requireCanonicalProjectRef(projectRef, '<projectRef>');
                 const data = await requestContractJson('projectGet', {
                     env,
@@ -9533,9 +10139,11 @@ async function handleProjectCommand(subcommand, parsed) {
             }
         case 'update':
             {
-                validateFlags(parsed, FLAGS$d.update);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                validateFlags(parsed, FLAGS$c.update);
+                const { projectRef } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'project update'
+                });
                 const { orgHandle, projectHandle } = requireCanonicalProjectRef(projectRef, '<projectRef>');
                 const body = {};
                 if (parsed.options.name && parsed.options.name !== 'true') {
@@ -9569,10 +10177,10 @@ async function handleProjectCommand(subcommand, parsed) {
             }
         case 'delete':
             {
-                validateFlags(parsed, FLAGS$d.delete);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
+                validateFlags(parsed, FLAGS$c.delete);
+                const rawProjectRef = requirePositional(parsed, 0, '<projectRef>');
                 assertNoExtraPositionals(parsed, 1);
-                const { orgHandle, projectHandle } = requireCanonicalProjectRef(projectRef, '<projectRef>');
+                const { orgHandle, projectHandle } = await resolveProjectRefWithDefaults(rawProjectRef, env, '<projectRef>');
                 if (getBooleanOption(parsed, 'dry-run')) {
                     if (isJsonOutput(parsed)) {
                         console.log(JSON.stringify({
@@ -9598,9 +10206,11 @@ async function handleProjectCommand(subcommand, parsed) {
             }
         case 'snippet':
             {
-                validateFlags(parsed, FLAGS$d.snippet);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                validateFlags(parsed, FLAGS$c.snippet);
+                const { projectRef } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'project snippet'
+                });
                 const { orgHandle, projectHandle } = requireCanonicalProjectRef(projectRef, '<projectRef>');
                 const data = await requestContractJson('projectGet', {
                     env,
@@ -9613,13 +10223,16 @@ async function handleProjectCommand(subcommand, parsed) {
                 if (!publicKey) {
                     failNotFound('Could not retrieve project public key');
                 }
-                const baseUrl = resolveBaseUrl(env);
-                const snippet = `<script src="${baseUrl}/v1/widget.js" data-project-key="${publicKey}"></script>`;
+                const widgetOrigin = resolveWidgetEmbedOriginForEnvironment(env);
+                const snippet = buildWidgetEmbedSnippet({
+                    origin: widgetOrigin,
+                    projectKey: publicKey
+                });
                 if (isJsonOutput(parsed)) {
                     console.log(JSON.stringify({
                         snippet,
                         public_key: publicKey,
-                        base_url: baseUrl
+                        base_url: widgetOrigin
                     }));
                 } else {
                     console.log(snippet);
@@ -9628,9 +10241,11 @@ async function handleProjectCommand(subcommand, parsed) {
             }
         case 'status':
             {
-                validateFlags(parsed, FLAGS$d.status);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                validateFlags(parsed, FLAGS$c.status);
+                const { projectRef } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'project status'
+                });
                 const { orgHandle, projectHandle } = requireCanonicalProjectRef(projectRef, '<projectRef>');
                 // Parallel fetch of project, settings, overview
                 const [projectData, settingsData, overviewData] = await Promise.all([
@@ -9686,6 +10301,12 @@ async function handleProjectCommand(subcommand, parsed) {
                 }
                 return;
             }
+        case 'overview':
+            {
+                validateFlags(parsed, FLAGS$c.overview);
+                await handleOverviewCommand(parsed);
+                return;
+            }
         default:
             fail(`Unknown project command: ${subcommand}`);
     }
@@ -9696,40 +10317,42 @@ Usage:
 
 Commands:
   list
-  list <orgHandle>
-  create <orgHandle> --name <name> [--handle <handle>] [--description <text>] [--repo <url>]
-  get <projectRef>
-  update <projectRef> [--name <name>] [--handle <handle>] [--description <text>] [--repo <url>] [--branch <name>]
+  list [<orgHandle>]
+  use <projectRef>          Set the current project for this environment
+  current                   Show the current project for this environment
+  create [<orgHandle>] --name <name> [--handle <handle>] [--description <text>] [--repo <url>]
+  get [projectRef]
+  update [projectRef] [--name <name>] [--handle <handle>] [--description <text>] [--repo <url>] [--branch <name>]
   delete <projectRef>
-  snippet <projectRef>        Output widget embed snippet
-  status <projectRef>         Show project readiness status
+  snippet [projectRef]        Output widget embed snippet
+  status [projectRef]         Show project readiness status
+  overview [projectRef]       Dashboard summary: sessions, signals, tasks, screeners
 
 Options:
   --env <env>                stage | production | local
   --json                     JSON output
 
 Discovery:
-  Need an org handle for \`list\` or \`create\`? Run \`usertold auth whoami --json\`
-  and use \`profile.personal_org_handle\` for your personal workspace.
+  \`list\` and \`create\` default to your personal workspace from \`usertold auth whoami --json\`.
+  Pass \`<orgHandle>\` or \`--org <orgHandle>\` to target another workspace.
+  Set a current project with \`usertold project use <projectRef>\` to omit <projectRef>
+  from project-scoped commands.
 
 Examples:
   usertold auth whoami --json
+  usertold project list --env stage
   usertold project list acme --env stage
-  usertold project create acme --name "Demo" --description "Smoke test"
+  usertold project create --name "Demo" --description "Smoke test"
+  usertold project use acme/checkout
   usertold project update acme/checkout --repo https://github.com/acme/app --branch main
   usertold project snippet acme/checkout
   usertold project status acme/checkout --json
+  usertold project overview acme/checkout
+  usertold project overview acme/checkout --json
 `;
 function printProjectHelp() {
     console.log(PROJECT_HELP);
 }
-function requireOrgHandleForProjectSetup(parsed, commandLabel) {
-    const orgHandle = parsed.positionals[0];
-    if (!orgHandle) {
-        failArgs(`Missing required organization handle for "${commandLabel}". ` + 'Discover it with "usertold auth whoami --json" and use "profile.personal_org_handle" as <orgHandle> or --org.');
-    }
-    return orgHandle;
-}
 
 const PROCESSING_STATUS_FILTERS = new Set([
     'failed',
@@ -9919,7 +10542,7 @@ function readProcessedStatus(event) {
     }
 }
 
-const FLAGS$c = {
+const FLAGS$b = {
     list: [
         'status',
         'study',
@@ -9963,7 +10586,7 @@ function projectApi(projectRef) {
     return buildProjectApiPathFromRef(projectRef, '', '<projectRef>');
 }
 // ─── Helpers ─────────────────────────────────────────────────────────────────
-function formatDuration$1(seconds) {
+function formatDuration(seconds) {
     if (seconds == null || seconds < 0) return '-';
     const mins = Math.floor(seconds / 60);
     const secs = seconds % 60;
@@ -10068,11 +10691,11 @@ const SPINNER_FRAMES = [
     '\u280F'
 ];
 async function pollUntilDone(opts) {
-    const deadline = opts.timeoutMs === Infinity ? Infinity : Date.now() + opts.timeoutMs;
+    const startedAt = performance.now();
     let frame = 0;
     let lastEventCount = 0;
     let lastSignalCount = 0;
-    for(;;){
+    while(true){
         const status = await fetchProcessingStatus(opts.env, opts.projectId, opts.sessionId);
         if (opts.json) {
             console.log(JSON.stringify(status));
@@ -10132,13 +10755,16 @@ async function pollUntilDone(opts) {
             if (!opts.json) process.stderr.write('\n');
             process.exit(status.status === 'failed' ? 1 : 0);
         }
-        if (Date.now() >= deadline) {
-            if (!opts.json) process.stderr.write('\n');
-            process.stderr.write('Timed out waiting for processing to complete.\n');
-            process.exit(2);
-        }
+        // Deadline is enforced *after* the status check so that a terminal state
+        // arriving during the final sleep window is still observed. Monotonic
+        // clock so wall-clock jumps (NTP, manual time changes) can't shorten or
+        // extend the wait.
+        if (opts.timeoutMs !== Infinity && performance.now() - startedAt >= opts.timeoutMs) break;
         await setTimeout$1(opts.intervalMs);
     }
+    if (!opts.json) process.stderr.write('\n');
+    process.stderr.write('Timed out waiting for processing to complete.\n');
+    process.exit(2);
 }
 // ─── Command handler ─────────────────────────────────────────────────────────
 async function handleSessionCommand(subcommand, parsed) {
@@ -10150,9 +10776,11 @@ async function handleSessionCommand(subcommand, parsed) {
     switch(subcommand){
         case 'list':
             {
-                validateFlags(parsed, FLAGS$c.list);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                validateFlags(parsed, FLAGS$b.list);
+                const { projectRef: projectId } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'session list'
+                });
                 const params = new URLSearchParams();
                 if (parsed.options.status && parsed.options.status !== 'true') {
                     params.set('status', parsed.options.status);
@@ -10184,8 +10812,10 @@ async function handleSessionCommand(subcommand, parsed) {
             }
         case 'create':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                const { projectRef: projectId } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'session create'
+                });
                 const body = {};
                 if (parsed.options.name && parsed.options.name !== 'true') {
                     body.participant_name = parsed.options.name;
@@ -10222,9 +10852,11 @@ async function handleSessionCommand(subcommand, parsed) {
             }
         case 'get':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session get'
+                });
+                const sessionId = args[0];
                 const data = await requestProjectContractJson('sessionGet', {
                     env,
                     projectRef: projectId,
@@ -10238,9 +10870,11 @@ async function handleSessionCommand(subcommand, parsed) {
         // ── Phase 1.1: session status ──────────────────────────────────────────
         case 'status':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session status'
+                });
+                const sessionId = args[0];
                 const data = await fetchSessionDetail(env, projectId, sessionId);
                 const { session, events } = data;
                 const processingDetails = deriveProcessingDetails(events);
@@ -10293,7 +10927,7 @@ async function handleSessionCommand(subcommand, parsed) {
                     console.log(`Session:     ${session.id}`);
                     console.log(`Status:      ${session.status}`);
                     console.log(`Processing:  ${processingDetail}`);
-                    console.log(`Duration:    ${formatDuration$1(session.duration_seconds)}`);
+                    console.log(`Duration:    ${formatDuration(session.duration_seconds)}`);
                     console.log(`Audio:       ${hasAudio ? 'available' : 'not available'}`);
                     console.log(`Screen:      ${hasScreen ? 'available' : 'not available'}`);
                     console.log(`Signals:     ${signalCount}`);
@@ -10305,9 +10939,11 @@ async function handleSessionCommand(subcommand, parsed) {
         // ── Phase 1.2: session events ──────────────────────────────────────────
         case 'events':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session events'
+                });
+                const sessionId = args[0];
                 const data = await fetchSessionDetail(env, projectId, sessionId);
                 let { events } = data;
                 const sessionStartMs = data.session.started_at ? new Date(data.session.started_at).getTime() : events.length > 0 ? events[0].timestamp_ms : 0;
@@ -10340,9 +10976,11 @@ async function handleSessionCommand(subcommand, parsed) {
             }
         case 'update':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session update'
+                });
+                const sessionId = args[0];
                 const body = {};
                 if (parsed.options.status && parsed.options.status !== 'true') {
                     body.status = parsed.options.status;
@@ -10366,9 +11004,11 @@ async function handleSessionCommand(subcommand, parsed) {
             }
         case 'delete':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session delete'
+                });
+                const sessionId = args[0];
                 if (getBooleanOption(parsed, 'dry-run')) {
                     if (isJsonOutput(parsed)) {
                         console.log(JSON.stringify({
@@ -10395,9 +11035,11 @@ async function handleSessionCommand(subcommand, parsed) {
         // ── Phase 2.2: transcript (R2 first, then fallback) ────────────────────
         case 'transcript':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session transcript'
+                });
+                const sessionId = args[0];
                 const useRaw = getBooleanOption(parsed, 'raw');
                 // Try R2 transcript first (unless --raw)
                 if (!useRaw && !getBooleanOption(parsed, 'json')) {
@@ -10440,9 +11082,11 @@ async function handleSessionCommand(subcommand, parsed) {
         // ── Phase 2.4: timeline ────────────────────────────────────────────────
         case 'timeline':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session timeline'
+                });
+                const sessionId = args[0];
                 const r2Text = await requestProjectContractText('sessionTimeline', {
                     env,
                     projectRef: projectId,
@@ -10469,9 +11113,11 @@ async function handleSessionCommand(subcommand, parsed) {
         // ── Enriched timeline ────────────────────────────────────────────────
         case 'enriched-timeline':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session enriched-timeline'
+                });
+                const sessionId = args[0];
                 const r2Text = await requestProjectContractText('sessionEnrichedTimeline', {
                     env,
                     projectRef: projectId,
@@ -10528,9 +11174,11 @@ async function handleSessionCommand(subcommand, parsed) {
         // ── Phase 1.4: media (absolute URLs) ───────────────────────────────────
         case 'media':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session media'
+                });
+                const sessionId = args[0];
                 const baseUrl = resolveBaseUrl(env);
                 const data = await requestProjectContractJson('sessionGet', {
                     env,
@@ -10571,9 +11219,11 @@ async function handleSessionCommand(subcommand, parsed) {
         // ── Phase 2.5: audio download ──────────────────────────────────────────
         case 'audio':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session audio'
+                });
+                const sessionId = args[0];
                 const outputOpt = parsed.options.output && parsed.options.output !== 'true' ? parsed.options.output : null;
                 const outPath = outputOpt || `${sessionId}-audio.webm`;
                 const buffer = await requestProjectContractBinary('sessionMediaAudioFull', {
@@ -10590,9 +11240,11 @@ async function handleSessionCommand(subcommand, parsed) {
         // ── Screen download ─────────────────────────────────────────────────
         case 'screen':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session screen'
+                });
+                const sessionId = args[0];
                 const outputOpt = parsed.options.output && parsed.options.output !== 'true' ? parsed.options.output : null;
                 const outPath = outputOpt || `${sessionId}-screen.webm`;
                 const buffer = await requestProjectContractBinary('sessionMediaScreenFull', {
@@ -10608,9 +11260,11 @@ async function handleSessionCommand(subcommand, parsed) {
             }
         case 'reprocess':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session reprocess'
+                });
+                const sessionId = args[0];
                 const data = await requestProjectContractJson('sessionReprocess', {
                     env,
                     projectRef: projectId,
@@ -10636,9 +11290,11 @@ async function handleSessionCommand(subcommand, parsed) {
             }
         case 'retry-media-merge':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session retry-media-merge'
+                });
+                const sessionId = args[0];
                 const data = await requestProjectContractJson('sessionRetryMediaMerge', {
                     env,
                     projectRef: projectId,
@@ -10651,9 +11307,11 @@ async function handleSessionCommand(subcommand, parsed) {
             }
         case 'watch':
             {
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const sessionId = requirePositional(parsed, 1, '<sessionId>');
-                assertNoExtraPositionals(parsed, 2);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'session watch'
+                });
+                const sessionId = args[0];
                 const intervalStr = parsed.options.interval && parsed.options.interval !== 'true' ? parsed.options.interval : '4';
                 const intervalSec = parseInt(intervalStr, 10);
                 if (isNaN(intervalSec) || intervalSec < 1) fail('--interval must be a positive integer (seconds)');
@@ -10678,23 +11336,23 @@ Usage:
   usertold session <command> [options]
 
 Commands:
-  list <projectRef> [--status <status>] [--processing-status <failed|done>] [--study <studyId>] [--limit <n>] [--offset <n>]
-  create <projectRef> [--name <participant>] [--email <email>] [--mode <voice|text|async>]
+  list [projectRef] [--status <status>] [--processing-status <failed|done>] [--study <studyId>] [--limit <n>] [--offset <n>]
+  create [projectRef] [--name <participant>] [--email <email>] [--mode <voice|text|async>]
   end <sessionId> --key <projectPublicOrSecretKey>
-  get <projectRef> <sessionId>
-  status <projectRef> <sessionId>         Show session + processing status summary
-  events <projectRef> <sessionId> [--type <type>]  Show session events (processing|conductor|all)
-  update <projectRef> <sessionId> [--status <status>] [--summary "..."]
-  delete <projectRef> <sessionId>
-  transcript <projectRef> <sessionId>     Print transcript (--raw for messages-only fallback)
-  timeline <projectRef> <sessionId>       Print session timeline from R2
-  enriched-timeline <projectRef> <sessionId>  Print enriched timeline (diarized + annotations)
-  screen <projectRef> <sessionId> [--output file.webm]   Download screen recording
-  media <projectRef> <sessionId>          Show audio/screen chunk counts and media URLs
-  audio <projectRef> <sessionId> [--chunk <n>] [--output file.webm]  Download audio
-  reprocess <projectRef> <sessionId> [--wait] [--timeout <s>]
-  retry-media-merge <projectRef> <sessionId>       Retry audio/screen media merge
-  watch <projectRef> <sessionId> [--interval <s>] [--verbose] [--signals]  Poll processing status until done
+  get [projectRef] <sessionId>
+  status [projectRef] <sessionId>         Show session + processing status summary
+  events [projectRef] <sessionId> [--type <type>]  Show session events (processing|conductor|all)
+  update [projectRef] <sessionId> [--status <status>] [--summary "..."]
+  delete [projectRef] <sessionId>
+  transcript [projectRef] <sessionId>     Print transcript (--raw for messages-only fallback)
+  timeline [projectRef] <sessionId>       Print session timeline from R2
+  enriched-timeline [projectRef] <sessionId>  Print enriched timeline (diarized + annotations)
+  screen [projectRef] <sessionId> [--output file.webm]   Download screen recording
+  media [projectRef] <sessionId>          Show audio/screen chunk counts and media URLs
+  audio [projectRef] <sessionId> [--chunk <n>] [--output file.webm]  Download audio
+  reprocess [projectRef] <sessionId> [--wait] [--timeout <s>]
+  retry-media-merge [projectRef] <sessionId>       Retry audio/screen media merge
+  watch [projectRef] <sessionId> [--interval <s>] [--verbose] [--signals]  Poll processing status until done
 
 Options:
   --wait                       Block until processing completes (reprocess, study reprocess)
@@ -10703,6 +11361,8 @@ Options:
   --json                     JSON output
 
 Examples:
+  usertold project use acme/checkout
+  usertold session status ses_123
   usertold session status acme/checkout ses_123
   usertold session events acme/checkout ses_123 --type processing
   usertold session transcript acme/checkout ses_123
@@ -10722,9 +11382,10 @@ function printSessionHelp() {
     console.log(SESSION_HELP);
 }
 
-const FLAGS$b = {
+const FLAGS$a = {
     list: [
         'type',
+        'target-surface',
         'session',
         'task',
         'search',
@@ -10761,9 +11422,11 @@ async function handleSignalCommand(subcommand, parsed) {
     switch(subcommand){
         case 'list':
             {
-                validateFlags(parsed, FLAGS$b.list);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                validateFlags(parsed, FLAGS$a.list);
+                const { projectRef } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'signal list'
+                });
                 const query = buildSignalQuery(parsed);
                 const data = await requestProjectContract({
                     env,
@@ -10781,10 +11444,12 @@ async function handleSignalCommand(subcommand, parsed) {
             }
         case 'get':
             {
-                validateFlags(parsed, FLAGS$b.get);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const signalId = requirePositional(parsed, 1, '<signalId>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$a.get);
+                const { projectRef, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'signal get'
+                });
+                const signalId = args[0];
                 const data = await requestProjectContract({
                     env,
                     key: 'signalGet',
@@ -10799,10 +11464,12 @@ async function handleSignalCommand(subcommand, parsed) {
             }
         case 'annotate':
             {
-                validateFlags(parsed, FLAGS$b.annotate);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const signalId = requirePositional(parsed, 1, '<signalId>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$a.annotate);
+                const { projectRef, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'signal annotate'
+                });
+                const signalId = args[0];
                 const text = requireOption(parsed, 'text');
                 const data = await requestProjectContract({
                     env,
@@ -10821,10 +11488,12 @@ async function handleSignalCommand(subcommand, parsed) {
             }
         case 'dismiss':
             {
-                validateFlags(parsed, FLAGS$b.dismiss);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const signalId = requirePositional(parsed, 1, '<signalId>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$a.dismiss);
+                const { projectRef, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'signal dismiss'
+                });
+                const signalId = args[0];
                 const reason = requireOption(parsed, 'reason');
                 const data = await requestProjectContract({
                     env,
@@ -10843,10 +11512,12 @@ async function handleSignalCommand(subcommand, parsed) {
             }
         case 'undismiss':
             {
-                validateFlags(parsed, FLAGS$b.undismiss);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const signalId = requirePositional(parsed, 1, '<signalId>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$a.undismiss);
+                const { projectRef, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'signal undismiss'
+                });
+                const signalId = args[0];
                 const data = await requestProjectContract({
                     env,
                     key: 'signalUndismiss',
@@ -10861,11 +11532,12 @@ async function handleSignalCommand(subcommand, parsed) {
             }
         case 'link':
             {
-                validateFlags(parsed, FLAGS$b.link);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const signalId = requirePositional(parsed, 1, '<signalId>');
-                const taskId = requirePositional(parsed, 2, '<taskId>');
-                assertNoExtraPositionals(parsed, 3);
+                validateFlags(parsed, FLAGS$a.link);
+                const { projectRef, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 2,
+                    commandLabel: 'signal link'
+                });
+                const [signalId, taskId] = args;
                 const data = await requestProjectContract({
                     env,
                     key: 'signalLink',
@@ -10883,10 +11555,12 @@ async function handleSignalCommand(subcommand, parsed) {
             }
         case 'unlink':
             {
-                validateFlags(parsed, FLAGS$b.unlink);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const signalId = requirePositional(parsed, 1, '<signalId>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$a.unlink);
+                const { projectRef, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'signal unlink'
+                });
+                const signalId = args[0];
                 const data = await requestProjectContract({
                     env,
                     key: 'signalUnlink',
@@ -10901,10 +11575,12 @@ async function handleSignalCommand(subcommand, parsed) {
             }
         case 'delete':
             {
-                validateFlags(parsed, FLAGS$b.delete);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const signalId = requirePositional(parsed, 1, '<signalId>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$a.delete);
+                const { projectRef, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'signal delete'
+                });
+                const signalId = args[0];
                 if (getBooleanOption(parsed, 'dry-run')) {
                     if (isJsonOutput(parsed)) {
                         console.log(JSON.stringify({
@@ -10932,10 +11608,12 @@ async function handleSignalCommand(subcommand, parsed) {
             }
         case 'bulk-link':
             {
-                validateFlags(parsed, FLAGS$b['bulk-link']);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const taskId = requirePositional(parsed, 1, '<taskId>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$a['bulk-link']);
+                const { projectRef, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'signal bulk-link'
+                });
+                const taskId = args[0];
                 const signalIds = parseSignalIdsOption(parsed);
                 const data = await requestProjectContract({
                     env,
@@ -10952,9 +11630,11 @@ async function handleSignalCommand(subcommand, parsed) {
             }
         case 'bulk-delete':
             {
-                validateFlags(parsed, FLAGS$b['bulk-delete']);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                validateFlags(parsed, FLAGS$a['bulk-delete']);
+                const { projectRef } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'signal bulk-delete'
+                });
                 const signalIds = parseSignalIdsOption(parsed);
                 if (getBooleanOption(parsed, 'dry-run')) {
                     if (isJsonOutput(parsed)) {
@@ -10990,19 +11670,20 @@ Usage:
   usertold signal <command> [options]
 
 Commands:
-  list <projectRef> [filters]          List signals (excludes dismissed by default)
-  get <projectRef> <signalId>          Get signal details
-  annotate <projectRef> <signalId> --text "..."   Add human annotation
-  dismiss <projectRef> <signalId> --reason "..."  Soft-exclude signal
-  undismiss <projectRef> <signalId>    Restore dismissed signal
-  link <projectRef> <signalId> <taskId>           Link signal to task
-  unlink <projectRef> <signalId>       Unlink signal from task
-  delete <projectRef> <signalId>       Permanently delete a signal
-  bulk-link <projectRef> <taskId> --signals <id1,id2,...>   Link multiple signals to one task
-  bulk-delete <projectRef> --signals <id1,id2,...>          Permanently delete multiple signals
+  list [projectRef] [filters]          List signals (excludes dismissed by default)
+  get [projectRef] <signalId>          Get signal details
+  annotate [projectRef] <signalId> --text "..."   Add human annotation
+  dismiss [projectRef] <signalId> --reason "..."  Soft-exclude signal
+  undismiss [projectRef] <signalId>    Restore dismissed signal
+  link [projectRef] <signalId> <taskId>           Link signal to task
+  unlink [projectRef] <signalId>       Unlink signal from task
+  delete [projectRef] <signalId>       Permanently delete a signal
+  bulk-link [projectRef] <taskId> --signals <id1,id2,...>   Link multiple signals to one task
+  bulk-delete [projectRef] --signals <id1,id2,...>          Permanently delete multiple signals
 
 List filters:
   --type <type>              Signal type (struggling_moment, desired_outcome, etc.)
+  --target-surface <surface> Filter by target surface (defaults to product_under_test; use all for every surface)
   --session <sessionId>      Filter by session
   --task <taskId>            Filter by task (use "none" for unlinked)
   --search <text>            Search in quotes
@@ -11017,6 +11698,8 @@ Options:
   --json                     JSON output
 
 Examples:
+  usertold project use acme/checkout
+  usertold signal list --type struggling_moment
   usertold signal list acme/checkout --type struggling_moment
   usertold signal list acme/checkout --dismissed
   usertold signal list acme/checkout --all --limit 50
@@ -11040,6 +11723,7 @@ function printSignalCards(data) {
     for (const s of signals){
         const conf = typeof s.confidence === 'number' ? `${Math.round(s.confidence * 100)}%` : '';
         console.log(`[${s.signal_type}] ${s.id}  (confidence: ${conf})`);
+        console.log(`  Target surface: ${s.target_surface}`);
         console.log(`  "${s.quote}"`);
         if (s.context) {
             const contextParts = s.context.split('\n').filter(Boolean).map((l)=>l.trim()).join('  ');
@@ -11059,6 +11743,9 @@ function buildSignalQuery(parsed) {
     if (parsed.options.type && parsed.options.type !== 'true') {
         query.type = parsed.options.type;
     }
+    if (parsed.options['target-surface'] && parsed.options['target-surface'] !== 'true') {
+        query.target_surface = parsed.options['target-surface'];
+    }
     if (parsed.options.session && parsed.options.session !== 'true') {
         query.session_id = parsed.options.session;
     }
@@ -11094,10 +11781,11 @@ function parseSignalIdsOption(parsed) {
     return signalIds;
 }
 
-const FLAGS$a = {
+const FLAGS$9 = {
     list: [
         'status',
         'type',
+        'target-surface',
         'session',
         'min-priority',
         'limit',
@@ -11126,7 +11814,6 @@ const FLAGS$a = {
         'priority'
     ],
     delete: [],
-    measure: [],
     push: [
         'provider'
     ],
@@ -11147,9 +11834,11 @@ async function handleTaskCommand(subcommand, parsed) {
     switch(subcommand){
         case 'list':
             {
-                validateFlags(parsed, FLAGS$a.list);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                validateFlags(parsed, FLAGS$9.list);
+                const { projectRef } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'task list'
+                });
                 const query = {};
                 if (parsed.options.status && parsed.options.status !== 'true') {
                     query.status = parsed.options.status;
@@ -11157,6 +11846,9 @@ async function handleTaskCommand(subcommand, parsed) {
                 if (parsed.options.type && parsed.options.type !== 'true') {
                     query.type = parsed.options.type;
                 }
+                if (parsed.options['target-surface'] && parsed.options['target-surface'] !== 'true') {
+                    query.target_surface = parsed.options['target-surface'];
+                }
                 if (parsed.options.session && parsed.options.session !== 'true') {
                     query.session_id = parsed.options.session;
                 }
@@ -11181,10 +11873,12 @@ async function handleTaskCommand(subcommand, parsed) {
             }
         case 'get':
             {
-                validateFlags(parsed, FLAGS$a.get);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const taskId = requirePositional(parsed, 1, '<taskId>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$9.get);
+                const { projectRef, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'task get'
+                });
+                const taskId = args[0];
                 const data = await requestProjectContract({
                     env,
                     key: 'taskGet',
@@ -11199,9 +11893,11 @@ async function handleTaskCommand(subcommand, parsed) {
             }
         case 'create':
             {
-                validateFlags(parsed, FLAGS$a.create);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                validateFlags(parsed, FLAGS$9.create);
+                const { projectRef } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'task create'
+                });
                 const title = requireOption(parsed, 'title');
                 const body = {
                     title
@@ -11230,10 +11926,12 @@ async function handleTaskCommand(subcommand, parsed) {
             }
         case 'update':
             {
-                validateFlags(parsed, FLAGS$a.update);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const taskId = requirePositional(parsed, 1, '<taskId>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$9.update);
+                const { projectRef, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'task update'
+                });
+                const taskId = args[0];
                 const body = {};
                 if (parsed.options.title && parsed.options.title !== 'true') {
                     body.title = parsed.options.title;
@@ -11271,10 +11969,12 @@ async function handleTaskCommand(subcommand, parsed) {
             }
         case 'delete':
             {
-                validateFlags(parsed, FLAGS$a.delete);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const taskId = requirePositional(parsed, 1, '<taskId>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$9.delete);
+                const { projectRef, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'task delete'
+                });
+                const taskId = args[0];
                 if (getBooleanOption(parsed, 'dry-run')) {
                     if (isJsonOutput(parsed)) {
                         console.log(JSON.stringify({
@@ -11300,30 +12000,14 @@ async function handleTaskCommand(subcommand, parsed) {
                 printOutput(data, parsed);
                 return;
             }
-        case 'measure':
-            {
-                validateFlags(parsed, FLAGS$a.measure);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const taskId = requirePositional(parsed, 1, '<taskId>');
-                assertNoExtraPositionals(parsed, 2);
-                const data = await requestProjectContract({
-                    env,
-                    key: 'taskMeasureImpact',
-                    projectRef,
-                    sourceLabel: '<projectRef>',
-                    pathParams: {
-                        taskId: taskId
-                    }
-                });
-                printOutput(data, parsed);
-                return;
-            }
         case 'push-status':
             {
-                validateFlags(parsed, FLAGS$a['push-status']);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const taskId = requirePositional(parsed, 1, '<taskId>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$9['push-status']);
+                const { projectRef, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'task push-status'
+                });
+                const taskId = args[0];
                 const data = await requestProjectContract({
                     env,
                     key: 'taskProviderState',
@@ -11338,10 +12022,12 @@ async function handleTaskCommand(subcommand, parsed) {
             }
         case 'push':
             {
-                validateFlags(parsed, FLAGS$a.push);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                const taskId = requirePositional(parsed, 1, '<taskId>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$9.push);
+                const { projectRef, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'task push'
+                });
+                const taskId = args[0];
                 const provider = parsed.options.provider && parsed.options.provider !== 'true' ? parsed.options.provider : null;
                 if (provider && provider !== 'github' && provider !== 'linear' && provider !== 'auto') {
                     fail('--provider must be one of: github, linear, auto');
@@ -11375,9 +12061,11 @@ async function handleTaskCommand(subcommand, parsed) {
             }
         case 'create-from-signals':
             {
-                validateFlags(parsed, FLAGS$a['create-from-signals']);
-                const projectRef = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                validateFlags(parsed, FLAGS$9['create-from-signals']);
+                const { projectRef } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'task create-from-signals'
+                });
                 const title = requireOption(parsed, 'title');
                 const signalsStr = requireOption(parsed, 'signals');
                 const signalIds = signalsStr.split(',').map((s)=>s.trim()).filter(Boolean);
@@ -11413,29 +12101,31 @@ Usage:
   usertold task <command> [options]
 
 Commands:
-  list <projectRef> [--status <status>] [--type <type>] [--session <sessionId>] [--min-priority <n>] [--limit <n>] [--offset <n>]
-  get <projectRef> <taskId>
-  create <projectRef> --title "..." [--description "..."] [--type <type>] [--effort <xs|s|m|l|xl>] [--priority <0-100>]
-  create-from-signals <projectRef> --title "..." --signals <id1,id2,...> [--description "..."] [--type <type>]
-  update <projectRef> <taskId> [--title] [--description] [--type] [--status] [--effort] [--priority]
-  delete <projectRef> <taskId>
-  measure <projectRef> <taskId>
-  push <projectRef> <taskId> [--provider <github|linear|auto>]
-  push-status <projectRef> <taskId>      Check provider state (GitHub issue URL, status)
+  list [projectRef] [--status <status>] [--type <type>] [--target-surface <surface|all>] [--session <sessionId>] [--min-priority <n>] [--limit <n>] [--offset <n>]
+  get [projectRef] <taskId>
+  create [projectRef] --title "..." [--description "..."] [--type <type>] [--effort <xs|s|m|l|xl>] [--priority <0-100>]
+  create-from-signals [projectRef] --title "..." --signals <id1,id2,...> [--description "..."] [--type <type>]
+  update [projectRef] <taskId> [--title] [--description] [--type] [--status] [--effort] [--priority]
+  delete [projectRef] <taskId>
+  push [projectRef] <taskId> [--provider <github|linear|auto>]  Send to provider ('auto' uses project settings)
+  push-status [projectRef] <taskId>       Inspect provider state — issue/PR URL, sync status, last update
 
 Options:
   --env <env>                stage | production | local
+  --target-surface <surface> defaults to product_under_test; use all for every surface
   --json                     JSON output
 
 Examples:
+  usertold project use acme/checkout
+  usertold task list --status ready
   usertold task list acme/checkout --status ready
   usertold task list acme/checkout --type bug --limit 10
+  usertold task list acme/checkout --target-surface all
   usertold task list acme/checkout --min-priority 60
   usertold task create acme/checkout --title "Fix checkout bug" --type bug --effort s
   usertold task create-from-signals acme/checkout --title "Fix onboarding" --signals sig_1,sig_2,sig_3
   usertold task update acme/checkout tsk_456 --status in_progress --effort m
   usertold task delete acme/checkout tsk_456
-  usertold task measure acme/checkout tsk_456
   usertold task push acme/checkout tsk_456
   usertold task push acme/checkout tsk_456 --provider linear
   usertold task push-status acme/checkout tsk_456
@@ -11456,7 +12146,7 @@ function isRetryableTaskPushFailure(response, error) {
     return error instanceof Error;
 }
 
-const FLAGS$9 = {
+const FLAGS$8 = {
     list: [],
     create: [
         'title',
@@ -11506,9 +12196,11 @@ async function handleScreenerCommand(subcommand, parsed) {
     switch(subcommand){
         case 'list':
             {
-                validateFlags(parsed, FLAGS$9.list);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                validateFlags(parsed, FLAGS$8.list);
+                const { projectRef: projectId } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'screener list'
+                });
                 const data = await requestProjectContractJson('screenersList', {
                     env,
                     projectRef: projectId
@@ -11518,9 +12210,11 @@ async function handleScreenerCommand(subcommand, parsed) {
             }
         case 'create':
             {
-                validateFlags(parsed, FLAGS$9.create);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                validateFlags(parsed, FLAGS$8.create);
+                const { projectRef: projectId } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'screener create'
+                });
                 const title = requireOption(parsed, 'title');
                 const body = {
                     title
@@ -11594,10 +12288,12 @@ async function handleScreenerCommand(subcommand, parsed) {
             }
         case 'get':
             {
-                validateFlags(parsed, FLAGS$9.get);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const screenerId = requirePositional(parsed, 1, '<screenerRef>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$8.get);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'screener get'
+                });
+                const screenerId = args[0];
                 const data = await requestProjectContractJson('screenerGet', {
                     env,
                     projectRef: projectId,
@@ -11610,10 +12306,12 @@ async function handleScreenerCommand(subcommand, parsed) {
             }
         case 'update':
             {
-                validateFlags(parsed, FLAGS$9.update);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const screenerId = requirePositional(parsed, 1, '<screenerRef>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$8.update);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'screener update'
+                });
+                const screenerId = args[0];
                 const body = {};
                 for (const field of [
                     'title',
@@ -11650,10 +12348,12 @@ async function handleScreenerCommand(subcommand, parsed) {
             }
         case 'delete':
             {
-                validateFlags(parsed, FLAGS$9.delete);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const screenerId = requirePositional(parsed, 1, '<screenerRef>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$8.delete);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'screener delete'
+                });
+                const screenerId = args[0];
                 if (getBooleanOption(parsed, 'dry-run')) {
                     if (isJsonOutput(parsed)) {
                         console.log(JSON.stringify({
@@ -11679,10 +12379,12 @@ async function handleScreenerCommand(subcommand, parsed) {
             }
         case 'set-questions':
             {
-                validateFlags(parsed, FLAGS$9['set-questions']);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const screenerId = requirePositional(parsed, 1, '<screenerRef>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$8['set-questions']);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'screener set-questions'
+                });
+                const screenerId = args[0];
                 const questionsInput = requireOption(parsed, 'questions');
                 const questions = await parseJsonOrFile(questionsInput, '--questions');
                 const data = await requestProjectContractJson('screenerSetQuestions', {
@@ -11700,10 +12402,12 @@ async function handleScreenerCommand(subcommand, parsed) {
             }
         case 'list-responses':
             {
-                validateFlags(parsed, FLAGS$9['list-responses']);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const screenerId = requirePositional(parsed, 1, '<screenerRef>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$8['list-responses']);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'screener list-responses'
+                });
+                const screenerId = args[0];
                 const data = await requestProjectContractJson('screenerGet', {
                     env,
                     projectRef: projectId,
@@ -11723,11 +12427,12 @@ async function handleScreenerCommand(subcommand, parsed) {
             }
         case 'get-response':
             {
-                validateFlags(parsed, FLAGS$9['get-response']);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const screenerId = requirePositional(parsed, 1, '<screenerRef>');
-                const responseId = requirePositional(parsed, 2, '<responseId>');
-                assertNoExtraPositionals(parsed, 3);
+                validateFlags(parsed, FLAGS$8['get-response']);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 2,
+                    commandLabel: 'screener get-response'
+                });
+                const [screenerId, responseId] = args;
                 const data = await requestProjectContractJson('screenerResponseGet', {
                     env,
                     projectRef: projectId,
@@ -11741,11 +12446,12 @@ async function handleScreenerCommand(subcommand, parsed) {
             }
         case 'qualify-response':
             {
-                validateFlags(parsed, FLAGS$9['qualify-response']);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const screenerId = requirePositional(parsed, 1, '<screenerRef>');
-                const responseId = requirePositional(parsed, 2, '<responseId>');
-                assertNoExtraPositionals(parsed, 3);
+                validateFlags(parsed, FLAGS$8['qualify-response']);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 2,
+                    commandLabel: 'screener qualify-response'
+                });
+                const [screenerId, responseId] = args;
                 const reason = parsed.options.reason && parsed.options.reason !== 'true' ? parsed.options.reason : undefined;
                 const data = await requestProjectContractJson('screenerResponsePatch', {
                     env,
@@ -11764,11 +12470,12 @@ async function handleScreenerCommand(subcommand, parsed) {
             }
         case 'disqualify-response':
             {
-                validateFlags(parsed, FLAGS$9['disqualify-response']);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const screenerId = requirePositional(parsed, 1, '<screenerRef>');
-                const responseId = requirePositional(parsed, 2, '<responseId>');
-                assertNoExtraPositionals(parsed, 3);
+                validateFlags(parsed, FLAGS$8['disqualify-response']);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 2,
+                    commandLabel: 'screener disqualify-response'
+                });
+                const [screenerId, responseId] = args;
                 const reason = requireOption(parsed, 'reason');
                 const data = await requestProjectContractJson('screenerResponsePatch', {
                     env,
@@ -11794,16 +12501,16 @@ Usage:
   usertold screener <command> [options]
 
 Commands:
-  list <projectRef>
-  create <projectRef> --title <title> [options]
-  get <projectRef> <screenerRef>
-  update <projectRef> <screenerRef> [--title ...] [--status draft|active|paused|closed]
-  delete <projectRef> <screenerRef>
-  set-questions <projectRef> <screenerRef> --questions <json|@file>
-  list-responses <projectRef> <screenerRef>
-  get-response <projectRef> <screenerRef> <responseId>
-  qualify-response <projectRef> <screenerRef> <responseId> [--reason "..."]
-  disqualify-response <projectRef> <screenerRef> <responseId> --reason "..."
+  list [projectRef]
+  create [projectRef] --title <title> [options]
+  get [projectRef] <screenerRef>
+  update [projectRef] <screenerRef> [--title ...] [--status draft|active|paused|closed]
+  delete [projectRef] <screenerRef>
+  set-questions [projectRef] <screenerRef> --questions <json|@file>
+  list-responses [projectRef] <screenerRef>
+  get-response [projectRef] <screenerRef> <responseId>
+  qualify-response [projectRef] <screenerRef> <responseId> [--reason "..."]
+  disqualify-response [projectRef] <screenerRef> <responseId> --reason "..."
 
 Create options:
   --title <title>                        Screener title (required)
@@ -11835,6 +12542,8 @@ General options:
   --json                     JSON output
 
 Examples:
+  usertold project use acme/checkout
+  usertold screener create --title "Power User Study" --handle power-users --activate --questions @screener.json
   usertold screener create acme/checkout --title "Power User Study" --handle power-users --activate --questions @screener.json
   usertold screener update acme/checkout power-users --status active
   usertold screener set-questions acme/checkout power-users --questions @questions.json
@@ -11873,7 +12582,7 @@ function extractMarkdownH2Section(markdown, sectionName) {
     };
 }
 
-const FLAGS$8 = {
+const FLAGS$7 = {
     list: [],
     create: [
         'title',
@@ -11883,6 +12592,7 @@ const FLAGS$8 = {
         'screener-id',
         'goals',
         'script',
+        'allowed-origins',
         'activate'
     ],
     get: [],
@@ -11894,7 +12604,8 @@ const FLAGS$8 = {
         'type',
         'screener-id',
         'goals',
-        'script'
+        'script',
+        'allowed-origins'
     ],
     delete: [],
     export: [],
@@ -11922,9 +12633,11 @@ async function handleStudyCommand(subcommand, parsed) {
     switch(subcommand){
         case 'list':
             {
-                validateFlags(parsed, FLAGS$8.list);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                validateFlags(parsed, FLAGS$7.list);
+                const { projectRef: projectId } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'study list'
+                });
                 const data = await requestProjectContractJson('studiesList', {
                     env,
                     projectRef: projectId
@@ -11934,9 +12647,11 @@ async function handleStudyCommand(subcommand, parsed) {
             }
         case 'create':
             {
-                validateFlags(parsed, FLAGS$8.create);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                assertNoExtraPositionals(parsed, 1);
+                validateFlags(parsed, FLAGS$7.create);
+                const { projectRef: projectId } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'study create'
+                });
                 const title = requireOption(parsed, 'title');
                 const body = {
                     title
@@ -11969,6 +12684,10 @@ async function handleStudyCommand(subcommand, parsed) {
                 if (scriptInput && scriptInput !== 'true') {
                     body.script = await parseJsonOrFile(scriptInput, '--script');
                 }
+                // Allowed origins: comma-separated list; empty string clears to []
+                if ('allowed-origins' in parsed.options) {
+                    body.allowed_origins = parseAllowedOrigins(parsed.options['allowed-origins']);
+                }
                 const data = await requestProjectContractJson('studyCreate', {
                     env,
                     projectRef: projectId,
@@ -12006,10 +12725,12 @@ async function handleStudyCommand(subcommand, parsed) {
             }
         case 'get':
             {
-                validateFlags(parsed, FLAGS$8.get);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const studyId = requirePositional(parsed, 1, '<studyRef>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$7.get);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'study get'
+                });
+                const studyId = args[0];
                 const data = await requestProjectContractJson('studyGet', {
                     env,
                     projectRef: projectId,
@@ -12022,10 +12743,12 @@ async function handleStudyCommand(subcommand, parsed) {
             }
         case 'update':
             {
-                validateFlags(parsed, FLAGS$8.update);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const studyId = requirePositional(parsed, 1, '<studyRef>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$7.update);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'study update'
+                });
+                const studyId = args[0];
                 const body = {};
                 // Optional string fields
                 for (const field of [
@@ -12054,8 +12777,12 @@ async function handleStudyCommand(subcommand, parsed) {
                 if (scriptInput && scriptInput !== 'true') {
                     body.script = await parseJsonOrFile(scriptInput, '--script');
                 }
+                // Allowed origins: comma-separated list; empty string clears to []
+                if ('allowed-origins' in parsed.options) {
+                    body.allowed_origins = parseAllowedOrigins(parsed.options['allowed-origins']);
+                }
                 if (Object.keys(body).length === 0) {
-                    fail('No update fields provided. Use --title, --handle, --description, --status, --type, --goals, --script, --screener-id.');
+                    fail('No update fields provided. Use --title, --handle, --description, --status, --type, --goals, --script, --screener-id, --allowed-origins.');
                 }
                 const data = await requestProjectContractJson('studyPatch', {
                     env,
@@ -12070,10 +12797,12 @@ async function handleStudyCommand(subcommand, parsed) {
             }
         case 'delete':
             {
-                validateFlags(parsed, FLAGS$8.delete);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const studyId = requirePositional(parsed, 1, '<studyRef>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$7.delete);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'study delete'
+                });
+                const studyId = args[0];
                 if (getBooleanOption(parsed, 'dry-run')) {
                     if (isJsonOutput(parsed)) {
                         console.log(JSON.stringify({
@@ -12099,10 +12828,12 @@ async function handleStudyCommand(subcommand, parsed) {
             }
         case 'export':
             {
-                validateFlags(parsed, FLAGS$8.export);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const studyId = requirePositional(parsed, 1, '<studyRef>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$7.export);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'study export'
+                });
+                const studyId = args[0];
                 const data = await requestProjectContractJson('studyGet', {
                     env,
                     projectRef: projectId,
@@ -12122,10 +12853,12 @@ async function handleStudyCommand(subcommand, parsed) {
             }
         case 'import':
             {
-                validateFlags(parsed, FLAGS$8.import);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const studyId = requirePositional(parsed, 1, '<studyRef>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$7.import);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'study import'
+                });
+                const studyId = args[0];
                 const scriptInput = requireOption(parsed, 'script');
                 const script = await parseJsonOrFile(scriptInput, '--script');
                 const data = await requestProjectContractJson('studyPatch', {
@@ -12143,10 +12876,12 @@ async function handleStudyCommand(subcommand, parsed) {
             }
         case 'reprocess':
             {
-                validateFlags(parsed, FLAGS$8.reprocess);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const studyId = requirePositional(parsed, 1, '<studyRef>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$7.reprocess);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'study reprocess'
+                });
+                const studyId = args[0];
                 // Fetch all completed sessions in the study
                 const data = await requestProjectContractJson('sessionsList', {
                     env,
@@ -12178,7 +12913,8 @@ async function handleStudyCommand(subcommand, parsed) {
                 const timeoutStr = parsed.options.timeout && parsed.options.timeout !== 'true' ? parsed.options.timeout : '600';
                 const timeoutSec = parseInt(timeoutStr, 10);
                 if (isNaN(timeoutSec) || timeoutSec < 1) fail('--timeout must be a positive integer (seconds)');
-                const deadline = Date.now() + timeoutSec * 1000;
+                const timeoutMs = timeoutSec * 1000;
+                const startedAt = performance.now();
                 const jsonMode = isJsonOutput(parsed);
                 const spinnerFrames = [
                     '\u280B',
@@ -12193,7 +12929,7 @@ async function handleStudyCommand(subcommand, parsed) {
                     '\u280F'
                 ];
                 let frame = 0;
-                for(;;){
+                while(true){
                     const batchStatus = await requestProjectContractJson('sessionProcessingStatus', {
                         env,
                         projectRef: projectId,
@@ -12232,20 +12968,23 @@ async function handleStudyCommand(subcommand, parsed) {
                         }
                         process.exit(s.failed > 0 ? 1 : 0);
                     }
-                    if (Date.now() >= deadline) {
-                        if (!jsonMode) process.stderr.write('\n');
-                        process.stderr.write('Timed out waiting for processing to complete.\n');
-                        process.exit(2);
-                    }
+                    // Deadline is enforced *after* the status check so that a completion
+                    // arriving during the final sleep window is still observed.
+                    if (performance.now() - startedAt >= timeoutMs) break;
                     await setTimeout$1(5000);
                 }
+                if (!jsonMode) process.stderr.write('\n');
+                process.stderr.write('Timed out waiting for processing to complete.\n');
+                process.exit(2);
             }
         case 'validate-script':
             {
-                validateFlags(parsed, FLAGS$8['validate-script']);
-                const projectId = requirePositional(parsed, 0, '<projectRef>');
-                const studyId = requirePositional(parsed, 1, '<studyRef>');
-                assertNoExtraPositionals(parsed, 2);
+                validateFlags(parsed, FLAGS$7['validate-script']);
+                const { projectRef: projectId, args } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 1,
+                    commandLabel: 'study validate-script'
+                });
+                const studyId = args[0];
                 const body = {};
                 const scriptInput = parsed.options.script;
                 if (scriptInput && scriptInput !== 'true') {
@@ -12267,7 +13006,7 @@ async function handleStudyCommand(subcommand, parsed) {
             }
         case 'guide':
             {
-                validateFlags(parsed, FLAGS$8.guide);
+                validateFlags(parsed, FLAGS$7.guide);
                 assertNoExtraPositionals(parsed, 0);
                 const markdown = await loadStudyDesignGuideMarkdown(env);
                 if (markdown === null) {
@@ -12305,15 +13044,15 @@ Usage:
   usertold study <command> [options]
 
 Commands:
-  list <projectRef>                               List all studies
-  create <projectRef> --title <title> [options]  Create a study
-  get <projectRef> <studyRef>                     Get study detail
-  update <projectRef> <studyRef> [options]        Update study fields (use --status active to activate)
-  delete <projectRef> <studyRef>                  Delete a study
-  export <projectRef> <studyRef>                  Export script_json to stdout
-  import <projectRef> <studyRef> --script <file>  Import script from file
-  reprocess <projectRef> <studyRef> [--wait] [--timeout <s>]  Reprocess all completed sessions
-  validate-script <projectRef> <studyRef> [--script <json|@file>] [--type <type>]  Validate script and return summary
+  list [projectRef]                               List all studies
+  create [projectRef] --title <title> [options]  Create a study
+  get [projectRef] <studyRef>                     Get study detail
+  update [projectRef] <studyRef> [options]        Update study fields (use --status active to activate)
+  delete [projectRef] <studyRef>                  Delete a study
+  export [projectRef] <studyRef>                  Export script_json to stdout
+  import [projectRef] <studyRef> --script <file>  Import script from file
+  reprocess [projectRef] <studyRef> [--wait] [--timeout <s>]  Reprocess all completed sessions
+  validate-script [projectRef] <studyRef> [--script <json|@file>] [--type <type>]  Validate script and return summary
   guide [--section <name>] [--format json]          Print study design guide
 
 Create/update options:
@@ -12325,6 +13064,7 @@ Create/update options:
   --goals <json|@file>          Goals array: [{ "id": "g1", "description": "..." }]
   --script <json|@file>         Full script JSON (StudyScriptV2 format)
   --screener-id <screenerRef>   Link to a screener
+  --allowed-origins <list>      Comma-separated list of origins allowed to embed (e.g. "https://a.com,https://b.com"). Use --allowed-origins= to clear.
   --activate                    Set status to active after create
 
 Reprocess options:
@@ -12340,10 +13080,13 @@ General options:
   --json                        JSON output
 
 Examples:
+  usertold project use acme/checkout
+  usertold study list
   usertold study list acme/checkout
   usertold study create acme/checkout --title "Checkout Study" --handle checkout-q1 --type usability --activate
   usertold study update acme/checkout checkout-q1 --status active
   usertold study update acme/checkout checkout-q1 --status paused
+  usertold study update acme/checkout checkout-q1 --allowed-origins "https://learnspeakrepeat.com"
   usertold study export acme/checkout checkout-q1 > script.json
   usertold study import acme/checkout checkout-q1 --script @script.json
   usertold study guide
@@ -12356,8 +13099,14 @@ Examples:
 function printStudyHelp() {
     console.log(STUDY_HELP);
 }
+function parseAllowedOrigins(value) {
+    if (value === undefined || value === 'true') {
+        fail('--allowed-origins requires a value. Pass a comma-separated list of origins, or --allowed-origins= to clear.');
+    }
+    return value.split(',').map((part)=>part.trim()).filter((part)=>part.length > 0);
+}
 
-const FLAGS$7 = {};
+const FLAGS$6 = {};
 const ALLOWED_METHODS = new Set([
     'GET',
     'POST',
@@ -12449,7 +13198,7 @@ function extractApiError(json, text) {
     return text.trim() || 'Request failed';
 }
 
-const FLAGS$6 = {
+const FLAGS$5 = {
     status: [],
     history: [
         'limit',
@@ -12515,141 +13264,17 @@ function printBillingHelp() {
     console.log(BILLING_HELP);
 }
 
-const FLAGS$5 = {};
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-function formatDuration(seconds) {
-    if (seconds === null || seconds < 0) return '-';
-    const mins = Math.floor(seconds / 60);
-    const secs = seconds % 60;
-    return `${mins}m ${secs}s`;
-}
-function formatDate(iso) {
-    const d = new Date(iso);
-    return d.toLocaleDateString('en-US', {
-        month: 'short',
-        day: 'numeric'
-    });
-}
-function check(value) {
-    return value ? '[x]' : '[ ]';
-}
-function formatSignalBreakdown(byType) {
-    const parts = Object.entries(byType).sort((a, b)=>b[1] - a[1]).map(([type, count])=>`${count} ${type}`);
-    return parts.length > 0 ? ` (${parts.join(', ')})` : '';
-}
-function formatTaskBreakdown(byStatus) {
-    const parts = Object.entries(byStatus).sort((a, b)=>b[1] - a[1]).map(([status, count])=>`${count} ${status}`);
-    return parts.length > 0 ? ` (${parts.join(', ')})` : '';
-}
-function formatOverview(data) {
-    const { sessions, signals, tasks, screeners, setup, recent_sessions, top_tasks } = data;
-    console.log(`Sessions:    ${sessions.total} total (${sessions.completed} completed, ${sessions.active} active)`);
-    console.log(`Signals:     ${signals.total} total${formatSignalBreakdown(signals.by_type)}`);
-    console.log(`Tasks:       ${tasks.total} total${formatTaskBreakdown(tasks.by_status)}`);
-    console.log(`Screeners:   ${screeners.total} total (${screeners.active} active, ${screeners.total_views} views, ${screeners.total_qualified} qualified)`);
-    console.log('');
-    console.log('Setup:');
-    console.log(`  ${check(setup.has_api_keys)} API keys configured`);
-    console.log(`  ${check(setup.has_active_study)} Active study`);
-    console.log(`  ${check(setup.has_active_screener)} Active screener`);
-    console.log(`  ${check(setup.has_linked_active_screener)} Active screener linked to study`);
-    console.log(`  ${check(setup.has_sessions)} Has sessions`);
-    if (recent_sessions.length > 0) {
-        console.log('');
-        console.log('Recent sessions:');
-        for (const s of recent_sessions){
-            const name = s.participant_name || 'anonymous';
-            const dur = formatDuration(s.duration_seconds);
-            const date = formatDate(s.created_at);
-            const id = s.id.length > 12 ? `${s.id.slice(0, 12)}...` : s.id;
-            console.log(`  ${id}  ${s.status.padEnd(10)}  ${dur.padEnd(8)}  ${String(s.signal_count).padStart(2)} signals  ${date}  ${name}`);
-        }
-    }
-    if (top_tasks.length > 0) {
-        console.log('');
-        console.log('Top tasks:');
-        for (const t of top_tasks){
-            const id = t.id.length > 12 ? `${t.id.slice(0, 12)}...` : t.id;
-            const title = t.title.length > 50 ? `${t.title.slice(0, 47)}...` : t.title;
-            console.log(`  ${id}  p${String(t.priority_score).padStart(2)}  ${String(t.signal_count).padStart(2)} signals  ${title}`);
-        }
-    }
-}
-// ─── Command ─────────────────────────────────────────────────────────────────
-async function handleOverviewCommand(parsed) {
-    if (hasHelpFlag(parsed)) {
-        printOverviewHelp();
-        return;
-    }
-    const projectRef = requirePositional(parsed, 0, '<projectRef>');
-    assertNoExtraPositionals(parsed, 1);
-    const env = parseEnvironment(parsed);
-    const data = await requestProjectContract({
-        env,
-        key: 'overview',
-        projectRef,
-        sourceLabel: '<projectRef>'
-    });
-    if (isJsonOutput(parsed)) {
-        printOutput(data, parsed);
-    } else {
-        formatOverview(data);
-    }
-}
-const OVERVIEW_HELP = `
-Usage:
-  usertold overview <projectRef> [options]
-
-  Displays dashboard overview for a project: session counts, signal breakdown,
-  task status, screener summary, recent sessions, and top tasks.
-
-Options:
-  --env <env>                stage | production | local
-  --json                     JSON output
-
-Examples:
-  usertold overview acme/checkout
-  usertold overview acme/checkout --json
-`;
-function printOverviewHelp() {
-    console.log(OVERVIEW_HELP);
-}
-
-/**
- * Resolve the project reference from --project flag or USERTOLD_PROJECT_ID env var.
- */ function resolveProjectRefInput(parsed) {
-    const fromFlag = parsed.options.project;
-    if (fromFlag && fromFlag !== 'true') {
-        return fromFlag;
-    }
-    return process.env.USERTOLD_PROJECT_ID ?? null;
-}
-/**
- * Same as resolveProjectRefInput but throws if missing.
- */ function requireProjectRefInput(parsed) {
-    const projectRef = resolveProjectRefInput(parsed);
-    if (!projectRef) {
-        fail('Missing --project flag or USERTOLD_PROJECT_ID environment variable');
-    }
-    return projectRef;
-}
-
 const FLAGS$4 = {
     set: [
-        'project',
         'key',
         'value',
         'no-validate'
     ],
     get: [
-        'project',
         'key'
     ],
-    list: [
-        'project'
-    ],
+    list: [],
     delete: [
-        'project',
         'key'
     ]
 };
@@ -12659,13 +13284,14 @@ async function handleConfigCommand(subcommand, parsed) {
         return;
     }
     const env = parseEnvironment(parsed);
-    const rawProjectRef = requireProjectRefInput(parsed);
-    const canonical = await resolveProjectRefToCanonical(rawProjectRef, env);
-    const projectRef = `${canonical.orgHandle}/${canonical.projectHandle}`;
     switch(subcommand){
         case 'set':
             {
                 validateFlags(parsed, FLAGS$4.set);
+                const { projectRef } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'config set'
+                });
                 const key = requireOption(parsed, 'key');
                 const value = requireOption(parsed, 'value');
                 // Optionally validate first
@@ -12674,7 +13300,7 @@ async function handleConfigCommand(subcommand, parsed) {
                         env,
                         key: 'settingsValidate',
                         projectRef,
-                        sourceLabel: '--project',
+                        sourceLabel: '<projectRef>',
                         body: {
                             key,
                             value
@@ -12702,6 +13328,10 @@ async function handleConfigCommand(subcommand, parsed) {
         case 'get':
             {
                 validateFlags(parsed, FLAGS$4.get);
+                const { projectRef } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'config get'
+                });
                 const key = requireOption(parsed, 'key');
                 const data = await requestProjectContract({
                     env,
@@ -12725,6 +13355,10 @@ async function handleConfigCommand(subcommand, parsed) {
         case 'list':
             {
                 validateFlags(parsed, FLAGS$4.list);
+                const { projectRef } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'config list'
+                });
                 const data = await requestProjectContract({
                     env,
                     key: 'settingsGet',
@@ -12737,6 +13371,10 @@ async function handleConfigCommand(subcommand, parsed) {
         case 'delete':
             {
                 validateFlags(parsed, FLAGS$4.delete);
+                const { projectRef } = await consumeProjectRef(parsed, env, {
+                    resourceArgCount: 0,
+                    commandLabel: 'config delete'
+                });
                 const key = requireOption(parsed, 'key');
                 const data = await requestProjectContract({
                     env,
@@ -12756,27 +13394,28 @@ async function handleConfigCommand(subcommand, parsed) {
 }
 const CONFIG_HELP = `
 Usage:
-  usertold config <command> [options]
+  usertold config <command> [projectRef] [options]
 
 Commands:
-  set --project <org/project> --key <KEY> --value <val> [--no-validate]
-  get --project <org/project> --key <KEY>
-  list --project <org/project>
-  delete --project <org/project> --key <KEY>
+  set [projectRef] --key <KEY> --value <val> [--no-validate]
+  get [projectRef] --key <KEY>
+  list [projectRef]
+  delete [projectRef] --key <KEY>
 
 Allowed keys:
   openai_api_key        OpenAI API key for interviews, signal extraction, transcription & realtime
 
 Options:
-  --project <org/project>  Project reference (or set USERTOLD_PROJECT_ID env var)
   --env <env>           stage | production | local
   --json                JSON output
   --no-validate         Skip key validation on set
 
 Examples:
-  usertold config set --project acme/checkout --key openai_api_key --value sk-xxx
-  usertold config list --project acme/checkout
-  usertold config delete --project acme/checkout --key openai_api_key
+  usertold project use acme/checkout
+  usertold config set --key openai_api_key --value sk-xxx
+  usertold config set acme/checkout --key openai_api_key --value sk-xxx
+  usertold config list acme/checkout
+  usertold config delete acme/checkout --key openai_api_key
 `;
 function printConfigHelp() {
     console.log(CONFIG_HELP);
@@ -12875,7 +13514,7 @@ async function handleInitCommand(parsed) {
         if (!config || config.token.expiresAt <= Date.now()) {
             if (interactive) {
                 console.error(`No valid token for environment "${env}".`);
-                console.error(`Run: usertold auth login -- --env ${env}`);
+                console.error(`Run: usertold auth login --env ${env}`);
                 failAuth('Authentication required. Run auth login first.');
             } else {
                 failAuth('No valid token. Set USERTOLD_API_KEY or run auth login.');
@@ -12893,7 +13532,7 @@ async function handleInitCommand(parsed) {
         }
     }
     if (!json) console.error(`Creating project "${projectName}"...`);
-    const targetOrgHandle = requireOrgHandleForInit(parsed);
+    const targetOrgHandle = await resolveOrgHandleForInit(parsed, env);
     const projectData = await requestContract({
         env,
         key: 'projectCreate',
@@ -12991,8 +13630,11 @@ async function handleInitCommand(parsed) {
         if (!json) console.error('Study and screener activated.');
     }
     // Step 5: Widget snippet
-    const baseUrl = resolveBaseUrl(env);
-    const snippet = `<script src="${baseUrl}/v1/widget.js" data-project-key="${publicKey}"></script>`;
+    const widgetOrigin = resolveWidgetEmbedOriginForEnvironment(env);
+    const snippet = buildWidgetEmbedSnippet({
+        origin: widgetOrigin,
+        projectKey: publicKey
+    });
     result.widget_snippet = snippet;
     // Output
     if (json) {
@@ -13018,12 +13660,13 @@ const INIT_HELP = `
 Usage:
   usertold init [options]
 
-  Interactive project setup wizard. Creates a project, optionally configures
-  BYOK keys, and creates a study (auto-creates screener).
+  Bootstrap a project, optionally configure BYOK keys, and create a study
+  (auto-creates a screener). Runs interactively when stdout is a TTY; pass
+  --yes to skip prompts for non-interactive use (the agent path).
   GitHub integration is managed via the GitHub App (install from project settings).
 
 Options:
-  --org <orgHandle>           Target organization handle for created project
+  --org <orgHandle>           Target organization handle (defaults to your personal workspace)
   --name <name>               Project name (prompted if interactive)
   --openai-key <key>          OpenAI API key for interviews, analysis, and voice
   --study-title <title>       Study title (default: "User Research Study")
@@ -13034,8 +13677,8 @@ Options:
   --format json               Same as --json
 
 Non-interactive mode:
-  Discover your org first with \`usertold auth whoami --json\`, then run:
-  USERTOLD_API_KEY=... usertold init --org <orgHandle> --name "My Project" --yes --format json
+  Defaults to your personal workspace. Pass --org only when targeting another org:
+  USERTOLD_API_KEY=... usertold init --name "My Project" --yes --format json
 
 Note:
   If the wizard fails mid-way, earlier resources (e.g. project) will persist.
@@ -13044,22 +13687,28 @@ Note:
 Examples:
   usertold init
   usertold auth whoami --json
-  usertold init --org acme --name "Demo" --yes --env local
+  usertold init --name "Demo" --yes --env local
   usertold init --org acme --name "Demo" --openai-key sk-xxx --yes --json
 `;
 function printInitHelp() {
     console.log(INIT_HELP);
 }
-function requireOrgHandleForInit(parsed) {
+async function resolveOrgHandleForInit(parsed, env) {
     const orgHandle = parsed.options.org;
-    if (!orgHandle || orgHandle === 'true') {
-        failArgs('Missing required option: --org. ' + 'Discover it with "usertold auth whoami --json" and use "profile.personal_org_handle".');
+    if (orgHandle && orgHandle !== 'true') {
+        return orgHandle;
     }
-    return orgHandle;
+    return resolveDefaultOrgHandle(env, 'init');
 }
 
 const FLAGS$1 = {
-    'embed-backfill': []
+    'embed-backfill': [],
+    credits: [
+        'email',
+        'credits',
+        'reason',
+        'grant-id'
+    ]
 };
 async function handleAdminCommand(subcommand, parsed) {
     if (!subcommand || hasHelpFlag(parsed) || subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
@@ -13070,6 +13719,7 @@ async function handleAdminCommand(subcommand, parsed) {
     switch(subcommand){
         case 'embed-backfill':
             {
+                validateFlags(parsed, FLAGS$1['embed-backfill']);
                 console.log('Running embedding backfill for all signals and tasks...');
                 const data = await requestContractJson('adminEmbedBackfill', {
                     env
@@ -13082,6 +13732,56 @@ async function handleAdminCommand(subcommand, parsed) {
                 }
                 return;
             }
+        case 'credits':
+            {
+                validateFlags(parsed, FLAGS$1.credits);
+                const action = parsed.positionals[0];
+                if (action !== 'grant') {
+                    fail(`Unknown admin credits command: ${action ?? ''}`.trim());
+                }
+                assertNoExtraPositionals(parsed, 1);
+                const email = requireOption(parsed, 'email').trim().toLowerCase();
+                const reason = requireOption(parsed, 'reason').trim();
+                const creditsRaw = requireOption(parsed, 'credits');
+                const credits = Number(creditsRaw);
+                if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+                    failArgs('--email must be a valid email address');
+                }
+                if (!Number.isInteger(credits) || credits <= 0 || credits > 100000) {
+                    failArgs('--credits must be a positive integer no larger than 100000');
+                }
+                if (!reason) {
+                    failArgs('--reason cannot be empty');
+                }
+                const grantIdRaw = parsed.options['grant-id'];
+                const grantId = grantIdRaw && grantIdRaw !== 'true' ? grantIdRaw.trim() : undefined;
+                if (grantIdRaw === 'true') {
+                    failArgs('--grant-id requires a value');
+                }
+                if (grantIdRaw && !grantId) {
+                    failArgs('--grant-id cannot be empty');
+                }
+                const data = await requestContractJson('adminCreditsGrant', {
+                    env,
+                    body: {
+                        email,
+                        credits,
+                        reason,
+                        ...grantId ? {
+                            grant_id: grantId
+                        } : {}
+                    }
+                });
+                if (parsed.options.json === 'true' || parsed.options.format === 'json') {
+                    printOutput(data, parsed);
+                    return;
+                }
+                const verb = data.applied ? 'Granted' : 'Already granted';
+                console.log(`${verb} ${data.credits} bonus credit(s) to ${data.email}`);
+                console.log(`Grant key: ${data.grant_key}`);
+                console.log(`Available interviews: ${data.available_interview_count}`);
+                return;
+            }
         default:
             fail(`Unknown admin command: ${subcommand}`);
     }
@@ -13092,6 +13792,7 @@ Usage:
 
 Commands:
   embed-backfill    Backfill Vectorize embeddings for all existing signals and tasks
+  credits grant     Grant bonus credits by user email
 
 Options:
   --env <env>       stage | production | local
@@ -13100,6 +13801,7 @@ Options:
 Examples:
   usertold admin embed-backfill --env production
   usertold admin embed-backfill --env stage --json
+  usertold admin credits grant --email user@example.com --credits 10 --reason "signup bonus" --env production
 `;
 function printAdminHelp() {
     console.log(ADMIN_HELP);
@@ -13114,12 +13816,19 @@ Return ONLY a JSON array. Do not include markdown fences or extra text.
 
 Each signal must include ALL of these fields:
 - signal_type: one of ["struggling_moment","desired_outcome","workaround","hiring_criteria","firing_moment","emotional_response","smooth_completion","critical_error","recovery_success","decision_point"]
+- target_surface: one of ["product_under_test","usertold_widget_interview","interviewer_conductor_behavior","ambiguous_needs_review"]. Classify what the evidence is about:
+  - product_under_test: the customer's product, site, workflow, content, pricing, onboarding, checkout, or other experience being researched.
+  - usertold_widget_interview: UserTold participant-facing interview/widget UX, recording, microphone, transcript, consent, embedded prompt UI, or session mechanics.
+  - interviewer_conductor_behavior: the AI interviewer/conductor's questions, timing, probing, interruptions, tone, instructions, or behavior.
+  - ambiguous_needs_review: unclear or mixed evidence that cannot be safely assigned to exactly one of the above.
 - headline: one-line summary of the signal (NOT the quote itself — a descriptive label)
 - quote: direct participant quote, minimum ~15 words unless behavioral evidence compensates. NEVER interviewer text.
 - observed_facts: array of strict factual bullet strings — what was literally seen or heard. No interpretation. Each bullet starts with a verb (e.g., "Said ...", "Clicked ...", "Paused 4 seconds before ...", "Scrolled past ...")
 - claim: the smallest defensible interpretation of what the observed facts mean for the user's experience. One sentence. Must not exceed what observed_facts support. NEVER prescribe solutions.
 - reconstruction: 2-4 sentence before/during/after narrative. What led to this moment, what happened, and what followed.
 - evidence_grade: self-assessment of evidence strength — one of ["direct","strong_circumstantial","weak"]. "direct" = explicit quote + matching behavior. "strong_circumstantial" = clear behavioral pattern without explicit statement. "weak" = single ambiguous cue.
+- transcript_uncertain: boolean. Set true only when the direct quote appears to contain likely speech-recognition drift, phonetic approximations, mixed-language artifacts, or unusual tokens that could change how a reviewer interprets the evidence.
+- transcript_uncertainty_note: null unless transcript_uncertain is true. When true, write one concise reviewer note that names the uncertain token or phrase and, only when supported by page titles, URLs, product glossary terms, observed DOM text, or nearby context, suggests a normalized interpretation. Never rewrite the quote itself.
 - page_url: the page URL where this moment occurred. Look for the most recent [page] line before this moment in the transcript, or consult the Page Navigation History section. Set to null only if the session has no page/navigation data.
 - page_title: the page title from the same source as page_url. Set to null only if unavailable.
 - preceding_actions: array of 2-5 user actions leading up to this moment, from [event] and [page] lines that occur before this moment. Include clicks, navigation, focus changes — any user-initiated action. Set to null only if there are genuinely no [event] or [page] lines within 60 seconds before this moment.
@@ -13136,6 +13845,7 @@ Each signal must include ALL of these fields:
 Example output for a single signal:
 {
   "signal_type": "struggling_moment",
+  "target_surface": "product_under_test",
   "headline": "Cannot navigate backwards in multi-step checkout",
   "quote": "I filled in my whole shipping address and now I can't go back to change it without losing everything",
   "observed_facts": [
@@ -13147,6 +13857,8 @@ Example output for a single signal:
   "claim": "User cannot navigate backwards in multi-step checkout flow, causing loss of earlier input.",
   "reconstruction": "User completed shipping address and advanced to payment. Realized the address was wrong and looked for a way to go back. Scrolled the payment page, found no back button, and used browser back — which cleared the shipping form. Gave up and restarted checkout.",
   "evidence_grade": "direct",
+  "transcript_uncertain": false,
+  "transcript_uncertainty_note": null,
   "page_url": "/checkout/step3",
   "page_title": "Payment",
   "preceding_actions": ["Clicked 'Continue' on shipping", "Scrolled up and down on payment page", "Clicked browser back button"],
@@ -13167,10 +13879,13 @@ Guidelines:
 - Use [page] lines in the transcript for inline chronological page context — they show which page the user was on when they spoke. Also use the Page Navigation History section (if present) for the full page visit list.
 - Use [event] lines for behavioral context — clicks, navigation, form interactions that precede each signal.
 - If the same issue appears at different points in the session (e.g., during a task and again in the debrief), extract both — they carry different context and together show reinforcement.
+- Keep product-under-test evidence separate from UserTold-owned evidence. If the user struggles with the interview widget, recording, consent, microphone, AI interviewer, question flow, or conductor behavior, do not classify that as product_under_test even if it interrupts a product task.
 - Analysis must describe the user's experience and its impact. NEVER prescribe solutions, implementation direction, or what engineering should build. Bad: "Add a back button to fix navigation." Good: "User cannot navigate backwards in multi-step flow, causing loss of earlier input."
 - Prioritize concrete, evidence-backed signals over vague sentiments.
 - page_url contains only the path — domain is never available. Never prefix a domain. If no [page] line precedes this moment, set page_url to null.
 - context should include observed facts — what was literally seen or heard, starting with verbs (e.g., "Said ...", "Clicked ...", "Paused 4 seconds before ..."). This grounds the analysis in verifiable behavior.
+- Preserve quote verbatim even when transcript_uncertain is true. Put any normalized reading in transcript_uncertainty_note, not in quote.
+- Use visible page titles, URLs, product terms, and DOM text as anchors for domain terms. For example, if a quote contains a phonetically similar or mixed-language token but the page context clearly shows a matching product/page term, flag uncertainty and suggest that term in transcript_uncertainty_note. If no safe normalized reading exists, flag the uncertainty without inventing one.
 
 ## Audio Behavioral Cues
 The transcript includes inline audio annotations that provide important context:
@@ -13214,6 +13929,7 @@ Examples of needs_context=true:
 - Participant says "I don't know where to go" — need to know the task instruction and current page
 - Participant laughs and clicks something — need to know what they clicked
 - Participant says "oh, that's weird" — need to know what the UI showed
+- Participant quote contains unusual, phonetically approximated, or mixed-language domain terms — need page title, URL, or DOM text before suggesting any normalized reading
 
 Examples of needs_context=false:
 - Participant explicitly states frustration with a named feature
@@ -13336,6 +14052,7 @@ const extractedSignalSchema = object({
         'recovery_success',
         'decision_point'
     ]),
+    target_surface: _enum(TARGET_SURFACES).nullish().transform((v)=>normalizeTargetSurface(v)),
     quote: string().min(1),
     context: string().nullish().transform((v)=>v ?? ''),
     analysis: string().nullish().transform((v)=>v ?? ''),
@@ -13359,7 +14076,9 @@ const extractedSignalSchema = object({
     observed_facts: array(string()).nullish(),
     evidence_grade: _enum(EVIDENCE_GRADES).nullish().transform((v)=>v ?? 'weak'),
     window_start_ms: number().nullish(),
-    window_end_ms: number().nullish()
+    window_end_ms: number().nullish(),
+    transcript_uncertain: boolean().nullish().transform((v)=>v ?? false),
+    transcript_uncertainty_note: string().nullish()
 });
 /**
  * Try to extract a JSON array from text using multiple strategies:
@@ -13411,6 +14130,7 @@ const extractedSignalSchema = object({
             const s = result.data;
             valid.push({
                 signal_type: s.signal_type,
+                target_surface: s.target_surface,
                 quote: s.quote,
                 context: s.context,
                 analysis: s.analysis,
@@ -13429,7 +14149,9 @@ const extractedSignalSchema = object({
                 observed_facts: s.observed_facts ?? undefined,
                 evidence_grade: s.evidence_grade ?? undefined,
                 window_start_ms: s.window_start_ms ?? undefined,
-                window_end_ms: s.window_end_ms ?? undefined
+                window_end_ms: s.window_end_ms ?? undefined,
+                transcript_uncertain: s.transcript_uncertain || undefined,
+                transcript_uncertainty_note: s.transcript_uncertainty_note ?? undefined
             });
         } else {
             const issues = result.error.issues.map((e)=>`${e.path.join('.')}: ${e.message}`).join(', ');
@@ -13622,8 +14344,12 @@ async function openAIFetch(url, init, options) {
             if (!RETRYABLE_STATUSES.has(response.status) || attempt >= retries) {
                 return response;
             }
-            // Retryable status — consume body to free connection
             lastResponse = response;
+            const responseBody = await response.clone().text().catch(()=>'');
+            if (options?.shouldRetryResponse && !await options.shouldRetryResponse(response, responseBody)) {
+                return response;
+            }
+            // Retryable status — consume body to free connection
             await response.text().catch(()=>{});
             // Respect Retry-After header on 429
             if (response.status === 429) {
@@ -14531,11 +15257,15 @@ const EXTRACT_HELP = `
 usertold extract — run signal extraction on local files
 
 Usage:
-  usertold extract <transcript-file> --key <openai-key> [options]
+  usertold extract <transcript-file> [options]
 
 Arguments:
   transcript-file     Path to transcript (.vtt, .txt, or pre-formatted text)
 
+Auth:
+  Pass --key <key> OR set the OPENAI_API_KEY environment variable. The CLI
+  fails fast with a clear message if neither is provided.
+
 Options:
   --key <key>         OpenAI API key (or set OPENAI_API_KEY env var)
   --events <file>     Events JSONL file (one JSON object per line)
@@ -14648,6 +15378,7 @@ function printSignal(sig, index) {
     const grade = sig.evidence_grade ? `Grade: ${sig.evidence_grade}  |  ` : '';
     const time = sig.timestamp_ms != null ? `  |  At: ${formatMs(sig.timestamp_ms)}` : '';
     console.log(`    ${grade}Confidence: ${(sig.confidence * 100).toFixed(0)}%  |  Intensity: ${(sig.intensity * 100).toFixed(0)}%${time}`);
+    console.log(`    Surface: ${sig.target_surface}`);
     console.log(`    Quote: "${sig.quote}"`);
     if (sig.observed_facts && sig.observed_facts.length > 0) {
         console.log('    Observed facts:');
@@ -14734,7 +15465,7 @@ function printExtractHelp() {
     console.log(EXTRACT_HELP);
 }
 
-const CLI_VERSION$1 = '1.18.0';
+const CLI_VERSION$1 = '1.20.0';
 const GLOBAL_FLAGS = [
     'env',
     'json',
@@ -14764,38 +15495,34 @@ function buildCommandSurface() {
     const commands = [
         {
             name: 'auth',
-            subcommands: buildSubcommands(FLAGS$e)
+            subcommands: buildSubcommands(FLAGS$d)
         },
         {
             name: 'project',
-            subcommands: buildSubcommands(FLAGS$d)
+            subcommands: buildSubcommands(FLAGS$c)
         },
         {
             name: 'session',
-            subcommands: buildSubcommands(FLAGS$c)
+            subcommands: buildSubcommands(FLAGS$b)
         },
         {
             name: 'signal',
-            subcommands: buildSubcommands(FLAGS$b)
+            subcommands: buildSubcommands(FLAGS$a)
         },
         {
             name: 'task',
-            subcommands: buildSubcommands(FLAGS$a)
+            subcommands: buildSubcommands(FLAGS$9)
         },
         {
             name: 'screener',
-            subcommands: buildSubcommands(FLAGS$9)
+            subcommands: buildSubcommands(FLAGS$8)
         },
         {
             name: 'study',
-            subcommands: buildSubcommands(FLAGS$8)
+            subcommands: buildSubcommands(FLAGS$7)
         },
         {
             name: 'billing',
-            subcommands: buildSubcommands(FLAGS$6)
-        },
-        {
-            name: 'overview',
             subcommands: buildSubcommands(FLAGS$5)
         },
         {
@@ -14812,7 +15539,7 @@ function buildCommandSurface() {
         },
         {
             name: 'api',
-            subcommands: buildSubcommands(FLAGS$7)
+            subcommands: buildSubcommands(FLAGS$6)
         },
         {
             name: 'init',
@@ -14847,7 +15574,7 @@ const SHELLS = [
     'fish'
 ];
 async function handleCompletionsCommand(shell, parsed) {
-    if (!shell || hasHelpFlag(parsed)) {
+    if (!shell || hasHelpFlag(parsed) || shell === '--help' || shell === '-h' || shell === 'help') {
         printCompletionsHelp();
         return;
     }
@@ -15030,7 +15757,7 @@ function printCompletionsHelp() {
     console.log(COMPLETIONS_HELP);
 }
 
-const CLI_VERSION = '1.18.0';
+const CLI_VERSION = '1.20.0';
 function detectJsonMode() {
     const argv = process$2.argv.slice(2);
     if (argv.includes('--json')) return true;
@@ -15166,12 +15893,6 @@ async function dispatch(command, argv) {
                 await handleBillingCommand(subcommand, parsed);
                 return;
             }
-        case 'overview':
-            {
-                const parsed = parseArgs(argv);
-                await handleOverviewCommand(parsed);
-                return;
-            }
         case 'config':
             {
                 const [subcommand, ...rest] = argv;
@@ -15237,27 +15958,28 @@ const ROOT_HELP = `Usage: usertold <group> <subcommand> [options]
 
 Groups:
   auth              login, logout, whoami, token
-  project           list, create, get, update, delete
-  session           list, create, end, get, update, delete, transcript
-  signal            list, get, annotate, dismiss, link, unlink
-  task              list, get, create, update, delete, push, measure
-  screener          list, create, get, update, delete, set-questions
-  study             list, create, get, update, delete, export, import
+  project           list, use, current, create, get, update, delete, snippet, status, overview
+  session           list, create, end, get, status, events, update, delete, transcript, timeline, enriched-timeline, screen, media, audio, reprocess, retry-media-merge, watch
+  signal            list, get, annotate, dismiss, undismiss, link, unlink, delete, bulk-link, bulk-delete
+  task              list, get, create, create-from-signals, update, delete, push, push-status
+  screener          list, create, get, update, delete, set-questions, list-responses, get-response, qualify-response, disqualify-response
+  study             list, create, get, update, delete, export, import, reprocess, validate-script, guide
   billing           status, history
-  overview          project dashboard
-  config            set, get, list, delete
-  setup             provider setup
-  init              interactive setup wizard
+  config            set, get, list, delete  (uses current project when omitted)
+  setup             stub group — GitHub App install moved to the dashboard
+  init              bootstrap project + study + screener (TTY-interactive or --yes)
   api               raw HTTP passthrough
   extract           offline signal extraction from local files
-  admin             admin operations
+  admin             admin operations (elevated auth)
   completions       shell completions (bash, zsh, fish)
   introspect        full command surface as JSON
 
 Options:
-  --json            structured JSON output
+  --json            structured JSON output (alias: --format json)
   --env <env>       stage | production | local (default: ${DEFAULT_ENVIRONMENT})
-  --dry-run         show what would happen without executing
+  --local           shortcut for --env local
+  --dry-run         preview a destructive call without executing it
+                    (honored by 'delete' on every resource and by 'task push')
   --help            group or subcommand help
 
 Exit codes:
@@ -15274,4 +15996,4 @@ function printRootHelp() {
 }
 void main();
 
-export { ADMIN_HELP, API_HELP, AUTH_HELP, BILLING_HELP, COMPLETIONS_HELP, CONFIG_HELP, EXTRACT_HELP, INIT_HELP, OVERVIEW_HELP, PROJECT_HELP, ROOT_HELP, SCREENER_HELP, SESSION_HELP, SETUP_HELP, SIGNAL_HELP, STUDY_HELP, TASK_HELP, printAdminHelp, printApiHelp, printAuthHelp, printBillingHelp, printCompletionsHelp, printConfigHelp, printExtractHelp, printInitHelp, printOverviewHelp, printProjectHelp, printRootHelp, printScreenerHelp, printSessionHelp, printSetupHelp, printSignalHelp, printStudyHelp, printTaskHelp };
+export { ADMIN_HELP, API_HELP, AUTH_HELP, BILLING_HELP, COMPLETIONS_HELP, CONFIG_HELP, EXTRACT_HELP, INIT_HELP, PROJECT_HELP, ROOT_HELP, SCREENER_HELP, SESSION_HELP, SETUP_HELP, SIGNAL_HELP, STUDY_HELP, TASK_HELP, printAdminHelp, printApiHelp, printAuthHelp, printBillingHelp, printCompletionsHelp, printConfigHelp, printExtractHelp, printInitHelp, printProjectHelp, printRootHelp, printScreenerHelp, printSessionHelp, printSetupHelp, printSignalHelp, printStudyHelp, printTaskHelp };