forkit-connect 0.1.19 → 0.1.21

package/dist/cli.js

@@ -87,9 +87,9 @@ const PUBLIC_COMMANDS = [
     ['scan', 'Discover runtimes, models, and agents on this device'],
     ['inbox', 'Review the Smart Registration Inbox'],
     ['sync', 'Flush queued drafts and lifecycle metadata'],
-    ['workspace', 'List, select, or inspect optional governed workspace/project scope'],
-    ['runtime', 'Register or review governed runtimes for the current repo/worktree'],
-    ['register', 'Register ready local models into the current scope'],
+    ['workspace', 'Optional governed workspace and project scope'],
+    ['runtime', 'Register or review local runtimes for this repo/worktree'],
+    ['register', 'Register ready local models'],
     ['ignore', 'Deny one detected local model on this device'],
     ['doctor', 'Run local environment diagnostics'],
 ];
@@ -117,86 +117,42 @@ const ADVANCED_COMMAND_GROUPS = [
     ['notify', 'Notification preview and delivery controls'],
 ];
 function usage() {
-    console.log('Usage: forkit-connect <init|login|logout|status|changes|start|stop|scan|inbox|sync|workspace|runtime|register|ignore|doctor> [options]');
-    console.log('       forkit-connect workspace <list|select|create|status> [options]');
-    console.log('       forkit-connect runtime <register|review|status> [options]');
-    console.log('Public commands:');
+    printCliHeader('CLI', 'Precise local review, runtime detection, and registration handoff.');
+    console.log(cliKeyLine('usage', 'forkit-connect <command> [options]'));
+    console.log(cliKeyLine('scope', 'forkit-connect workspace <list|select|create|status>'));
+    console.log(cliKeyLine('runtime', 'forkit-connect runtime <register|review|status>'));
+    printCliSection('Core');
     for (const [command, description] of PUBLIC_COMMANDS) {
-        console.log(`  ${command.padEnd(10)} ${description}`);
-    }
-    console.log('Options:');
-    console.log('  --description <text>    Optional workspace description used by workspace create');
-    console.log('  --project-name <text>   Project name used by workspace create/select');
-    console.log('  --project-description <text> Optional project description used by workspace create/select');
-    console.log('  --json                  Print machine-readable output when supported');
-    console.log('  --name <value>          Runtime or metric name depending on command');
-    console.log('  --model <value>         Model name used by register');
-    console.log('  --entrypoint <path>     Relative project path used by runtime register');
-    console.log('  --source-url <url>      Source URL override used by runtime register');
-    console.log('  --subject-type <type>   Runtime subject type used by runtime register');
-    console.log('  --deployment-environment <value> Runtime environment used by runtime register');
-    console.log('  --show-key              Print the raw runtime API key when one is created');
-    console.log('  --no-api-key            Skip automatic runtime API key creation');
-    console.log('  --dry-run               Show the inferred runtime payload without creating it');
-    console.log('  --all-ready             Register every ready local model in the current scope');
-    console.log('  --ignore-model <name>   Deny a detected model on this device with --ignore-digest');
-    console.log('  --ignore-digest <sha>   Digest used with --ignore-model');
-    console.log('  --digest <sha>          Digest used by ignore when the model name is ambiguous');
-    console.log('  --interval-seconds <n>  Override daemon scan interval');
-    console.log('  --no-browser            Do not auto-open verification URL during login');
-    console.log('  --advanced-help         Show internal/engineering commands');
+        console.log(cliKeyLine(command, description));
+    }
+    printCliSection('Flags');
+    console.log(cliKeyLine('--json', 'Machine-readable output when supported'));
+    console.log(cliKeyLine('--all-ready', 'Register every ready local model in the current scope'));
+    console.log(cliKeyLine('--model', 'Model name used by register'));
+    console.log(cliKeyLine('--entrypoint', 'Relative project path used by runtime register'));
+    console.log(cliKeyLine('--dry-run', 'Show inferred runtime payload without creating it'));
+    console.log(cliKeyLine('--no-browser', 'Do not auto-open browser verification during login'));
+    console.log(cliKeyLine('--plain', 'Disable the interactive terminal table surface'));
+    console.log(cliKeyLine('--advanced-help', 'Show internal and engineering commands'));
 }
 function advancedUsage() {
     usage();
-    console.log('');
-    console.log('Advanced commands:');
-    console.log('  forkit-connect connect <modelNameOrDiscoveryHash>');
-    console.log('  forkit-connect connect <start|init|status|inbox|services|permissions|handoff|evolution review|runtime review|runtime status>');
-    console.log('  forkit-connect runtime target <add|list|remove|status> [options]');
-    console.log('  forkit-connect runtime observe --gaid <gaid> [options]');
-    console.log('  forkit-connect <review|workspaces|projects|bind|drafts|publish|bound|heartbeat|update-check|config|daemon|pulse|c2|train|agent|tray|notify> [options]');
+    printCliSection('Advanced');
+    console.log(cliKeyLine('connect', 'forkit-connect connect <modelNameOrDiscoveryHash>'));
+    console.log(cliKeyLine('connect', 'forkit-connect connect <start|init|status|inbox|services|permissions|handoff|evolution review|runtime review|runtime status>'));
+    console.log(cliKeyLine('targets', 'forkit-connect runtime target <add|list|remove|status>'));
+    console.log(cliKeyLine('observe', 'forkit-connect runtime observe --gaid <gaid>'));
+    console.log(cliKeyLine('more', 'forkit-connect <review|workspaces|projects|bind|drafts|publish|bound|heartbeat|update-check|config|daemon|pulse|c2|train|agent|tray|notify>'));
     for (const [command, description] of ADVANCED_COMMAND_GROUPS) {
-        console.log(`  ${command.padEnd(12)} ${description}`);
-    }
-    console.log('Advanced options:');
-    console.log('  --session-ref <value>   Store/update backend session reference');
-    console.log('  --workspace <id>        Store workspace binding');
-    console.log('  --project <id>          Store project binding');
-    console.log('  --draft <id>            Draft id used by publish');
-    console.log('  --name <value>          Model or metric name depending on command');
-    console.log('  --framework <value>     Training framework used by train init');
-    console.log('  --task <value>          Training task used by train init');
-    console.log('  --dataset-ref <value>   Safe dataset reference used by train init');
-    console.log('  --type <value>          Training lifecycle event type');
-    console.log('  --ref <value>           Dataset reference used by train dataset');
-    console.log('  --change <value>        Dataset change type used by train dataset');
-    console.log('  --value <number>        Metric value used by train metric');
-    console.log('  --version <value>       Version name used by train version');
-    console.log('  --reason <value>        Version or lifecycle reason');
-    console.log('  --path <value>          Artifact path used by train artifact');
-    console.log('  --hash-artifact         Hash artifact contents for train artifact');
-    console.log('  --heartbeat-gaid <gaid> Queue heartbeat runtime signal event for GAID');
-    console.log('  --heartbeat-key <key>   API key used for heartbeat runtime signal event');
-    console.log('                          Also used by: c2 set-key (stores key + backfills events)');
-    console.log('  --gaid <gaid>           Runtime or passport GAID used by runtime observe and c2 run-log emit');
-    console.log('  --api-key <key>         Runtime signal API key used by runtime observe and c2 run-log emit');
-    console.log('  --repo-root <path>      Repo root used by runtime target add (defaults to current repo/worktree)');
-    console.log('  --provider <name>       Provider label used by c2 run-log emit');
-    console.log('  --service-name <name>   Service/agent/workflow label used by c2 run-log emit');
-    console.log('  --prompt-tokens <n>     Prompt tokens used by c2 run-log emit');
-    console.log('  --completion-tokens <n> Completion tokens used by c2 run-log emit');
-    console.log('  --client-name <name>    Optional repo/runtime client label used by c2 run-log emit');
-    console.log('  --command-label <name>  Operator label used by runtime observe and c2 run-log emit');
-    console.log('  --actor-labels <csv>    Actor labels used by c2 run-log emit (for example: Codex,Claude)');
-    console.log('  --task-labels <csv>     Task or chat labels used by c2 run-log emit');
-    console.log('  --folder-labels <csv>   Relative folder labels used by c2 run-log emit');
-    console.log('  --file-labels <csv>     Relative file labels used by c2 run-log emit');
-    console.log('  --model-labels <csv>    Optional model labels used by c2 run-log emit');
-    console.log('  --cpu-percent <n>       Scoped CPU percentage used by c2 run-log emit');
-    console.log('  --memory-mb <n>         Scoped memory usage used by c2 run-log emit');
-    console.log('  --vram-mb <n>           Device VRAM usage used by c2 run-log emit');
-    console.log('  --emit-ambient          Include ambient tool detections in runtime observe JSON output');
-    console.log('  --draft-only            Allow draft creation even when governed publish capacity is full');
+        console.log(cliKeyLine(command, description));
+    }
+    printCliSection('Advanced Flags');
+    console.log(cliKeyLine('--session-ref', 'Store or update backend session reference'));
+    console.log(cliKeyLine('--workspace', 'Store workspace binding'));
+    console.log(cliKeyLine('--project', 'Store project binding'));
+    console.log(cliKeyLine('--gaid', 'Runtime or passport GAID used by runtime observe'));
+    console.log(cliKeyLine('--api-key', 'Runtime signal API key used by runtime observe'));
+    console.log(cliKeyLine('--draft-only', 'Allow private continuation when governed publish is blocked'));
 }
 function showUsage() {
     if (hasFlag('--advanced-help')) {
@@ -760,6 +716,13 @@ function formatScopeReferenceLabel(value, kind) {
     }
     return `selected on this device (${shortId(normalized)})`;
 }
+function formatScopeDetailValue(value, kind) {
+    const normalized = String(value || '').trim();
+    if (!normalized) {
+        return kind === 'workspace' ? 'not selected' : 'not selected';
+    }
+    return `${kind} ${shortId(normalized)}`;
+}
 function printUpdateCheckLines(lines, useErrorStream = false) {
     for (const line of lines) {
         if (useErrorStream) {
@@ -846,6 +809,207 @@ function printConnectInit(result) {
 function printJson(value) {
     console.log(JSON.stringify(value, null, 2));
 }
+const CLI_LABEL_WIDTH = 16;
+const CLI_WIDTH_FALLBACK = 88;
+const ANSI_ESCAPE_PATTERN = /\u001B\[[0-9;]*m/g;
+function canRenderCliColor() {
+    return Boolean(node_process_1.stdout.isTTY && process.env.NO_COLOR !== '1' && process.env.TERM !== 'dumb');
+}
+function paintCli(text, code) {
+    if (!canRenderCliColor()) {
+        return text;
+    }
+    return `\u001B[${code}m${text}\u001B[0m`;
+}
+function cliBold(text) {
+    return paintCli(text, '1');
+}
+function cliDim(text) {
+    return paintCli(text, '2');
+}
+function cliAccent(text) {
+    return paintCli(text, '1;36');
+}
+function cliGood(text) {
+    return paintCli(text, '1;32');
+}
+function cliWarm(text) {
+    return paintCli(text, '1;33');
+}
+function cliDanger(text) {
+    return paintCli(text, '1;31');
+}
+function cliPlainWidth(text) {
+    return text.replace(ANSI_ESCAPE_PATTERN, '').length;
+}
+function truncateCliText(value, maxWidth) {
+    const normalized = String(value ?? '').trim();
+    if (normalized.length <= maxWidth) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(0, maxWidth - 3)).trimEnd()}...`;
+}
+function getCliRenderWidth() {
+    const columns = node_process_1.stdout.columns;
+    if (Number.isFinite(columns) && Number(columns) > 0) {
+        return Math.max(72, Number(columns));
+    }
+    return CLI_WIDTH_FALLBACK;
+}
+function cliRule(char = '-') {
+    return cliDim(char.repeat(Math.max(24, Math.min(getCliRenderWidth(), CLI_WIDTH_FALLBACK))));
+}
+function cliTag(label, tone = 'muted') {
+    const rendered = `[${label}]`;
+    switch (tone) {
+        case 'accent':
+            return cliAccent(rendered);
+        case 'good':
+            return cliGood(rendered);
+        case 'warm':
+            return cliWarm(rendered);
+        case 'danger':
+            return cliDanger(rendered);
+        default:
+            return cliDim(rendered);
+    }
+}
+function cliKeyLine(label, value) {
+    return `  ${cliDim(`${label}`.padEnd(CLI_LABEL_WIDTH, ' '))} ${value}`;
+}
+function printCliHeader(title, subtitle) {
+    console.log(`[forkit-connect] ${cliBold(title)}`);
+    if (subtitle) {
+        console.log(cliDim(subtitle));
+    }
+    console.log(cliRule());
+}
+function printCliSection(title) {
+    console.log('');
+    console.log(cliBold(title.toUpperCase()));
+}
+function printCliEntry(title, options) {
+    const trimmedTitle = truncateCliText(title, 36);
+    const summaryWidth = Math.max(24, Math.min(48, getCliRenderWidth() - cliPlainWidth(trimmedTitle) - 22));
+    const pieces = [trimmedTitle];
+    if (options?.tag) {
+        pieces.push(cliTag(options.tag, options.tagTone ?? 'muted'));
+    }
+    if (options?.summary) {
+        pieces.push(cliDim('->'));
+        pieces.push(truncateCliText(options.summary, summaryWidth));
+    }
+    console.log(`  > ${pieces.join(' ')}`);
+    if (options?.meta) {
+        console.log(`    ${cliDim(options.meta)}`);
+    }
+}
+function joinCliSummary(parts) {
+    return parts.filter((value) => Boolean(value && String(value).trim())).join(cliDim(' | '));
+}
+function formatCliCompactCount(count, singular, plural) {
+    const noun = count === 1 ? singular : (plural || `${singular}s`);
+    return `${count} ${noun}`;
+}
+function formatCliAge(seconds) {
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        return 'fresh';
+    }
+    if (seconds >= 86400) {
+        return `${Math.round(seconds / 86400)}d old`;
+    }
+    if (seconds >= 3600) {
+        return `${Math.round(seconds / 3600)}h old`;
+    }
+    if (seconds >= 60) {
+        return `${Math.round(seconds / 60)}m old`;
+    }
+    return `${Math.round(seconds)}s old`;
+}
+function formatCliScopeLabel(workspaceId, projectId) {
+    const workspace = String(workspaceId || '').trim();
+    const project = String(projectId || '').trim();
+    if (workspace && project) {
+        return `${shortId(workspace)} / ${shortId(project)}`;
+    }
+    if (workspace) {
+        return `${shortId(workspace)} / project needed`;
+    }
+    return 'solo / no workspace';
+}
+function summarizeReviewQueueCounts(values) {
+    const parts = [
+        values.draftFirstCount ? formatCliCompactCount(values.draftFirstCount, 'private review') : null,
+        values.readyCount ? formatCliCompactCount(values.readyCount, 'ready item') : null,
+        values.needsReviewCount ? formatCliCompactCount(values.needsReviewCount, 'review item') : null,
+        values.connectedCount ? formatCliCompactCount(values.connectedCount, 'connected item') : null,
+    ];
+    const joined = joinCliSummary(parts);
+    return joined || 'clear';
+}
+function formatCliEvidenceGlyph(confidence) {
+    switch (String(confidence || '').trim().toLowerCase()) {
+        case 'high':
+            return '●●●';
+        case 'medium':
+            return '●●○';
+        case 'low':
+            return '●○○';
+        default:
+            return '○○○';
+    }
+}
+function formatCliEvidenceLabel(confidence) {
+    const normalized = String(confidence || '').trim().toLowerCase();
+    switch (normalized) {
+        case 'high':
+            return 'high';
+        case 'medium':
+            return 'medium';
+        case 'low':
+            return 'low';
+        default:
+            return normalized || 'unknown';
+    }
+}
+function formatCliEvidenceCell(confidence) {
+    return `${formatCliEvidenceGlyph(confidence)} ${formatCliEvidenceLabel(confidence)}`;
+}
+function formatCliDetailLine(label, value, labelWidth = 12) {
+    const safeLabel = `${label}:`;
+    const paddedLabel = `${safeLabel}${' '.repeat(Math.max(1, labelWidth - safeLabel.length))}`;
+    const normalizedValue = value == null
+        ? ''
+        : typeof value === 'string'
+            ? value.trim()
+            : String(value);
+    return `${paddedLabel}${normalizedValue || normalizedValue === '0' ? normalizedValue : 'n/a'}`;
+}
+function formatRuntimeRecommendedActionLabel(action) {
+    const normalized = String(action || '').trim().toLowerCase();
+    if (normalized === 'link an agent to a model on this runtime.') {
+        return 'Link agent to model';
+    }
+    if (normalized === 'connect a model served by this runtime.') {
+        return 'Register served model';
+    }
+    if (normalized === 'check whether this runtime should be running locally.') {
+        return 'Check local runtime';
+    }
+    return truncateCliText(action, 36);
+}
+function getDraftFirstCountFromInbox(inbox) {
+    return inbox.groups.ready_to_connect.filter((item) => (item.item_type === 'model'
+        && item.recommended_action === 'create_passport_draft'
+        && String(item.details_received_automatically.registration_flow_state || '').trim() === 'private_draft_required')).length;
+}
+function splitReadyInboxItems(inbox) {
+    const privateReview = inbox.groups.ready_to_connect.filter((item) => (item.item_type === 'model'
+        && item.recommended_action === 'create_passport_draft'
+        && String(item.details_received_automatically.registration_flow_state || '').trim() === 'private_draft_required'));
+    const ready = inbox.groups.ready_to_connect.filter((item) => !privateReview.includes(item));
+    return { privateReview, ready };
+}
 const INTERACTIVE_LABEL_WIDTH = 24;
 const INTERACTIVE_DISCOVERY_TIMEOUT_MS = 800;
 const INTERACTIVE_BINDING_TIMEOUT_MS = 800;
@@ -1365,23 +1529,47 @@ function printAgentLedger(summary) {
     console.log(JSON.stringify(summary, null, 2));
 }
 function printRuntimeReview(summary) {
-    console.log('[forkit-connect] Runtime review');
-    console.log(`- runtimes=${summary.total_runtimes}`);
-    for (const runtime of summary.runtimes) {
-        console.log(`- ${runtime.runtime_name} | ${runtime.status} | linked models=${runtime.linked_models_count} | linked agents=${runtime.linked_agents_count} | health=${runtime.health_status} | next=${runtime.recommended_action}`);
+    const ready = summary.runtimes.filter((runtime) => runtime.status !== 'unavailable' && runtime.health_status === 'detected');
+    const attention = summary.runtimes.filter((runtime) => !ready.includes(runtime));
+    printCliHeader('Runtime Review', `${formatCliCompactCount(summary.total_runtimes, 'runtime')} on this device`);
+    console.log(cliKeyLine('summary', joinCliSummary([
+        formatCliCompactCount(ready.length, 'healthy runtime'),
+        formatCliCompactCount(attention.length, 'runtime needs review', 'runtimes need review'),
+    ])));
+    for (const [label, items] of [['Healthy', ready], ['Needs review', attention]]) {
+        if (items.length === 0) {
+            continue;
+        }
+        printCliSection(`${label} ${cliTag(String(items.length), label === 'Healthy' ? 'good' : 'warm')}`);
+        for (const runtime of items) {
+            printCliEntry(runtime.runtime_name, {
+                tag: runtime.status.replaceAll('_', ' '),
+                tagTone: runtime.status === 'unavailable' ? 'warm' : 'good',
+                meta: joinCliSummary([
+                    `health ${runtime.health_status}`,
+                    formatCliCompactCount(runtime.linked_models_count, 'model'),
+                    formatCliCompactCount(runtime.linked_agents_count, 'agent'),
+                    `next ${formatRuntimeRecommendedActionLabel(runtime.recommended_action)}`,
+                ]),
+            });
+        }
     }
 }
 function printRuntimeStatus(status) {
-    console.log('[forkit-connect] Runtime status');
-    console.log(`- total=${status.total_runtimes}`);
-    console.log(`- online=${status.online_runtimes}`);
-    console.log(`- offline=${status.offline_runtimes}`);
-    console.log(`- linked=${status.linked_runtimes}`);
-    console.log(`- unlinked=${status.unlinked_runtimes}`);
-    console.log(`- needs attention=${status.unhealthy_runtimes}`);
-    console.log(`- pending runtime sync=${status.c2_pending_count}`);
+    printCliHeader('Runtime Status');
+    console.log(cliKeyLine('runtimes', joinCliSummary([
+        formatCliCompactCount(status.total_runtimes, 'total'),
+        formatCliCompactCount(status.online_runtimes, 'online runtime'),
+        formatCliCompactCount(status.offline_runtimes, 'offline runtime'),
+    ])));
+    console.log(cliKeyLine('linking', joinCliSummary([
+        formatCliCompactCount(status.linked_runtimes, 'linked runtime'),
+        formatCliCompactCount(status.unlinked_runtimes, 'unlinked runtime'),
+        formatCliCompactCount(status.unhealthy_runtimes, 'runtime needs review', 'runtimes need review'),
+    ])));
+    console.log(cliKeyLine('sync', `${status.c2_pending_count} pending runtime events`));
     if (status.latest_runtime_lifecycle_event) {
-        console.log(`- latest event=${status.latest_runtime_lifecycle_event}`);
+        console.log(cliKeyLine('latest', truncateCliText(status.latest_runtime_lifecycle_event, 60)));
     }
 }
 function printRuntimeTargetList(service, options) {
@@ -1437,24 +1625,133 @@ function formatSmartInboxActionLabel(item) {
     }
     return formatSmartInboxActionValue(item.recommended_action, item.item_type, String(item.details_received_automatically.connectable_model_name || '').trim());
 }
+function getInboxGroupTone(label) {
+    switch (label) {
+        case 'Private review':
+            return 'accent';
+        case 'Ready to connect':
+            return 'good';
+        case 'Needs review':
+            return 'warm';
+        case 'Denied on this device':
+            return 'danger';
+        default:
+            return 'muted';
+    }
+}
+function formatInboxItemMeta(item) {
+    const match = item.matched_passport_gaid ? `match ${shortId(item.matched_passport_gaid)}` : null;
+    const runtime = String(item.details_received_automatically.runtime_name || '').trim();
+    const displayName = String(item.display_name || '').trim().toLowerCase();
+    const sourceCandidate = item.item_type === 'runtime'
+        ? String(item.details_received_automatically.source_endpoint_label || runtime || '').trim()
+        : '';
+    const sourceNormalized = sourceCandidate.toLowerCase();
+    const runtimeNormalized = runtime.toLowerCase();
+    const detectedSource = String(item.detected_source || '').trim().toLowerCase();
+    const source = sourceCandidate && sourceNormalized !== displayName && sourceNormalized !== runtimeNormalized && sourceNormalized !== detectedSource
+        ? sourceCandidate
+        : null;
+    const confidence = item.confidence !== 'high' ? `${item.confidence} confidence` : null;
+    const parts = [source || null, confidence, match];
+    const joined = joinCliSummary(parts);
+    return joined || null;
+}
 function printInboxGroup(label, items) {
     if (items.length === 0)
         return;
-    console.log(`${label}: ${items.length}`);
+    printCliSection(`${label} ${cliTag(String(items.length), getInboxGroupTone(label))}`);
     for (const item of items) {
-        console.log(`- ${item.display_name} | type=${item.item_type} | confidence=${item.confidence} | next=${formatSmartInboxActionLabel(item)}${item.matched_passport_gaid ? ` | match=${shortId(item.matched_passport_gaid)}` : ''}`);
+        printCliEntry(item.display_name, {
+            tag: item.item_type.replaceAll('_', ' '),
+            tagTone: item.item_type === 'runtime' ? 'accent' : item.item_type === 'agent' ? 'warm' : 'muted',
+            summary: formatSmartInboxActionLabel(item),
+            meta: formatInboxItemMeta(item),
+        });
     }
 }
 function printSmartInbox(inbox) {
-    console.log(`[forkit-connect] Smart Registration Inbox generated_at=${inbox.summary.generated_at}`);
-    console.log(`Governance authority: website | user_api_key_required=${String(inbox.user_api_key_required)}`);
-    printInboxGroup('Ready to Connect', inbox.groups.ready_to_connect);
-    printInboxGroup('Needs Confirmation', inbox.groups.needs_confirmation);
-    printInboxGroup('Connected', inbox.groups.connected);
-    printInboxGroup('Denied on This Device', inbox.groups.ignored);
+    const draftFirstCount = getDraftFirstCountFromInbox(inbox);
+    const { privateReview, ready } = splitReadyInboxItems(inbox);
+    const freshness = inbox.summary.freshness_state ?? 'fresh';
+    const ageSeconds = Number.isFinite(inbox.summary.snapshot_age_seconds)
+        ? Number(inbox.summary.snapshot_age_seconds)
+        : 0;
+    printCliHeader('Inbox', `${formatTimestamp(inbox.summary.generated_at)} snapshot`);
+    console.log(cliKeyLine('freshness', joinCliSummary([
+        freshness,
+        formatCliAge(ageSeconds),
+    ])));
+    console.log(cliKeyLine('queue', summarizeReviewQueueCounts({
+        draftFirstCount,
+        readyCount: ready.length,
+        needsReviewCount: inbox.groups.needs_confirmation.length,
+        connectedCount: inbox.groups.connected.length,
+    })));
     if (inbox.summary.next_recommended_action) {
-        console.log(`Next recommended action: ${formatSmartInboxActionValue(inbox.summary.next_recommended_action)}`);
+        console.log(cliKeyLine('next', formatSmartInboxActionValue(inbox.summary.next_recommended_action)));
     }
+    printInboxGroup('Private review', privateReview);
+    printInboxGroup('Needs review', inbox.groups.needs_confirmation);
+    printInboxGroup('Ready to connect', ready);
+    printInboxGroup('Connected', inbox.groups.connected);
+    printInboxGroup('Denied on this device', inbox.groups.ignored);
+}
+function buildInboxInteractiveSections(inbox) {
+    const { privateReview, ready } = splitReadyInboxItems(inbox);
+    const rows = (groupLabel, items) => (items.map((item) => ({ groupLabel, item })));
+    const sections = [
+        { id: 'review', label: 'Review', tone: 'warm', rows: rows('Needs review', inbox.groups.needs_confirmation) },
+        { id: 'private', label: 'Private', tone: 'accent', rows: rows('Private review', privateReview) },
+        { id: 'ready', label: 'Ready', tone: 'good', rows: rows('Ready to connect', ready) },
+        { id: 'connected', label: 'Connected', tone: 'muted', rows: rows('Connected', inbox.groups.connected) },
+        { id: 'denied', label: 'Denied', tone: 'danger', rows: rows('Denied on this device', inbox.groups.ignored) },
+    ];
+    return sections.filter((section) => section.rows.length > 0);
+}
+function buildInboxInteractiveDetailLines(row) {
+    const item = row.item;
+    const lines = [
+        formatCliDetailLine('Review', row.groupLabel),
+        formatCliDetailLine('Next', formatSmartInboxActionLabel(item)),
+        formatCliDetailLine('Evidence', `${formatCliEvidenceLabel(item.confidence)} local evidence`),
+        formatCliDetailLine('Source', item.detected_source),
+    ];
+    if (item.workspaceId || item.projectId) {
+        lines.push(formatCliDetailLine('Workspace', formatScopeDetailValue(item.workspaceId, 'workspace')));
+        lines.push(formatCliDetailLine('Project', formatScopeDetailValue(item.projectId, 'project')));
+    }
+    else {
+        lines.push(formatCliDetailLine('Scope', 'solo / no workspace'));
+    }
+    if (item.matched_passport_gaid) {
+        lines.push(formatCliDetailLine('Passport', item.matched_passport_gaid));
+    }
+    return lines;
+}
+async function maybeShowInteractiveInboxTable(inbox) {
+    const freshness = inbox.summary.freshness_state ?? 'fresh';
+    const ageSeconds = Number.isFinite(inbox.summary.snapshot_age_seconds)
+        ? Number(inbox.summary.snapshot_age_seconds)
+        : 0;
+    return await viewInteractiveTable({
+        title: '[forkit-connect] Inbox',
+        subtitle: joinCliSummary([
+            `${formatTimestamp(inbox.summary.generated_at)} snapshot`,
+            freshness,
+            formatCliAge(ageSeconds),
+        ]),
+        sections: buildInboxInteractiveSections(inbox),
+        columns: [
+            { header: 'Item', width: 32, render: (row) => row.item.display_name },
+            { header: 'Type', width: 18, render: (row) => row.item.item_type.replaceAll('_', ' ') },
+            { header: 'Next', width: 28, render: (row) => formatSmartInboxActionLabel(row.item) },
+            { header: 'Evidence', width: 14, render: (row) => formatCliEvidenceCell(row.item.confidence) },
+        ],
+        detailLines: buildInboxInteractiveDetailLines,
+        detailTitle: (row) => `${row.item.item_type.replaceAll('_', ' ').toUpperCase()} SNAPSHOT`,
+        emptyState: 'No inbox items are available right now.',
+    });
 }
 function printConnectStatusOverview(status) {
     const sessionMissing = !status.device_paired && status.binding_state === 'active' && !status.credential_reconnect_needed;
@@ -1483,20 +1780,28 @@ function printConnectStatusOverview(status) {
 }
 function printPublicStatusOverview(status) {
     const otherReadyCount = getOtherReadyCount(status.ready_to_connect_count, status.draft_first_count);
-    console.log('[forkit-connect] Status');
-    console.log(`- device=${status.device_paired ? 'paired' : 'approval pending'}`);
-    console.log(`- scope=${status.workspace_id && status.project_id ? `${status.workspace_id} / ${status.project_id}` : 'not selected'}`);
-    console.log(`- daemon=${status.daemon_status}`);
-    console.log(`- local inventory=models ${status.models_discovered} · agents ${status.agents_discovered} · runtimes ${status.runtimes_discovered}`);
-    console.log(`- review queue=private review ${status.draft_first_count} · ready ${otherReadyCount} · needs review ${status.needs_confirmation_count}`);
-    console.log(`- connected records=${status.connected_count}`);
-    console.log(`- pending runtime sync=${status.c2_sync_pending}`);
-    console.log(`- privacy=${status.privacy_mode}`);
+    printCliHeader('Status');
+    console.log(cliKeyLine('device', status.device_paired ? 'paired' : 'approval pending'));
+    console.log(cliKeyLine('scope', formatCliScopeLabel(status.workspace_id, status.project_id)));
+    console.log(cliKeyLine('daemon', status.daemon_status));
+    console.log(cliKeyLine('privacy', status.privacy_mode));
+    console.log(cliKeyLine('inventory', joinCliSummary([
+        formatCliCompactCount(status.models_discovered, 'model'),
+        formatCliCompactCount(status.agents_discovered, 'agent'),
+        formatCliCompactCount(status.runtimes_discovered, 'runtime'),
+    ])));
+    console.log(cliKeyLine('queue', summarizeReviewQueueCounts({
+        draftFirstCount: status.draft_first_count,
+        readyCount: otherReadyCount,
+        needsReviewCount: status.needs_confirmation_count,
+    })));
+    console.log(cliKeyLine('linked', formatCliCompactCount(status.connected_count, 'connected record')));
+    console.log(cliKeyLine('sync', `${status.c2_sync_pending} pending runtime events`));
     if (status.lifecycle_note) {
-        console.log(`- note=${status.lifecycle_note}`);
+        console.log(cliKeyLine('governed', truncateCliText(status.lifecycle_note, 88)));
     }
     if (!status.device_paired && status.binding_state === 'active') {
-        console.log('- warning=Local workspace/project scope exists, but the account session is missing. Re-login is required before governed actions can continue.');
+        console.log(cliKeyLine('warning', 'Local governed scope exists, but login is still required.'));
     }
 }
 function getOtherReadyCount(readyToConnectCount, draftFirstCount) {
@@ -1510,34 +1815,65 @@ function printPublicStatusGuidance(status, sessionState) {
             : sessionState === 'unavailable'
                 ? 'unverified'
                 : 'login required';
-    console.log(`- account=${accountLabel}`);
+    console.log(cliKeyLine('account', accountLabel));
     if (sessionState === 'missing') {
-        console.log('- note=Local discovery is working. Sign in next to pair this device with your Forkit.dev account.');
-        console.log('- next=run forkit-connect login');
+        console.log(cliKeyLine('session', 'Local discovery is working. Sign in to pair this device.'));
+        console.log(cliKeyLine('next', 'forkit-connect login'));
         if (status.binding_state === 'active' && status.workspace_id && status.project_id) {
-            console.log('- warning=This device has local workspace/project scope saved, but it is not an active account session yet.');
+            console.log(cliKeyLine('scope', 'This device still has saved governed scope from an older session.'));
         }
         return;
     }
     if (sessionState === 'expired') {
-        console.log('- note=Your local device is initialized, but the account session needs to be renewed.');
-        console.log('- next=run forkit-connect login');
+        console.log(cliKeyLine('session', 'The local device is ready, but the account session needs renewal.'));
+        console.log(cliKeyLine('next', 'forkit-connect login'));
         return;
     }
     if (!status.device_paired) {
-        console.log('- note=Device identity is ready locally, but browser approval still needs to complete.');
-        console.log('- next=finish login approval on Forkit.dev, then rerun forkit-connect status');
+        console.log(cliKeyLine('session', 'Local identity is ready, but browser approval still needs to finish.'));
+        console.log(cliKeyLine('next', 'Finish approval in the browser, then rerun forkit-connect status'));
         return;
     }
     if (status.daemon_status === 'stopped') {
-        console.log('- note=Background sync is idle right now. This is expected until you start the local daemon.');
-        console.log('- next=run forkit-connect start');
+        console.log(cliKeyLine('daemon', 'Background sync is idle until you start the local daemon.'));
+        console.log(cliKeyLine('next', 'forkit-connect start'));
         return;
     }
     if (status.next_recommended_action) {
-        console.log(`- next_detail=${formatSmartInboxActionValue(status.next_recommended_action)}`);
+        console.log(cliKeyLine('next', formatSmartInboxActionValue(status.next_recommended_action)));
     }
 }
+function buildRuntimeInteractiveDetailLines(runtime) {
+    return [
+        formatCliDetailLine('State', runtime.status.replaceAll('_', ' ')),
+        formatCliDetailLine('Health', runtime.health_status),
+        formatCliDetailLine('Endpoint', runtime.source_endpoint_label || runtime.runtime_type),
+        formatCliDetailLine('Models', runtime.linked_models_count),
+        formatCliDetailLine('Agents', runtime.linked_agents_count),
+        formatCliDetailLine('Next', formatRuntimeRecommendedActionLabel(runtime.recommended_action)),
+    ];
+}
+async function maybeShowInteractiveRuntimeReviewTable(summary) {
+    const healthy = summary.runtimes.filter((runtime) => runtime.status !== 'unavailable' && runtime.health_status === 'detected');
+    const review = summary.runtimes.filter((runtime) => !healthy.includes(runtime));
+    return await viewInteractiveTable({
+        title: '[forkit-connect] Runtime Review',
+        subtitle: `${formatCliCompactCount(summary.total_runtimes, 'runtime')} on this device`,
+        sections: [
+            { id: 'healthy', label: 'Healthy', tone: 'good', rows: healthy },
+            { id: 'review', label: 'Needs review', tone: 'warm', rows: review },
+        ],
+        columns: [
+            { header: 'Runtime', width: 24, render: (runtime) => runtime.runtime_name },
+            { header: 'State', width: 18, render: (runtime) => runtime.status.replaceAll('_', ' ') },
+            { header: 'Health', width: 12, render: (runtime) => runtime.health_status },
+            { header: 'Next', width: 24, render: (runtime) => formatRuntimeRecommendedActionLabel(runtime.recommended_action) },
+        ],
+        detailLines: buildRuntimeInteractiveDetailLines,
+        detailTitle: () => 'RUNTIME SNAPSHOT',
+        emptyState: 'No runtimes are available right now.',
+    });
+}
 async function checkBackendSessionState(service) {
     const sessionRefValue = String(service.readSessionRef() || '').trim();
     if (!sessionRefValue)
@@ -1676,6 +2012,180 @@ async function promptSelection(label, options) {
         node_process_1.stdin.on('keypress', onKeypress);
     });
 }
+function paintCliTone(text, tone) {
+    switch (tone) {
+        case 'accent':
+            return cliAccent(text);
+        case 'good':
+            return cliGood(text);
+        case 'warm':
+            return cliWarm(text);
+        case 'danger':
+            return cliDanger(text);
+        default:
+            return cliDim(text);
+    }
+}
+function fitCliTableCell(value, width, align = 'left') {
+    const rendered = truncateCliText(value, width);
+    const pad = Math.max(0, width - cliPlainWidth(rendered));
+    return align === 'right'
+        ? `${' '.repeat(pad)}${rendered}`
+        : `${rendered}${' '.repeat(pad)}`;
+}
+function buildCliTableBorder(widths, left, middle, right) {
+    return `${left}${widths.map((width) => '─'.repeat(width + 2)).join(middle)}${right}`;
+}
+function buildCliTableRow(cells) {
+    return `│${cells.map((cell) => ` ${fitCliTableCell(cell.value, cell.width, cell.align)} `).join('│')}│`;
+}
+function buildCliWideBox(title, lines, width) {
+    const innerWidth = Math.max(24, width);
+    const safeTitle = truncateCliText(title, Math.max(8, innerWidth - 4));
+    const topPad = Math.max(0, innerWidth - cliPlainWidth(safeTitle) - 2);
+    const top = `┌─ ${safeTitle} ${'─'.repeat(topPad)}┐`;
+    const body = lines.map((line) => `│ ${fitCliTableCell(line, innerWidth)} │`);
+    const bottom = `└${'─'.repeat(innerWidth + 2)}┘`;
+    return [top, ...body, bottom];
+}
+function cliTableCell(value, width, align) {
+    return align ? { value, width, align } : { value, width };
+}
+function formatCliTableTabs(sections, activeIndex) {
+    return sections
+        .map((section, index) => {
+        const label = `${section.label} ${section.rows.length}`;
+        if (index === activeIndex) {
+            return paintCli(` ${label} `, '7');
+        }
+        return paintCliTone(`[${label}]`, section.tone ?? 'muted');
+    })
+        .join(' ');
+}
+async function viewInteractiveTable(options) {
+    const sections = options.sections.filter((section) => section.rows.length > 0);
+    if (!sections.length || !node_process_1.stdin.isTTY || !node_process_1.stdout.isTTY || hasFlag('--plain')) {
+        return false;
+    }
+    (0, node_readline_1.emitKeypressEvents)(node_process_1.stdin);
+    const canUseRawMode = typeof node_process_1.stdin.setRawMode === 'function';
+    const previousRawMode = canUseRawMode ? node_process_1.stdin.isRaw : false;
+    if (canUseRawMode) {
+        node_process_1.stdin.setRawMode(true);
+    }
+    let activeSectionIndex = 0;
+    let selectedIndex = 0;
+    let renderLineCount = 0;
+    const visibleRows = 8;
+    const reset = '\u001B[0m';
+    const hideCursor = '\u001B[?25l';
+    const showCursor = '\u001B[?25h';
+    const inverse = '\u001B[7m';
+    const render = () => {
+        const activeSection = sections[activeSectionIndex] ?? sections[0];
+        const rows = activeSection?.rows ?? [];
+        const currentRow = rows[selectedIndex] ?? null;
+        const startIndex = Math.max(0, Math.min(selectedIndex - Math.floor(visibleRows / 2), Math.max(0, rows.length - visibleRows)));
+        const visibleSlice = rows.slice(startIndex, startIndex + visibleRows);
+        const selectorWidth = 1;
+        const columnWidths = [selectorWidth, ...options.columns.map((column) => column.width)];
+        const headerLine = buildCliTableRow([
+            cliTableCell(' ', selectorWidth),
+            ...options.columns.map((column) => cliTableCell(column.header.toUpperCase(), column.width, column.align)),
+        ]);
+        const rowLines = visibleSlice.length > 0
+            ? visibleSlice.map((row, offset) => {
+                const absoluteIndex = startIndex + offset;
+                const active = absoluteIndex === selectedIndex;
+                const line = buildCliTableRow([
+                    cliTableCell(active ? cliAccent('›') : ' ', selectorWidth),
+                    ...options.columns.map((column, index) => cliTableCell(active && index === 0 ? cliBold(column.render(row)) : column.render(row), column.width, column.align)),
+                ]);
+                return active ? cliAccent(line) : line;
+            })
+            : buildCliWideBox('EMPTY', [options.emptyState], columnWidths.reduce((sum, value) => sum + value + 3, -1));
+        const detail = currentRow ? options.detailLines(currentRow) : [options.emptyState];
+        const innerTableWidth = columnWidths.reduce((sum, value) => sum + value + 3, -1);
+        const tableTop = buildCliTableBorder(columnWidths, '┌', '┬', '┐');
+        const tableMiddle = buildCliTableBorder(columnWidths, '├', '┼', '┤');
+        const tableBottom = buildCliTableBorder(columnWidths, '└', '┴', '┘');
+        const detailTitle = currentRow && options.detailTitle ? options.detailTitle(currentRow) : 'SELECTED ITEM';
+        const detailBox = buildCliWideBox(detailTitle, detail, innerTableWidth);
+        const lines = [
+            cliBold(options.title),
+            ...(options.subtitle ? [cliDim(options.subtitle)] : []),
+            cliRule(),
+            formatCliTableTabs(sections, activeSectionIndex),
+            '',
+            cliDim(tableTop),
+            cliDim(headerLine),
+            cliDim(tableMiddle),
+            ...rowLines,
+            cliDim(tableBottom),
+            '',
+            ...detailBox.map((line) => cliDim(line)),
+            '',
+            cliDim('Tab switch lane  ·  Up/Down move  ·  q or Esc exit'),
+        ];
+        if (renderLineCount > 0) {
+            node_process_1.stdout.write(`\u001B[${renderLineCount}A`);
+            node_process_1.stdout.write('\u001B[0J');
+        }
+        node_process_1.stdout.write(`${hideCursor}${lines.join('\n')}\n`);
+        renderLineCount = lines.length;
+    };
+    const clampSelection = () => {
+        const activeRows = sections[activeSectionIndex]?.rows ?? [];
+        selectedIndex = Math.max(0, Math.min(selectedIndex, Math.max(activeRows.length - 1, 0)));
+    };
+    render();
+    await new Promise((resolve) => setTimeout(resolve, 40));
+    await new Promise((resolve) => {
+        const cleanup = () => {
+            node_process_1.stdin.off('keypress', onKeypress);
+            if (canUseRawMode) {
+                node_process_1.stdin.setRawMode(previousRawMode === true);
+            }
+            node_process_1.stdout.write(`\u001B[${renderLineCount}A`);
+            node_process_1.stdout.write(`\u001B[0J${showCursor}`);
+            resolve();
+        };
+        const onKeypress = (_value, key) => {
+            if (key.ctrl && key.name === 'c') {
+                cleanup();
+                return;
+            }
+            if (key.name === 'up' || key.name === 'k') {
+                selectedIndex = Math.max(0, selectedIndex - 1);
+                render();
+                return;
+            }
+            if (key.name === 'down' || key.name === 'j') {
+                const rows = sections[activeSectionIndex]?.rows ?? [];
+                selectedIndex = Math.min(Math.max(rows.length - 1, 0), selectedIndex + 1);
+                render();
+                return;
+            }
+            if (key.name === 'tab' || key.name === 'right' || key.name === 'l') {
+                activeSectionIndex = (activeSectionIndex + 1) % sections.length;
+                clampSelection();
+                render();
+                return;
+            }
+            if (key.name === 'left' || key.name === 'h') {
+                activeSectionIndex = (activeSectionIndex - 1 + sections.length) % sections.length;
+                clampSelection();
+                render();
+                return;
+            }
+            if (key.name === 'escape' || key.name === 'q' || key.name === 'return' || key.name === 'enter') {
+                cleanup();
+            }
+        };
+        node_process_1.stdin.on('keypress', onKeypress);
+    });
+    return true;
+}
 async function promptText(question, options) {
     const rl = (0, promises_1.createInterface)({ input: node_process_1.stdin, output: node_process_1.stdout });
     try {
@@ -1810,9 +2320,9 @@ async function run() {
             return;
         }
         printPublicStatusOverview(displayOverview);
-        console.log(`- secure storage=${secureStorage.backend}`);
+        console.log(cliKeyLine('secure', secureStorage.backend));
         if (!secureStorage.available || secureStorage.plaintextFallbackActive) {
-            console.log(`- secure storage detail=${secureStorage.detail}`);
+            console.log(cliKeyLine('secure note', secureStorage.detail));
         }
         printPublicStatusGuidance(displayOverview, sessionState);
     };
@@ -1828,17 +2338,16 @@ async function run() {
             return;
         }
         const freshness = inbox.summary.freshness_state ?? 'fresh';
-        const ageSeconds = Number.isFinite(inbox.summary.snapshot_age_seconds)
-            ? Number(inbox.summary.snapshot_age_seconds)
-            : 0;
-        console.log(`[forkit-connect] Inbox snapshot freshness=${freshness} age_seconds=${ageSeconds}`);
+        if (await maybeShowInteractiveInboxTable(inbox)) {
+            return;
+        }
+        printSmartInbox(inbox);
         if (freshness === 'stale') {
-            console.log('[forkit-connect] Snapshot is stale. Run `forkit-connect inbox --refresh` for immediate reconcile.');
+            console.log(cliKeyLine('refresh', 'Run forkit-connect inbox --refresh for an immediate reconcile.'));
         }
         else if (freshness === 'syncing') {
-            console.log('[forkit-connect] Background reconcile is running; results will self-refresh after completion.');
+            console.log(cliKeyLine('refresh', 'Background reconcile is still running.'));
         }
-        printSmartInbox(inbox);
     };
     const runPublicCollectedChanges = () => {
         const rawLimit = limitArg !== null ? Number(limitArg) : 20;
@@ -4173,6 +4682,9 @@ async function run() {
                 printJson(summary);
                 return;
             }
+            if (await maybeShowInteractiveRuntimeReviewTable(summary)) {
+                return;
+            }
             printRuntimeReview(summary);
             return;
         }
@@ -4480,6 +4992,9 @@ async function run() {
                     printJson(summary);
                     return;
                 }
+                if (await maybeShowInteractiveRuntimeReviewTable(summary)) {
+                    return;
+                }
                 printRuntimeReview(summary);
                 return;
             }

package/dist/launcher.js

@@ -7085,16 +7085,6 @@ function renderLauncherHtml(launcherToken) {
               <h4 class="discovery-review-title" id="discovery-review-title">Select a discovery item</h4>
               <p class="discovery-review-meta" id="discovery-review-meta">Choose a model, agent, or runtime to review it here.</p>
               <p class="discovery-review-detail" id="discovery-review-detail">Registering creates or updates a Forkit Passport. Nothing is published automatically.</p>
-              <div class="review-summary-grid">
-                <div class="review-summary-pill">
-                  <span class="review-summary-label">Action</span>
-                  <span class="review-summary-value" id="discovery-review-action-summary">Select an item</span>
-                </div>
-                <div class="review-summary-pill">
-                  <span class="review-summary-label">Scope</span>
-                  <span class="review-summary-value" id="discovery-review-scope-summary">Review</span>
-                </div>
-              </div>
               <div class="review-recommendation-card">
                 <p class="review-recommendation-kicker">Recommended next step</p>
                 <h4 class="review-recommendation-title" id="discovery-review-recommendation-title">Select an item</h4>
@@ -7968,6 +7958,31 @@ function renderLauncherHtml(launcherToken) {
       return '';
     }
 
+    function getDiscoveryReviewDetailText(item) {
+      if (!item) return 'Registering creates or updates a Forkit Passport. Nothing is published automatically.';
+      if (item.kind === 'runtime') {
+        return item.statusTone === 'error'
+          ? 'Open runtime review to fix health before linked registrations continue.'
+          : '';
+      }
+      if (item.statusLabel === 'Registration in progress') {
+        return '';
+      }
+      if (item.statusLabel === 'Finish privately first') {
+        return '';
+      }
+      if (item.matchedPassportGaid && !item.passportGaid) {
+        return '';
+      }
+      if (item.passportGaid) {
+        return '';
+      }
+      if (item.actionLabel === 'Retry') {
+        return 'Review the latest local metadata before retrying registration.';
+      }
+      return '';
+    }
+
     function getQuickReviewStatusText(item) {
       if (!item) return 'Waiting for review.';
       const meta = typeof item.statusMeta === 'string' ? item.statusMeta.trim() : '';
@@ -8476,14 +8491,11 @@ function renderLauncherHtml(launcherToken) {
         return;
       }
       if (!workspaceId) {
-        setText('discovery-review-scope-summary', 'Choose governed workspace');
         return;
       }
       if (!projectId) {
-        setText('discovery-review-scope-summary', workspaceLabel ? (workspaceLabel + ' · choose project') : 'Choose project');
         return;
       }
-      setText('discovery-review-scope-summary', [workspaceLabel, projectLabel].filter(Boolean).join(' · ') || 'Governed project');
     }
 
     function syncDiscoveryReviewRegistrationMode(item, mode) {
@@ -8503,7 +8515,6 @@ function renderLauncherHtml(launcherToken) {
           deferEnabled: canReviewDefer(item),
           ignoreEnabled: canReviewIgnore(item),
         });
-        setText('discovery-review-action-summary', getReviewActionSummary(item, reviewScopeMode));
         updateReviewRecommendation('discovery-review', item, reviewScopeMode);
       }
       updateDiscoveryReviewScopeSummary(reviewScopeMode);
@@ -8564,8 +8575,6 @@ function renderLauncherHtml(launcherToken) {
         setText('discovery-review-title', 'Select a discovery item');
         setText('discovery-review-meta', 'Choose a model, agent, or runtime to review it here.');
         setText('discovery-review-detail', 'Registering creates or updates a Forkit Passport. Nothing is published automatically.');
-        setText('discovery-review-action-summary', 'Select an item');
-        setText('discovery-review-scope-summary', 'Review');
         setText('discovery-review-recommendation-title', 'Select an item');
         setText('discovery-review-recommendation-detail', 'Connect will show the best next step after you choose a model, agent, or runtime.');
         if (scopeWrap) scopeWrap.hidden = true;
@@ -8582,10 +8591,9 @@ function renderLauncherHtml(launcherToken) {
       setText('discovery-review-kicker', typeLabel);
       setText('discovery-review-title', item.name);
       setText('discovery-review-meta', item.subtitle + ' · ' + item.source);
-      setText('discovery-review-detail', getReviewDetailText(item));
-      setText('discovery-review-action-summary', getReviewActionSummary(item, 'solo'));
+      setOptionalDetail('discovery-review-detail', getDiscoveryReviewDetailText(item));
       updateReviewRecommendation('discovery-review', item, 'solo');
-      setDiscoveryReviewStatus(item.statusLabel + (item.statusMeta ? ' · ' + item.statusMeta : ''), item.statusTone === 'muted' ? '' : item.statusTone);
+      setDiscoveryReviewStatus(getQuickReviewStatusText(item), item.statusTone === 'muted' ? '' : item.statusTone);
       resetReviewResolutionActions('discovery-review');
       setDiscoveryReviewButtons({
         primaryLabel: getReviewPrimaryLabel(item, 'solo'),
@@ -8598,7 +8606,6 @@ function renderLauncherHtml(launcherToken) {
         if (scopeWrap) scopeWrap.hidden = true;
         setReviewRegistrationMode('discovery-review', 'solo');
         reviewScopeCacheKey = null;
-        setText('discovery-review-scope-summary', getPassiveReviewScopeSummary(item));
         updateReviewRecommendation('discovery-review', item, 'solo');
         return;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forkit-connect",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "Forkit Connect Local Engine - The Global AI Governance Fabric",
   "license": "MIT",
   "main": "dist/index.js",