forkit-connect 0.1.6 → 0.1.8

package/dist/cli.js

@@ -1427,6 +1427,11 @@ function formatSmartInboxActionValue(action, itemType, connectableModelName) {
     }
 }
 function formatSmartInboxActionLabel(item) {
+    if (item.item_type === 'model'
+        && item.recommended_action === 'create_passport_draft'
+        && String(item.details_received_automatically.registration_flow_state || '').trim() === 'private_draft_required') {
+        return 'Open Draft Path';
+    }
     return formatSmartInboxActionValue(item.recommended_action, item.item_type, String(item.details_received_automatically.connectable_model_name || '').trim());
 }
 function printInboxGroup(label, items) {
@@ -2709,6 +2714,9 @@ async function run() {
             else if (message === 'SIMILAR_PASSPORT_EXISTS') {
                 console.error('A similar or existing passport already exists in your Forkit.dev account. Open inbox and review the connected/passport match before creating a new draft.');
             }
+            else if (message === 'INVALID_DRAFT_VISIBILITY') {
+                console.error('This registration must start as a private draft. Review it in inbox/start first, or choose publish only when Forkit is ready to finish the passport.');
+            }
             else if (message.startsWith('DRAFT_CREATE_FAILED:')) {
                 console.error(`[forkit-connect] Draft creation failed (${message.split(':')[1]}).`);
             }
@@ -2847,6 +2855,8 @@ async function run() {
         const detailKeys = [
             'verification_summary',
             'limitations_summary',
+            'registration_guidance',
+            'registration_error_message',
             'scope_suggestion',
             'scope_mismatch_reason',
             'connectable_model_name',
@@ -3871,6 +3881,8 @@ async function run() {
                 return 'A backend draft already exists for this model. No duplicate draft created.';
             if (raw === 'SIMILAR_PASSPORT_EXISTS')
                 return 'A similar or existing passport already exists in your Forkit.dev account. Review existing records before creating a new draft.';
+            if (raw === 'INVALID_DRAFT_VISIBILITY')
+                return 'This registration must start as a private draft. Review it in inbox/start first, or choose publish only when Forkit is ready to finish the passport.';
             if (raw === 'WORKSPACE_PROJECT_BINDING_REQUIRED')
                 return 'No governed workspace/project scope is linked yet. Select or create scope first.';
             if (raw === 'DRAFT_CREATION_NOT_ALLOWED_BY_BINDING')
@@ -4538,6 +4550,11 @@ async function run() {
                 process.exitCode = 2;
                 return;
             }
+            if (message === 'INVALID_DRAFT_VISIBILITY') {
+                console.error('This registration must start as a private draft. Review it in inbox/start first, or choose publish only when Forkit is ready to finish the passport.');
+                process.exitCode = 2;
+                return;
+            }
             if (message.startsWith('DRAFT_CREATE_FAILED:')) {
                 console.error(`[forkit-connect] Draft creation failed (${message.split(':')[1]}).`);
                 process.exitCode = 2;

package/dist/launcher.js

@@ -535,6 +535,16 @@ function normalizeDiscoveryRegistrationFailure(message) {
             message: 'A similar passport already exists in Forkit. Review existing records before creating a new one.',
         };
     }
+    if (normalized === 'INVALID_DRAFT_VISIBILITY') {
+        return {
+            code: normalized,
+            message: 'This registration needs to start as a private draft before it can be published.',
+            nextActions: [
+                'Keep the item in review or open the draft path first.',
+                'Choose publish only when Forkit is ready to finish the passport.',
+            ],
+        };
+    }
     if (normalized === 'WORKSPACE_PROJECT_BINDING_REQUIRED') {
         return {
             code: normalized,
@@ -666,6 +676,9 @@ function buildDiscovery(service) {
         const registeredPassportName = getInboxDetailText(entry, 'registered_passport_name');
         const scopeSuggestion = getInboxDetailText(entry, 'scope_suggestion');
         const verificationSummary = getInboxDetailText(entry, 'verification_summary');
+        const registrationState = getInboxDetailText(entry, 'registration_flow_state');
+        const registrationGuidance = getInboxDetailText(entry, 'registration_guidance')
+            ?? getInboxDetailText(entry, 'registration_error_message');
         const matchReason = entry.match_reason;
         const draftPending = binding?.status === 'pending';
         let statusLabel = 'Ready to register';
@@ -687,6 +700,13 @@ function buildDiscovery(service) {
             actionLabel = 'Review';
             actionTone = 'accent';
         }
+        else if (registrationState === 'private_draft_required') {
+            statusLabel = 'Draft first';
+            statusMeta = registrationGuidance ?? 'This model needs to go through the private draft path before publishing.';
+            statusTone = 'warn';
+            actionLabel = 'Review';
+            actionTone = 'accent';
+        }
         else if (group === 'connected') {
             statusLabel = 'Registered';
             statusMeta = registeredPassportName
@@ -7581,9 +7601,11 @@ function renderLauncherHtml(launcherToken) {
         actionSummary: result && result.code === 'GOVERNED_PASSPORT_CAPACITY_REACHED'
           ? 'Capacity full · use an existing passport or free space'
           : result && result.code === 'DRAFT_LIMIT_REACHED'
-          ? 'Draft capacity full · use an existing passport, clear a draft, or upgrade'
+        ? 'Draft capacity full · use an existing passport, clear a draft, or upgrade'
           : result && result.code === 'SIMILAR_PASSPORT_EXISTS'
           ? 'Matching passport exists · reuse it instead of creating another'
+          : result && result.code === 'INVALID_DRAFT_VISIBILITY'
+          ? 'Draft first · keep this registration private until it is ready to publish'
           : result && (result.code === 'WORKSPACE_PROJECT_BINDING_REQUIRED' || result.code === 'DRAFT_CREATION_NOT_ALLOWED_BY_BINDING')
           ? 'Scope required · choose workspace and project'
           : null,

package/dist/v1/service.d.ts

@@ -408,6 +408,7 @@ export declare class ConnectV1Service {
     private hasExactBoundPassportForModel;
     private runtimeHasExactBoundModelDuplicate;
     private clearModelReviewDeferral;
+    private updateDetectedModelRegistrationHint;
     private buildPassportMatchSuggestionForModel;
     private normalizeRemotePassportList;
     private loadRemoteWorkspaceNameMaps;

package/dist/v1/service.js

@@ -2287,6 +2287,33 @@ class ConnectV1Service {
             : item);
         this.stateStore.replaceDetectedModels(nextModels);
     }
+    updateDetectedModelRegistrationHint(model, input) {
+        const nextModels = this.stateStore.readState().detected_models.map((item) => {
+            if (item.discoveryHash !== model.discoveryHash) {
+                return item;
+            }
+            const nextMetadata = {
+                ...(item.metadata && typeof item.metadata === 'object' ? item.metadata : {}),
+            };
+            const assignOrDelete = (key, value) => {
+                if (value === null || value === undefined || value === '') {
+                    delete nextMetadata[key];
+                    return;
+                }
+                nextMetadata[key] = value;
+            };
+            assignOrDelete('tracking_status', input.trackingStatus ?? null);
+            assignOrDelete('registration_error_code', input.errorCode ?? null);
+            assignOrDelete('registration_error_message', input.errorMessage ?? null);
+            assignOrDelete('registration_error_status', typeof input.errorStatus === 'number' ? input.errorStatus : null);
+            assignOrDelete('registration_guidance', input.guidance ?? null);
+            return {
+                ...item,
+                metadata: nextMetadata,
+            };
+        });
+        this.stateStore.replaceDetectedModels(nextModels);
+    }
     buildPassportMatchSuggestionForModel(state, model, runtimePassport) {
         const registrationKey = (0, discovery_1.buildModelRegistrationKey)(model, state.runtime_identity.runtimeId);
         const candidates = state.model_bindings
@@ -4305,6 +4332,10 @@ class ConnectV1Service {
             const observedProjectId = normalizeDisplayText(modelMetadata.projectId ?? modelMetadata.project_id);
             const scopeSuggestion = this.resolveScopeSuggestion(refreshedState, observedWorkspaceId, observedProjectId);
             const itemId = this.buildInboxItemId('model', model.discoveryHash);
+            const registrationTrackingStatus = normalizeDisplayText(modelMetadata.tracking_status);
+            const registrationErrorMessage = normalizeDisplayText(modelMetadata.registration_error_message);
+            const registrationErrorCode = normalizeDisplayText(modelMetadata.registration_error_code);
+            const registrationGuidance = normalizeDisplayText(modelMetadata.registration_guidance);
             const recommendedAction = binding?.status === 'bound'
                 ? 'open_on_forkit'
                 : suggestion.match_confidence === 'medium'
@@ -4371,6 +4402,10 @@ class ConnectV1Service {
                     registered_workspace_name: binding?.workspaceName ?? null,
                     registered_project_name: binding?.projectName ?? null,
                     remote_match_source: binding?.remoteMatchSource ?? null,
+                    registration_flow_state: registrationTrackingStatus,
+                    registration_error_message: registrationErrorMessage,
+                    registration_error_code: registrationErrorCode,
+                    registration_guidance: registrationGuidance,
                     verification_summary: verification.verification,
                     limitations_summary: verification.limitations,
                     review_disposition: reviewDisposition,
@@ -7793,8 +7828,18 @@ class ConnectV1Service {
         const soloDraftAllowed = draftBindingStatus.allowed && draftBindingStatus.reasonCode === 'solo_passport_draft_allowed';
         const localScopedDraftAllowed = draftBindingStatus.allowed && draftBindingStatus.reasonCode === 'local_workspace_project_draft_allowed';
         const model = this.resolveModelSelection(selector, state);
-        const requestedVisibility = options?.visibility === 'private' ? 'private' : 'public';
+        const requestedDestination = options?.destination === 'passport' ? 'passport' : 'draft';
+        const requestedVisibility = options?.visibility === 'public' && requestedDestination === 'passport'
+            ? 'public'
+            : 'private';
         this.clearModelReviewDeferral(model);
+        this.updateDetectedModelRegistrationHint(model, {
+            trackingStatus: null,
+            errorCode: null,
+            errorMessage: null,
+            errorStatus: null,
+            guidance: null,
+        });
         const { payload, registrationKey } = this.buildConnectDraftPayload(model, state, draftScope, {
             visibility: requestedVisibility,
         });
@@ -7802,7 +7847,7 @@ class ConnectV1Service {
         const binding = this.findBindingForModel(this.stateStore.readState(), model, registrationKey);
         const pendingQueue = this.findPendingQueueItem(state, model, registrationKey);
         const shouldPublishImmediately = requestedVisibility === 'public'
-            && (options?.destination === 'passport' || (soloDraftAllowed && options?.destination !== 'draft'));
+            && (requestedDestination === 'passport' || (soloDraftAllowed && requestedDestination !== 'draft'));
         const bindingWithRuntime = binding ? {
             ...binding,
             runtimeGaid: binding.runtimeGaid ?? runtimePassport?.runtime_gaid ?? null,
@@ -7936,6 +7981,16 @@ class ConnectV1Service {
             const api = this.getApiClient(state);
             const result = await api.createPassportDraft(payload);
             if (!result.ok) {
+                const backendCode = extractApiErrorCode(result.body) || `DRAFT_CREATE_FAILED:${result.status}`;
+                if (backendCode === 'INVALID_DRAFT_VISIBILITY') {
+                    this.updateDetectedModelRegistrationHint(model, {
+                        trackingStatus: 'private_draft_required',
+                        errorCode: backendCode,
+                        errorMessage: 'This registration must start as a private draft before it can be published.',
+                        errorStatus: result.status,
+                        guidance: 'Open the review flow and continue through the private draft path first.',
+                    });
+                }
                 this.observeBackendCommunicationState({
                     passportGaid: bindingWithRuntime?.gaid ?? null,
                     runtimeGaid: runtimePassport?.runtime_gaid ?? null,
@@ -7944,7 +7999,7 @@ class ConnectV1Service {
                     body: result.body,
                     source: 'draft_sync',
                 });
-                throw new Error(result.status === 409 ? 'DRAFT_ALREADY_EXISTS' : (extractApiErrorCode(result.body) || `DRAFT_CREATE_FAILED:${result.status}`));
+                throw new Error(result.status === 409 ? 'DRAFT_ALREADY_EXISTS' : backendCode);
             }
             const parsed = this.parseDraftResponse(result);
             let finalGaid = parsed.gaid;

package/dist/v1/state.js

@@ -938,8 +938,30 @@ class LocalStateStore {
             const seen = new Map();
             for (const model of models) {
                 const existing = state.detected_models.find((item) => item.discoveryHash === model.discoveryHash);
+                const nextMetadata = model.metadata && typeof model.metadata === 'object'
+                    ? { ...model.metadata }
+                    : {};
+                const existingMetadata = existing?.metadata && typeof existing.metadata === 'object'
+                    ? existing.metadata
+                    : null;
+                if (existingMetadata) {
+                    for (const key of [
+                        'draft_id',
+                        'passport_gaid',
+                        'tracking_status',
+                        'registration_error_code',
+                        'registration_error_message',
+                        'registration_error_status',
+                        'registration_guidance',
+                    ]) {
+                        if (!Object.prototype.hasOwnProperty.call(nextMetadata, key) && Object.prototype.hasOwnProperty.call(existingMetadata, key)) {
+                            nextMetadata[key] = existingMetadata[key];
+                        }
+                    }
+                }
                 seen.set(model.discoveryHash, {
                     ...model,
+                    metadata: nextMetadata,
                     status: model.status === 'ignored' || model.status === 'bound'
                         ? model.status
                         : existing?.status === 'ignored' || existing?.status === 'bound'

package/package.json

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