forkit-connect 0.1.20 → 0.1.22

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;
@@ -1235,42 +1399,65 @@ function printCollectedChanges(service, limit) {
     for (const event of state.evidence_events) {
         evidenceTypeCounts.set(event.type, (evidenceTypeCounts.get(event.type) || 0) + 1);
     }
-    console.log('[forkit-connect] Collected changes');
-    console.log(`- state_dir=${paths.stateDir}`);
-    console.log(`- state_file=${paths.stateFile}`);
-    console.log(`- evidence_events=${state.evidence_events.length}`);
-    console.log(`- pulse_events=${state.pulse_events.length}`);
-    console.log(`- sync_queue=${state.sync_queue.length}`);
-    console.log(`- pending_reviews=${state.pending_reviews.length}`);
-    console.log(`- evolution_candidates=${state.evolution_candidates.length}`);
-    console.log(`- c2_events=${state.c2_events.length}`);
-    console.log(`- detected_models=${state.detected_models.length}`);
-    console.log(`- detected_runtimes=${state.detected_runtimes.length}`);
-    console.log(`- detected_agents=${state.detected_agents.length}`);
-    console.log('[forkit-connect] Some collected changes are local advisory telemetry and review evidence; only synced queue items become backend-authoritative.');
+    printCliHeader('Changes', 'Local evidence, queue, and runtime activity collected on this device.');
+    console.log(cliKeyLine('state dir', paths.stateDir));
+    console.log(cliKeyLine('state file', paths.stateFile));
+    console.log(cliKeyLine('summary', joinCliSummary([
+        formatCliCompactCount(state.evidence_events.length, 'evidence event'),
+        formatCliCompactCount(state.pulse_events.length, 'pulse event'),
+        formatCliCompactCount(state.sync_queue.length, 'queued sync'),
+        formatCliCompactCount(state.pending_reviews.length, 'pending review'),
+    ])));
+    console.log(cliKeyLine('local', joinCliSummary([
+        formatCliCompactCount(state.detected_models.length, 'model'),
+        formatCliCompactCount(state.detected_runtimes.length, 'runtime'),
+        formatCliCompactCount(state.detected_agents.length, 'agent'),
+        formatCliCompactCount(state.c2_events.length, 'c2 event'),
+    ])));
+    console.log(cliKeyLine('note', 'Only synced queue items become backend-authoritative.'));
     const sortedEvidenceTypes = [...evidenceTypeCounts.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
     if (sortedEvidenceTypes.length > 0) {
-        console.log('[forkit-connect] Evidence types observed:');
+        printCliSection('Evidence Types');
         for (const [type, count] of sortedEvidenceTypes) {
-            console.log(`- ${type}: ${count}`);
+            printCliEntry(type, {
+                summary: formatCliCompactCount(count, 'event'),
+            });
         }
     }
     if (recentEvidence.length > 0) {
-        console.log(`[forkit-connect] Recent evidence events showing=${recentEvidence.length} limit=${limit}`);
+        printCliSection(`Recent Evidence ${cliTag(String(recentEvidence.length), 'accent')}`);
         for (const event of recentEvidence) {
-            console.log(`- ${formatTimestamp(event.createdAt)} | ${event.type}${formatEvidenceDetails(event.details)}`);
+            printCliEntry(event.type, {
+                summary: formatTimestamp(event.createdAt),
+                meta: truncateCliText(formatEvidenceDetails(event.details).replace(/^\s*\|\s*/, ''), 88),
+            });
         }
     }
     if (recentPulse.length > 0) {
-        console.log(`[forkit-connect] Recent runtime signal history showing=${recentPulse.length} limit=${limit}`);
+        printCliSection(`Runtime Signals ${cliTag(String(recentPulse.length), 'good')}`);
         for (const event of recentPulse) {
-            console.log(`- ${event.measured_at} | runtime=${event.runtime_name} | model=${event.model_name || 'n/a'} | pulse=${event.pulse_status} | registration=${formatPulseRegistrationLabel(event)}`);
+            printCliEntry(event.runtime_name, {
+                summary: event.pulse_status,
+                meta: joinCliSummary([
+                    formatTimestamp(event.measured_at),
+                    event.model_name ? `model ${event.model_name}` : null,
+                    formatPulseRegistrationLabel(event),
+                ]),
+            });
         }
     }
     if (state.sync_queue.length > 0) {
-        console.log('[forkit-connect] Pending sync queue:');
+        printCliSection(`Pending Sync ${cliTag(String(Math.min(state.sync_queue.length, limit)), 'warm')}`);
         for (const item of state.sync_queue.slice(0, limit)) {
-            console.log(`- ${item.type} | endpoint=${item.endpoint} | attempts=${item.attempts} | created_at=${item.createdAt} | next_retry_at=${item.nextRetryAt} | last_error=${item.lastError || 'n/a'}`);
+            printCliEntry(item.type, {
+                summary: item.endpoint,
+                meta: joinCliSummary([
+                    `attempts ${item.attempts}`,
+                    `created ${formatTimestamp(item.createdAt)}`,
+                    item.nextRetryAt ? `retry ${formatTimestamp(item.nextRetryAt)}` : null,
+                    item.lastError ? `error ${truncateCliText(item.lastError, 48)}` : null,
+                ]),
+            });
         }
     }
 }
@@ -1304,14 +1491,25 @@ function printReviewSnapshot(snapshot) {
         'shadow_candidate',
         'provider_unavailable',
     ];
-    console.log(`[forkit-connect] Review items=${snapshot.total}`);
+    printCliHeader('Review', `${formatCliCompactCount(snapshot.total, 'local item')} across models and runtimes.`);
     for (const status of order) {
         const entries = snapshot.groups[status];
         if (entries.length === 0)
             continue;
-        console.log(`${formatReviewStatusLabel(status)}: ${entries.length}`);
+        printCliSection(`${formatReviewStatusLabel(status)} ${cliTag(String(entries.length), status === 'bound_passport' ? 'good' : status === 'provider_unavailable' ? 'danger' : 'warm')}`);
         for (const entry of entries) {
-            console.log(`- item=${entry.model_name || entry.process_name || 'n/a'} | runtime=${entry.runtime_name || 'n/a'} | discovery=${shortId(entry.discovery_hash)} | registration=${shortId(entry.registration_key)} | next=${formatReviewActionLabel(entry.suggested_action)}${formatReviewEvidence(entry)}`);
+            printCliEntry(formatCliReviewSubject(entry), {
+                tag: entry.kind,
+                tagTone: entry.kind === 'provider' ? 'danger' : entry.kind === 'process' ? 'warm' : 'accent',
+                summary: formatReviewSuggestedActionCompact(entry.suggested_action),
+                meta: joinCliSummary([
+                    formatCliReviewRuntime(entry),
+                    entry.discovery_hash ? `discovery ${shortId(entry.discovery_hash)}` : null,
+                    entry.registration_key ? `registration ${shortId(entry.registration_key)}` : null,
+                    entry.passport_gaid ? `passport ${shortId(entry.passport_gaid)}` : null,
+                    formatReviewEvidence(entry).replace(/^\s*\|\s*/, ''),
+                ]),
+            });
         }
     }
 }
@@ -1340,17 +1538,93 @@ function printTrainStatus(status) {
 }
 function printAgentReview(snapshot) {
     const order = ['new_agent', 'known_agent', 'linked_agent', 'inactive_agent', 'unknown_ai_tool'];
-    console.log(`[forkit-connect] Agent review items=${snapshot.total}`);
+    printCliHeader('Agent Review', `${formatCliCompactCount(snapshot.total, 'agent item')} detected on this device.`);
     for (const status of order) {
         const entries = snapshot.groups[status];
         if (entries.length === 0)
             continue;
-        console.log(`${status}: ${entries.length}`);
+        const tone = status === 'linked_agent' ? 'good' : status === 'inactive_agent' ? 'danger' : status === 'unknown_ai_tool' ? 'muted' : 'warm';
+        const label = status === 'new_agent'
+            ? 'New agents'
+            : status === 'known_agent'
+                ? 'Needs link'
+                : status === 'linked_agent'
+                    ? 'Linked agents'
+                    : status === 'inactive_agent'
+                        ? 'Inactive agents'
+                        : 'Unknown AI tools';
+        printCliSection(`${label} ${cliTag(String(entries.length), tone)}`);
         for (const entry of entries) {
-            console.log(`- agent=${entry.agent_name} | type=${entry.agent_type} | status=${entry.status} | id=${shortId(entry.agent_id)} | linked_model=${entry.linked_model_name || 'n/a'} | passport=${entry.linked_passport_gaid || 'n/a'} | action=${entry.suggested_action}${formatReviewEvidence(entry)}`);
+            printCliEntry(entry.agent_name, {
+                tag: entry.agent_type.replaceAll('_', ' '),
+                tagTone: entry.agent_type === 'unknown_ai_tool' ? 'muted' : 'accent',
+                summary: formatAgentSuggestedActionCompact(entry.suggested_action),
+                meta: joinCliSummary([
+                    entry.status.replaceAll('_', ' '),
+                    entry.linked_model_name ? `model ${entry.linked_model_name}` : null,
+                    entry.linked_passport_gaid ? `passport ${shortId(entry.linked_passport_gaid)}` : null,
+                    formatReviewEvidence(entry).replace(/^\s*\|\s*/, ''),
+                ]),
+            });
         }
     }
 }
+function printWorkspaceListSurface(workspaces, options) {
+    printCliHeader('Workspaces', `${formatCliCompactCount(workspaces.length, 'accessible workspace')} on this account.`);
+    const identityBits = [
+        options?.displayName || null,
+        options?.accountEmail || null,
+        options?.platformRole ? `role ${options.platformRole}` : null,
+    ];
+    if (identityBits.some(Boolean)) {
+        console.log(cliKeyLine('account', joinCliSummary(identityBits)));
+    }
+    if (options?.accountLimits) {
+        console.log(cliKeyLine('plan', options.accountLimits.planName));
+        console.log(cliKeyLine('capacity', joinCliSummary([
+            formatRemainingLimit(options.accountLimits.workspaceLimit, options.accountLimits.workspacesUsed, 'workspace'),
+            formatRemainingLimit(options.accountLimits.projectLimit, options.accountLimits.projectsUsed, 'project'),
+        ])));
+    }
+    if (workspaces.length === 0) {
+        console.log(cliKeyLine('next', 'Create a workspace from forkit-connect workspace create.'));
+        return;
+    }
+    printCliSection('Accessible');
+    for (const workspace of workspaces) {
+        printCliEntry(String(workspace.name || 'Unnamed workspace').trim() || 'Unnamed workspace', {
+            tag: String(workspace.role || 'unknown').trim() || 'unknown',
+            tagTone: 'accent',
+            summary: formatWorkspaceStateCell(workspace),
+            meta: joinCliSummary([
+                String(workspace.id || workspace.gaid || workspace.passportGaid || 'unknown'),
+                workspace.verificationStatus ? `verification ${workspace.verificationStatus}` : null,
+                workspace.description ? truncateCliText(workspace.description, 52) : null,
+            ]),
+        });
+    }
+}
+function printProjectListSurface(projects, workspaceId) {
+    printCliHeader('Projects', `${formatCliCompactCount(projects.length, 'project')} inside workspace ${shortId(workspaceId)}.`);
+    if (projects.length === 0) {
+        console.log(cliKeyLine('next', 'Create the first project with forkit-connect workspace select --workspace <id> --project-name "<name>".'));
+        return;
+    }
+    printCliSection('Available');
+    for (const project of projects) {
+        const passportCount = Number(project.passportCount);
+        printCliEntry(String(project.name || 'Unnamed project').trim() || 'Unnamed project', {
+            tag: String(project.status || 'active').trim() || 'active',
+            tagTone: 'good',
+            summary: Number.isFinite(passportCount) && passportCount >= 0 ? `${passportCount} passports` : 'passport count unavailable',
+            meta: joinCliSummary([
+                String(project.id || 'unknown'),
+                project.updatedAt ? `updated ${formatTimestamp(project.updatedAt)}` : null,
+                project.description ? truncateCliText(project.description, 52) : null,
+            ]),
+        });
+    }
+}
 function printAgentStatus(status) {
     console.log(JSON.stringify({
         detected_agents: status.detectedAgents,
@@ -1365,23 +1639,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 +1735,369 @@ 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 formatCliEvidenceSummary(confidence, sourceLabel) {
+    const normalizedConfidence = String(confidence || '').trim().toLowerCase();
+    if (normalizedConfidence === 'high' || normalizedConfidence === 'medium' || normalizedConfidence === 'low') {
+        return formatCliEvidenceCell(normalizedConfidence);
     }
+    const source = String(sourceLabel || '').trim();
+    return source ? truncateCliText(source, 14) : 'local review';
+}
+function formatCliReviewSubject(entry) {
+    if (entry.kind === 'process') {
+        return String(entry.process_name || 'Unknown process').trim() || 'Unknown process';
+    }
+    return String(entry.model_name || entry.runtime_name || 'Unknown item').trim() || 'Unknown item';
+}
+function formatCliReviewRuntime(entry) {
+    if (entry.kind === 'provider') {
+        return String(entry.runtime_name || 'runtime').trim() || 'runtime';
+    }
+    return String(entry.runtime_name || 'local').trim() || 'local';
+}
+function formatReviewSuggestedActionCompact(action) {
+    switch (action) {
+        case 'connect_model':
+            return 'Connect model';
+        case 'review_drafts':
+            return 'Open draft';
+        case 'already_connected':
+            return 'Already linked';
+        case 'review/runtime':
+            return 'Check runtime';
+        case 'review/connect':
+        case 'review_model':
+            return 'Review item';
+        default:
+            return truncateCliText(action.replaceAll('_', ' '), 24);
+    }
+}
+function buildDiscoveryInteractiveSections(snapshot) {
+    const mapRows = (groupLabel, items) => items.map((entry) => ({ groupLabel, entry }));
+    const sections = [
+        { id: 'new', label: 'New', tone: 'accent', rows: mapRows('New models', snapshot.groups.new_unregistered) },
+        { id: 'known', label: 'Known', tone: 'warm', rows: mapRows('Known models', snapshot.groups.known_unregistered) },
+        { id: 'drafts', label: 'Drafts', tone: 'good', rows: mapRows('Pending drafts', snapshot.groups.pending_draft) },
+        { id: 'linked', label: 'Linked', tone: 'muted', rows: mapRows('Connected', snapshot.groups.bound_passport) },
+        { id: 'runtime', label: 'Runtime', tone: 'warm', rows: mapRows('Unconnected runtimes', snapshot.groups.shadow_candidate) },
+        { id: 'unavailable', label: 'Offline', tone: 'danger', rows: mapRows('Unavailable runtimes', snapshot.groups.provider_unavailable) },
+    ];
+    return sections.filter((section) => section.rows.length > 0);
+}
+function buildDiscoveryInteractiveDetailLines(row) {
+    const entry = row.entry;
+    const lines = [
+        formatCliDetailLine('Review', row.groupLabel),
+        formatCliDetailLine('Item', formatCliReviewSubject(entry)),
+        formatCliDetailLine('Runtime', formatCliReviewRuntime(entry)),
+        formatCliDetailLine('Next', formatReviewSuggestedActionCompact(entry.suggested_action)),
+        formatCliDetailLine('Evidence', formatCliEvidenceSummary(entry.confidence, entry.source_label)),
+    ];
+    if (entry.source_label) {
+        lines.push(formatCliDetailLine('Source', entry.source_label));
+    }
+    if (entry.discovery_hash) {
+        lines.push(formatCliDetailLine('Discovery', shortId(entry.discovery_hash)));
+    }
+    if (entry.registration_key) {
+        lines.push(formatCliDetailLine('Registration', shortId(entry.registration_key)));
+    }
+    if (entry.draft_id) {
+        lines.push(formatCliDetailLine('Draft', shortId(entry.draft_id)));
+    }
+    if (entry.passport_gaid) {
+        lines.push(formatCliDetailLine('Passport', shortId(entry.passport_gaid)));
+    }
+    if (entry.reason) {
+        lines.push(formatCliDetailLine('Reason', truncateCliText(entry.reason, 64)));
+    }
+    return lines;
+}
+async function maybeShowInteractiveDiscoveryReviewTable(snapshot) {
+    return await viewInteractiveTable({
+        title: '[forkit-connect] Review',
+        subtitle: `${formatCliCompactCount(snapshot.total, 'local item')} across models and runtimes`,
+        sections: buildDiscoveryInteractiveSections(snapshot),
+        columns: [
+            { header: 'Item', width: 30, render: (row) => formatCliReviewSubject(row.entry) },
+            { header: 'Runtime', width: 18, render: (row) => formatCliReviewRuntime(row.entry) },
+            { header: 'Next', width: 24, render: (row) => formatReviewSuggestedActionCompact(row.entry.suggested_action) },
+            { header: 'Evidence', width: 14, render: (row) => formatCliEvidenceSummary(row.entry.confidence, row.entry.source_label) },
+        ],
+        detailLines: buildDiscoveryInteractiveDetailLines,
+        detailTitle: (row) => `${row.entry.kind.toUpperCase()} SNAPSHOT`,
+        emptyState: 'No local review items are available right now.',
+    });
+}
+function formatAgentSuggestedActionCompact(action) {
+    switch (action) {
+        case 'none':
+            return 'Already linked';
+        case 'rescan_agent':
+            return 'Rescan agent';
+        case 'review_agent':
+            return 'Review agent';
+        case 'link_model':
+            return 'Link model';
+        case 'connect_agent':
+            return 'Connect agent';
+        default:
+            return truncateCliText(action.replaceAll('_', ' '), 24);
+    }
+}
+function buildAgentInteractiveSections(snapshot) {
+    const rows = (groupLabel, items) => items.map((entry) => ({ groupLabel, entry }));
+    const sections = [
+        { id: 'new', label: 'New', tone: 'accent', rows: rows('New agents', snapshot.groups.new_agent) },
+        { id: 'known', label: 'Needs link', tone: 'warm', rows: rows('Needs link', snapshot.groups.known_agent) },
+        { id: 'linked', label: 'Linked', tone: 'good', rows: rows('Linked agents', snapshot.groups.linked_agent) },
+        { id: 'inactive', label: 'Inactive', tone: 'danger', rows: rows('Inactive agents', snapshot.groups.inactive_agent) },
+        { id: 'tooling', label: 'Tooling', tone: 'muted', rows: rows('Unknown AI tools', snapshot.groups.unknown_ai_tool) },
+    ];
+    return sections.filter((section) => section.rows.length > 0);
+}
+function buildAgentInteractiveDetailLines(row) {
+    const entry = row.entry;
+    const lines = [
+        formatCliDetailLine('Review', row.groupLabel),
+        formatCliDetailLine('Status', entry.status.replaceAll('_', ' ')),
+        formatCliDetailLine('Next', formatAgentSuggestedActionCompact(entry.suggested_action)),
+        formatCliDetailLine('Evidence', formatCliEvidenceSummary(entry.confidence, entry.source_label)),
+        formatCliDetailLine('Agent ID', shortId(entry.agent_id)),
+    ];
+    if (entry.source_label) {
+        lines.push(formatCliDetailLine('Source', entry.source_label));
+    }
+    if (entry.linked_model_name) {
+        lines.push(formatCliDetailLine('Model', entry.linked_model_name));
+    }
+    if (entry.linked_passport_gaid) {
+        lines.push(formatCliDetailLine('Passport', shortId(entry.linked_passport_gaid)));
+    }
+    if (entry.matched_terms?.length) {
+        lines.push(formatCliDetailLine('Matched', truncateCliText(entry.matched_terms.join(', '), 64)));
+    }
+    return lines;
+}
+async function maybeShowInteractiveAgentReviewTable(snapshot) {
+    return await viewInteractiveTable({
+        title: '[forkit-connect] Agent Review',
+        subtitle: `${formatCliCompactCount(snapshot.total, 'agent item')} discovered on this device`,
+        sections: buildAgentInteractiveSections(snapshot),
+        columns: [
+            { header: 'Agent', width: 28, render: (row) => row.entry.agent_name },
+            { header: 'Type', width: 18, render: (row) => row.entry.agent_type.replaceAll('_', ' ') },
+            { header: 'State', width: 16, render: (row) => row.entry.status.replaceAll('_', ' ') },
+            { header: 'Next', width: 22, render: (row) => formatAgentSuggestedActionCompact(row.entry.suggested_action) },
+        ],
+        detailLines: buildAgentInteractiveDetailLines,
+        detailTitle: () => 'AGENT SNAPSHOT',
+        emptyState: 'No agent review items are available right now.',
+    });
+}
+function formatWorkspaceStateCell(workspace) {
+    return [String(workspace.visibility || '').trim(), String(workspace.lifecycleStatus || '').trim()]
+        .filter(Boolean)
+        .join(' · ') || 'active';
+}
+function buildWorkspaceInteractiveDetailLines(row) {
+    const workspace = row.workspace;
+    const lines = [
+        formatCliDetailLine('Workspace', String(workspace.name || 'Unnamed workspace').trim() || 'Unnamed workspace'),
+        formatCliDetailLine('Role', String(workspace.role || 'unknown').trim() || 'unknown'),
+        formatCliDetailLine('Visibility', String(workspace.visibility || 'not set').trim() || 'not set'),
+        formatCliDetailLine('Lifecycle', String(workspace.lifecycleStatus || 'active').trim() || 'active'),
+        formatCliDetailLine('Verification', String(workspace.verificationStatus || 'unverified').trim() || 'unverified'),
+        formatCliDetailLine('ID', String(workspace.id || workspace.gaid || workspace.passportGaid || 'unknown').trim() || 'unknown'),
+    ];
+    if (workspace.ownerName) {
+        lines.push(formatCliDetailLine('Owner', String(workspace.ownerName).trim()));
+    }
+    if (workspace.description) {
+        lines.push(formatCliDetailLine('Notes', truncateCliText(workspace.description, 64)));
+    }
+    return lines;
+}
+async function maybeShowInteractiveWorkspaceTable(workspaces) {
+    return await viewInteractiveTable({
+        title: '[forkit-connect] Workspaces',
+        subtitle: `${formatCliCompactCount(workspaces.length, 'accessible workspace')} on this account`,
+        sections: [{ id: 'all', label: 'Accessible', tone: 'accent', rows: workspaces.map((workspace) => ({ workspace })) }],
+        columns: [
+            { header: 'Workspace', width: 28, render: (row) => String(row.workspace.name || 'Unnamed workspace').trim() || 'Unnamed workspace' },
+            { header: 'Role', width: 14, render: (row) => String(row.workspace.role || 'unknown').trim() || 'unknown' },
+            { header: 'State', width: 26, render: (row) => formatWorkspaceStateCell(row.workspace) },
+            { header: 'ID', width: 14, render: (row) => shortId(String(row.workspace.id || row.workspace.gaid || row.workspace.passportGaid || 'unknown')) },
+        ],
+        detailLines: buildWorkspaceInteractiveDetailLines,
+        detailTitle: () => 'WORKSPACE SNAPSHOT',
+        emptyState: 'No workspaces are available right now.',
+    });
+}
+function buildProjectInteractiveDetailLines(row) {
+    const project = row.project;
+    const passportCount = Number(project.passportCount);
+    const lines = [
+        formatCliDetailLine('Project', String(project.name || 'Unnamed project').trim() || 'Unnamed project'),
+        formatCliDetailLine('Status', String(project.status || 'active').trim() || 'active'),
+        formatCliDetailLine('Passports', Number.isFinite(passportCount) && passportCount >= 0 ? String(passportCount) : 'n/a'),
+        formatCliDetailLine('Project ID', String(project.id || 'unknown').trim() || 'unknown'),
+        formatCliDetailLine('Workspace', shortId(row.workspaceId || String(project.workspaceId || ''))),
+    ];
+    if (project.updatedAt) {
+        lines.push(formatCliDetailLine('Updated', formatTimestamp(project.updatedAt)));
+    }
+    if (project.description) {
+        lines.push(formatCliDetailLine('Notes', truncateCliText(project.description, 64)));
+    }
+    return lines;
+}
+async function maybeShowInteractiveProjectTable(projects, workspaceId) {
+    return await viewInteractiveTable({
+        title: '[forkit-connect] Projects',
+        subtitle: `${formatCliCompactCount(projects.length, 'project')} inside workspace ${shortId(workspaceId)}`,
+        sections: [{ id: 'all', label: 'Available', tone: 'accent', rows: projects.map((project) => ({ workspaceId, project })) }],
+        columns: [
+            { header: 'Project', width: 28, render: (row) => String(row.project.name || 'Unnamed project').trim() || 'Unnamed project' },
+            { header: 'Status', width: 16, render: (row) => String(row.project.status || 'active').trim() || 'active' },
+            { header: 'Passports', width: 12, render: (row) => {
+                    const passportCount = Number(row.project.passportCount);
+                    return Number.isFinite(passportCount) && passportCount >= 0 ? String(passportCount) : '-';
+                }, align: 'right' },
+            { header: 'Project ID', width: 14, render: (row) => shortId(String(row.project.id || 'unknown')) },
+        ],
+        detailLines: buildProjectInteractiveDetailLines,
+        detailTitle: () => 'PROJECT SNAPSHOT',
+        emptyState: 'No projects are available right now.',
+    });
+}
+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 +2126,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 +2161,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 +2358,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 +2666,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 +2684,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;
@@ -4113,16 +4968,13 @@ async function run() {
                     return;
                 }
                 const accountLimits = await loadCliAccountLimits().catch(() => null);
-                console.log(`[forkit-connect] Workspaces: ${workspaces.length}`);
-                if (accountLimits) {
-                    console.log(`- welcome=${accountLimits.displayName || 'there'}`);
-                    console.log(`- plan=${accountLimits.planName}`);
-                    console.log(`- workspaces_left=${formatRemainingLimit(accountLimits.workspaceLimit, accountLimits.workspacesUsed, 'workspace')}`);
-                    console.log(`- projects_left=${formatRemainingLimit(accountLimits.projectLimit, accountLimits.projectsUsed, 'project')}`);
-                }
-                for (const workspace of workspaces) {
-                    console.log(formatWorkspaceAccessLine(workspace));
+                if (await maybeShowInteractiveWorkspaceTable(workspaces)) {
+                    return;
                 }
+                printWorkspaceListSurface(workspaces, {
+                    displayName: accountLimits?.displayName || null,
+                    accountLimits,
+                });
                 return;
             }
             if (subcommand === 'select') {
@@ -4173,6 +5025,9 @@ async function run() {
                 printJson(summary);
                 return;
             }
+            if (await maybeShowInteractiveRuntimeReviewTable(summary)) {
+                return;
+            }
             printRuntimeReview(summary);
             return;
         }
@@ -4426,10 +5281,17 @@ async function run() {
     if (command === 'review') {
         const reviewScan = await service.scanRuntime();
         const snapshot = service.buildReviewSnapshot(reviewScan.summary);
+        if (hasFlag('--json')) {
+            printJson(snapshot);
+            return;
+        }
         if (snapshot.total === 0) {
             console.log('No review items found. Run `forkit-connect scan` first or ensure local runtimes are available.');
             return;
         }
+        if (await maybeShowInteractiveDiscoveryReviewTable(snapshot)) {
+            return;
+        }
         printReviewSnapshot(snapshot);
         return;
     }
@@ -4480,6 +5342,9 @@ async function run() {
                     printJson(summary);
                     return;
                 }
+                if (await maybeShowInteractiveRuntimeReviewTable(summary)) {
+                    return;
+                }
                 printRuntimeReview(summary);
                 return;
             }
@@ -4920,10 +5785,17 @@ async function run() {
         }
         if (subcommand === 'review') {
             const snapshot = service.buildAgentReviewSnapshot();
+            if (hasFlag('--json')) {
+                printJson(snapshot);
+                return;
+            }
             if (snapshot.total === 0) {
                 console.log('No agent items found. Run `forkit-connect agent scan` first.');
                 return;
             }
+            if (await maybeShowInteractiveAgentReviewTable(snapshot)) {
+                return;
+            }
             printAgentReview(snapshot);
             return;
         }
@@ -5319,22 +6191,14 @@ async function run() {
             : typeof tokenPayload?.role === 'string'
                 ? tokenPayload.role
                 : null;
-        if (email || platformRole) {
-            const identityParts = [
-                email ? `account=${email}` : null,
-                platformRole ? `platform_role=${platformRole}` : null,
-            ].filter(Boolean);
-            console.log(`[forkit-connect] ${identityParts.join(' | ')}`);
-        }
         const workspaces = Array.isArray(payload.workspaces) ? payload.workspaces : [];
-        console.log(`[forkit-connect] Workspaces: ${workspaces.length}`);
-        if (workspaces.length === 0) {
-            console.log('[forkit-connect] No accessible workspaces returned by /api/profiles/access.');
+        if (await maybeShowInteractiveWorkspaceTable(workspaces)) {
             return;
         }
-        for (const workspace of workspaces) {
-            console.log(formatWorkspaceAccessLine(workspace));
-        }
+        printWorkspaceListSurface(workspaces, {
+            accountEmail: email,
+            platformRole,
+        });
         return;
     }
     if (command === 'projects') {
@@ -5373,17 +6237,11 @@ async function run() {
             process.exitCode = 2;
             return;
         }
-        console.log('Authenticated successfully.');
         const projects = Array.isArray(result.body.projects) ? result.body.projects : [];
-        console.log(`Projects: ${projects.length}`);
-        if (projects.length === 0) {
-            console.log('No projects found in this workspace.');
-            console.log('Run `forkit-connect workspace select --workspace <id> --project-name "<name>"` to create the first project here.');
+        if (await maybeShowInteractiveProjectTable(projects, workspaceId)) {
             return;
         }
-        for (const project of projects) {
-            console.log(formatWorkspaceProjectLine(project));
-        }
+        printProjectListSurface(projects, workspaceId);
         return;
     }
     if (command === 'bind') {