forkit-connect 0.1.21 → 0.1.23

package/dist/cli.js

@@ -13,6 +13,7 @@ const daemon_1 = require("./v1/daemon");
 const service_1 = require("./v1/service");
 const discovery_1 = require("./v1/discovery");
 const heartbeat_1 = require("./v1/heartbeat");
+const startup_1 = require("./v1/startup");
 const runtime_activity_1 = require("./v1/runtime-activity");
 const runtime_editor_activity_1 = require("./v1/runtime-editor-activity");
 const runtime_observation_runner_1 = require("./v1/runtime-observation-runner");
@@ -81,6 +82,7 @@ const PUBLIC_COMMANDS = [
     ['login', 'Link this device to your Forkit.dev account'],
     ['logout', 'Remove the stored Forkit.dev session from this device'],
     ['status', 'Show account, scope, daemon, and queue status'],
+    ['startup', 'Enable, disable, or inspect CLI startup on login'],
     ['changes', 'View all collected local changes and queued sync items'],
     ['start', 'Open the interactive launcher or start foreground sync'],
     ['stop', 'Stop the local Connect daemon'],
@@ -117,14 +119,28 @@ const ADVANCED_COMMAND_GROUPS = [
     ['notify', 'Notification preview and delivery controls'],
 ];
 function usage() {
-    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>'));
+    printCliHeader('CLI', 'Local AI discovery, review, and registration from your terminal.');
+    console.log(cliKeyLine('command', 'forkit-connect <command> [options]'));
+    console.log(cliKeyLine('always on', 'forkit-connect startup enable'));
+    console.log(cliKeyLine('review', 'forkit-connect inbox'));
     console.log(cliKeyLine('runtime', 'forkit-connect runtime <register|review|status>'));
-    printCliSection('Core');
-    for (const [command, description] of PUBLIC_COMMANDS) {
-        console.log(cliKeyLine(command, description));
-    }
+    printCliSection('Start Here');
+    console.log(cliKeyLine('login', 'Connect this device to your Forkit.dev account'));
+    console.log(cliKeyLine('scan', 'Detect local models, runtimes, and agents'));
+    console.log(cliKeyLine('inbox', 'Review what needs action'));
+    console.log(cliKeyLine('startup', 'Keep Connect running from sign-in'));
+    printCliSection('Daily');
+    console.log(cliKeyLine('status', 'See account, queue, and daemon state'));
+    console.log(cliKeyLine('start', 'Open the interactive local console'));
+    console.log(cliKeyLine('sync', 'Flush queued local metadata'));
+    console.log(cliKeyLine('stop', 'Stop the background daemon'));
+    printCliSection('Governed');
+    console.log(cliKeyLine('workspace', 'Optional workspace and project scope'));
+    console.log(cliKeyLine('register', 'Register ready local models'));
+    console.log(cliKeyLine('runtime', 'Register or review local runtimes'));
+    printCliSection('Safety');
+    console.log(cliKeyLine('ignore', 'Deny one detected local model on this device'));
+    console.log(cliKeyLine('doctor', 'Check notifications, storage, and runtime wiring'));
     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'));
@@ -1399,42 +1415,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,
+                ]),
+            });
         }
     }
 }
@@ -1468,14 +1507,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*/, ''),
+                ]),
+            });
         }
     }
 }
@@ -1504,17 +1554,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,
@@ -1697,6 +1823,242 @@ function printSmartInbox(inbox) {
     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 })));
@@ -1784,6 +2146,7 @@ function printPublicStatusOverview(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('background', status.daemon_status === 'running' ? 'always on' : 'start required'));
     console.log(cliKeyLine('privacy', status.privacy_mode));
     console.log(cliKeyLine('inventory', joinCliSummary([
         formatCliCompactCount(status.models_discovered, 'model'),
@@ -1804,6 +2167,47 @@ function printPublicStatusOverview(status) {
         console.log(cliKeyLine('warning', 'Local governed scope exists, but login is still required.'));
     }
 }
+function formatStartupSummary(status) {
+    if (!status.supported)
+        return 'not supported';
+    if (status.enabled === true)
+        return 'enabled';
+    if (status.enabled === false)
+        return 'disabled';
+    return 'unknown';
+}
+function printStartupStatusLine(status) {
+    console.log(cliKeyLine('startup', formatStartupSummary(status)));
+}
+function printPublicStartupStatus(status) {
+    const enabled = status.enabled === true;
+    const platform = status.mode === 'launch_agent'
+        ? 'macOS LaunchAgent'
+        : status.mode === 'registry_run'
+            ? 'Windows sign-in registry'
+            : status.mode === 'systemd_user'
+                ? 'Linux user service'
+                : 'not available';
+    printCliHeader('Startup', 'Keep Forkit Connect running from sign-in without a tray app.');
+    console.log(cliKeyLine('auto start', enabled ? 'on' : status.enabled === false ? 'off' : 'unknown'));
+    console.log(cliKeyLine('behavior', enabled
+        ? 'Forkit Connect launches its background daemon when you sign in.'
+        : 'Forkit Connect starts only when you run it manually.'));
+    console.log(cliKeyLine('platform', platform));
+    console.log(cliKeyLine('next', enabled ? 'forkit-connect startup disable' : 'forkit-connect startup enable'));
+    if (hasFlag('--advanced-help') && status.configPath) {
+        console.log(cliKeyLine('config', status.configPath));
+    }
+}
+function getNotificationReadiness() {
+    if (process.platform === 'darwin') {
+        return 'Forkit Connect click-through ready';
+    }
+    if (process.platform === 'win32') {
+        return 'native Windows toasts ready';
+    }
+    return 'native desktop alerts when a GUI session is available';
+}
 function getOtherReadyCount(readyToConnectCount, draftFirstCount) {
     return Math.max(0, readyToConnectCount - draftFirstCount);
 }
@@ -2284,6 +2688,7 @@ async function run() {
     const runPublicConnectStatus = async () => {
         const sessionState = await checkBackendSessionState(service);
         const secureStorage = service.getCredentialStoreStatus();
+        const startupStatus = (0, startup_1.getCliStartupStatus)();
         if (service.readSessionRef()) {
             await withTimeout(service.refreshEffectiveBinding(), STATUS_BINDING_TIMEOUT_MS, undefined);
         }
@@ -2309,6 +2714,10 @@ async function run() {
                 session_truth: accountTrusted ? 'account_verified_or_offline' : 'local_scope_cached_login_required',
                 local_scope_cached: !accountTrusted && localScopeCached,
                 binding_truth: accountTrusted ? 'account_binding_active' : 'account_login_required',
+                startup_on_login: startupStatus,
+                notifications: {
+                    readiness: getNotificationReadiness(),
+                },
                 secure_storage: {
                     backend: secureStorage.backend,
                     available: secureStorage.available,
@@ -2324,8 +2733,28 @@ async function run() {
         if (!secureStorage.available || secureStorage.plaintextFallbackActive) {
             console.log(cliKeyLine('secure note', secureStorage.detail));
         }
+        console.log(cliKeyLine('notifications', getNotificationReadiness()));
+        printStartupStatusLine(startupStatus);
         printPublicStatusGuidance(displayOverview, sessionState);
     };
+    const runPublicStartupStatus = () => {
+        const startupStatus = (0, startup_1.getCliStartupStatus)();
+        if (hasFlag('--json')) {
+            printJson(startupStatus);
+            return;
+        }
+        printPublicStartupStatus(startupStatus);
+    };
+    const runPublicStartupEnable = () => {
+        const startupStatus = (0, startup_1.enableCliStartup)(process.execPath, __filename);
+        printPublicStartupStatus(startupStatus);
+        console.log('[forkit-connect] CLI startup on login is enabled. The background daemon will come up when your session starts.');
+    };
+    const runPublicStartupDisable = () => {
+        const startupStatus = (0, startup_1.disableCliStartup)();
+        printPublicStartupStatus(startupStatus);
+        console.log('[forkit-connect] CLI startup on login is disabled. Use forkit-connect stop if you also want to stop the daemon right now.');
+    };
     const runPublicConnectInbox = async () => {
         const forceRefresh = hasFlag('--refresh');
         const inbox = service.getSmartRegistrationInbox({
@@ -4588,6 +5017,24 @@ async function run() {
         await runPublicConnectStatus();
         return;
     }
+    if (command === 'startup') {
+        const subcommand = args[1] || 'status';
+        if (subcommand === 'status') {
+            runPublicStartupStatus();
+            return;
+        }
+        if (subcommand === 'enable') {
+            runPublicStartupEnable();
+            return;
+        }
+        if (subcommand === 'disable') {
+            runPublicStartupDisable();
+            return;
+        }
+        showUsage();
+        process.exitCode = 1;
+        return;
+    }
     if (command === 'changes') {
         runPublicCollectedChanges();
         return;
@@ -4622,16 +5069,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') {
@@ -4938,10 +5382,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;
     }
@@ -5435,10 +5886,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;
         }
@@ -5834,22 +6292,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') {
@@ -5888,17 +6338,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') {