forkit-connect 0.1.0

package/dist/v1/lifecycle-monitor.js

@@ -0,0 +1,512 @@
+"use strict";
+/**
+ * lifecycle-monitor.ts
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Deep AI model and agent lifecycle observability engine for Forkit Connect.
+ *
+ * Capabilities (fully automatic, 24/7, login-only onboarding):
+ *
+ * 1. Silent model change detection
+ *    Tracks digest, size, and weights-layer hash per model binding.
+ *    Emits `connect_silent_model_change` when any of these change without an
+ *    announced version event, queuing a PendingReview for human acknowledgement.
+ *
+ * 2. Model drift detection (metadata-based)
+ *    Tracks quantization label and parameter count changes over scan cycles.
+ *    Emits `connect_model_drift_detected` on capability-class changes.
+ *
+ * 3. Agent behavioral drift detection
+ *    Computes a hash of each agent's distinct observed tool set. If the tool
+ *    fingerprint changes significantly (tools added or removed) it emits
+ *    `connect_agent_drift_detected`.
+ *
+ * 4. Prompt injection detection
+ *    Scans agent tool-call observations for known injection patterns:
+ *    system-override phrases, base64-encoded instruction payloads, DAN-style
+ *    prompts. Emits `connect_prompt_injection_suspected` with confidence level.
+ *
+ * 5. Adversarial influence detection
+ *    Correlates: (a) multiple injection signals within the same scan window,
+ *    (b) a prompt injection AND a silent model change on the same agent/model
+ *    pair. When correlated, emits `connect_adversarial_influence_observed`.
+ *
+ * Human-in-the-loop flow:
+ *    Every detection writes a PendingReview. Humans can confirm/dismiss via
+ *    `c2 reviews` CLI commands. Once a pattern is confirmed once, subsequent
+ *    detections of the same kind for the same subject are auto-confirmed,
+ *    giving full automation with initial oversight.
+ *
+ * Privacy contract:
+ *    This module never reads prompt content or model outputs directly.
+ *    It only inspects: model metadata (name, digest, size, quantization label,
+ *    parameter count), agent tool names (not arguments), and detection signals
+ *    already recorded in the evidence chain.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLifecycleMonitoringPass = runLifecycleMonitoringPass;
+exports.findPassportsNeedingApiKeyProvisioning = findPassportsNeedingApiKeyProvisioning;
+const node_crypto_1 = require("node:crypto");
+// ─── Constants ──────────────────────────────────────────────────────────────
+/** Minimum seconds between monitor passes for the same subject. */
+const MONITOR_COOLDOWN_SECONDS = 120;
+/** Minimum size delta (bytes) to consider a model significantly smaller/larger. */
+const SIZE_DELTA_THRESHOLD_BYTES = 10 * 1024 * 1024; // 10 MB
+/** Minimum number of tool-set changes needed to declare agent drift. */
+const AGENT_DRIFT_TOOL_DELTA_THRESHOLD = 2;
+/** Injection signals within this window are correlated for adversarial detection. */
+const ADVERSARIAL_CORRELATION_WINDOW_MS = 5 * 60 * 1000; // 5 minutes
+// ─── Injection Pattern Library ───────────────────────────────────────────────
+const INJECTION_PATTERNS = [
+    // System override phrases
+    { pattern: /ignore (all )?previous instructions?/i, label: 'ignore_previous_instructions', confidence: 'high' },
+    { pattern: /disregard (your|all) (previous |prior )?instructions?/i, label: 'disregard_instructions', confidence: 'high' },
+    { pattern: /you are now (a |an )?(new |different )?/i, label: 'persona_override', confidence: 'medium' },
+    { pattern: /act as (a |an )?(?:DAN|unrestricted|jailbreak)/i, label: 'dan_jailbreak', confidence: 'high' },
+    { pattern: /\[SYSTEM\]|\[INST\]|\[\/INST\]/i, label: 'raw_system_tag_injection', confidence: 'high' },
+    { pattern: /<<<.*?(system|override|admin).*?>>>/i, label: 'bracket_override', confidence: 'medium' },
+    // Privilege escalation
+    { pattern: /you have (admin|root|superuser|god-mode) (access|privileges|rights)/i, label: 'privilege_escalation', confidence: 'high' },
+    { pattern: /developer mode (enabled|activated|on)/i, label: 'developer_mode_claim', confidence: 'high' },
+    { pattern: /bypass (safety|filter|guardrail|restriction)/i, label: 'safety_bypass', confidence: 'high' },
+    // Data exfiltration patterns
+    { pattern: /send (your |all )?(system|memory|context|knowledge base) to/i, label: 'data_exfiltration', confidence: 'high' },
+    { pattern: /repeat (the|your) (system|hidden|secret) prompt/i, label: 'prompt_extraction', confidence: 'high' },
+    // Indirect injection markers
+    { pattern: /note to AI:/i, label: 'note_to_ai', confidence: 'medium' },
+    { pattern: /hidden instruction/i, label: 'hidden_instruction', confidence: 'high' },
+    // Base64 encoded content > 40 chars (potential encoded instructions)
+    { pattern: /[A-Za-z0-9+/]{40,}={0,2}/, label: 'possible_base64_payload', confidence: 'low' },
+];
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function nowIso() {
+    return new Date().toISOString();
+}
+function shortId(value) {
+    return (0, node_crypto_1.createHash)('sha256').update(value, 'utf8').digest('hex').slice(0, 16);
+}
+function makeReviewId(kind, subjectId, detectedAt) {
+    return shortId(`${kind}:${subjectId}:${detectedAt}`);
+}
+function toolPatternHash(toolNames) {
+    const sorted = [...new Set(toolNames)].sort();
+    return (0, node_crypto_1.createHash)('sha256').update(sorted.join('|'), 'utf8').digest('hex').slice(0, 32);
+}
+function extractAgentToolNames(agent) {
+    const raw = agent.metadata.observed_tools;
+    const tools = Array.isArray(raw) ? raw : [];
+    return tools.map((t) => (typeof t === 'string' ? t : t.name ?? '')).filter(Boolean);
+}
+function firstStringLike(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+        if (typeof value === 'number' && Number.isFinite(value))
+            return String(value);
+    }
+    return null;
+}
+function deriveModelParameterProfile(model) {
+    const metadata = model.metadata ?? {};
+    return firstStringLike(model.parameterSize, metadata.parameter_size, metadata.parameterSize, metadata.parameter_count, metadata.parameterCount, metadata.params);
+}
+function isCooledDown(record, nowMs) {
+    if (!record)
+        return false;
+    const lastMs = new Date(record.last_monitored_at).getTime();
+    return Number.isFinite(lastMs) && (nowMs - lastMs) < COOLDOWN_MS;
+}
+const COOLDOWN_MS = MONITOR_COOLDOWN_SECONDS * 1000;
+function extractModelBindingForModel(state, model) {
+    return state.model_bindings.find((b) => b.status === 'bound' && b.modelKey.split('#')[0]?.trim() === model.model);
+}
+function findExistingReview(state, kind, subjectId) {
+    return state.pending_reviews.find((r) => r.kind === kind && (r.passport_gaid === subjectId || r.agent_id === subjectId || r.runtime_gaid === subjectId) && r.status === 'pending');
+}
+function hadPriorConfirmation(state, kind, subjectId) {
+    return state.pending_reviews.some((r) => r.kind === kind
+        && (r.passport_gaid === subjectId || r.agent_id === subjectId || r.runtime_gaid === subjectId)
+        && (r.status === 'confirmed' || r.status === 'auto_confirmed'));
+}
+// ─── Main pass ───────────────────────────────────────────────────────────────
+function runLifecycleMonitoringPass(deps) {
+    const { state } = deps;
+    const nowMs = Date.now();
+    const detections = [];
+    let checksRun = 0;
+    let reviewsQueued = 0;
+    let reviewsAutoConfirmed = 0;
+    // ── 1. Silent model change + model drift ──────────────────────────────────
+    for (const model of state.detected_models) {
+        if (model.status === 'ignored')
+            continue;
+        const binding = extractModelBindingForModel(state, model);
+        if (!binding?.gaid)
+            continue; // Only monitor registered (bound) models
+        const subjectId = binding.gaid;
+        const existingRecord = state.lifecycle_monitor_records.find((r) => r.subject_id === subjectId && r.subject_type === 'model');
+        if (isCooledDown(existingRecord, nowMs))
+            continue;
+        checksRun += 1;
+        // Detect silent model change (digest/size/weights change)
+        const currentDigest = model.digest ?? null;
+        const currentSize = Number.isFinite(model.sizeBytes) ? model.sizeBytes : null;
+        const currentWeightsDigest = model.checksumSource === 'weights_blob' ? model.checksumValue ?? null : null;
+        const silentChangeSignals = [];
+        if (existingRecord) {
+            if (currentDigest && existingRecord.last_digest && currentDigest !== existingRecord.last_digest) {
+                silentChangeSignals.push(`manifest_digest_changed:${existingRecord.last_digest.slice(0, 12)}→${currentDigest.slice(0, 12)}`);
+            }
+            if (currentWeightsDigest && existingRecord.last_weights_digest && currentWeightsDigest !== existingRecord.last_weights_digest) {
+                silentChangeSignals.push(`weights_digest_changed:${existingRecord.last_weights_digest.slice(0, 12)}→${currentWeightsDigest.slice(0, 12)}`);
+            }
+            if (currentSize !== null
+                && existingRecord.last_size_bytes !== null
+                && Math.abs(currentSize - existingRecord.last_size_bytes) > SIZE_DELTA_THRESHOLD_BYTES) {
+                const deltaMb = Math.round((currentSize - existingRecord.last_size_bytes) / (1024 * 1024));
+                silentChangeSignals.push(`size_delta_${deltaMb > 0 ? '+' : ''}${deltaMb}mb`);
+            }
+        }
+        if (silentChangeSignals.length > 0) {
+            const confidence = silentChangeSignals.some((s) => s.startsWith('weights_digest'))
+                ? 'high'
+                : silentChangeSignals.some((s) => s.startsWith('manifest_digest'))
+                    ? 'high'
+                    : 'medium';
+            const alreadyPending = findExistingReview(state, 'silent_model_change', subjectId);
+            if (!alreadyPending) {
+                const detectedAt = nowIso();
+                const autoConfirm = hadPriorConfirmation(state, 'silent_model_change', subjectId);
+                const review = {
+                    review_id: makeReviewId('silent_model_change', subjectId, detectedAt),
+                    kind: 'silent_model_change',
+                    status: autoConfirm ? 'auto_confirmed' : 'pending',
+                    passport_gaid: subjectId,
+                    agent_id: null,
+                    runtime_gaid: null,
+                    model_name: model.model,
+                    detected_at: detectedAt,
+                    reviewed_at: autoConfirm ? detectedAt : null,
+                    auto_confirm_after_first: true,
+                    confidence,
+                    summary: `Silent change detected in ${model.model}: ${silentChangeSignals.join(', ')}`,
+                    evidence: {
+                        signals: silentChangeSignals,
+                        previous_digest: existingRecord?.last_digest,
+                        current_digest: currentDigest,
+                        previous_weights_digest: existingRecord?.last_weights_digest,
+                        current_weights_digest: currentWeightsDigest,
+                        previous_size_bytes: existingRecord?.last_size_bytes,
+                        current_size_bytes: currentSize,
+                    },
+                };
+                deps.upsertPendingReview(review);
+                if (autoConfirm)
+                    reviewsAutoConfirmed += 1;
+                else
+                    reviewsQueued += 1;
+                detections.push({ kind: 'silent_model_change', subjectId, subjectType: 'model', confidence, summary: review.summary });
+                deps.recordC2Event({
+                    eventType: 'connect_silent_model_change',
+                    passportGaid: subjectId,
+                    modelName: model.model,
+                    metadata: {
+                        signals: silentChangeSignals,
+                        confidence,
+                        auto_confirmed: autoConfirm,
+                    },
+                });
+            }
+        }
+        // Detect model drift (capability-class metadata change — quantization, param count)
+        const currentQuant = model.quantizationLevel ?? null;
+        const currentParams = deriveModelParameterProfile(model);
+        const prevBehavior = existingRecord?.last_behavior_snapshot
+            ? (() => {
+                try {
+                    return JSON.parse(existingRecord.last_behavior_snapshot);
+                }
+                catch {
+                    return null;
+                }
+            })()
+            : null;
+        const driftSignals = [];
+        if (prevBehavior && existingRecord) {
+            if (currentQuant && prevBehavior.quant && currentQuant !== prevBehavior.quant) {
+                driftSignals.push(`quantization:${String(prevBehavior.quant)}→${currentQuant}`);
+            }
+            if (currentParams && prevBehavior.params && currentParams !== String(prevBehavior.params)) {
+                driftSignals.push(`parameter_profile:${String(prevBehavior.params)}→${currentParams}`);
+            }
+            if (driftSignals.length > 0) {
+                const alreadyPending = findExistingReview(state, 'model_drift', subjectId);
+                if (!alreadyPending) {
+                    const detectedAt = nowIso();
+                    const autoConfirm = hadPriorConfirmation(state, 'model_drift', subjectId);
+                    const review = {
+                        review_id: makeReviewId('model_drift', subjectId, detectedAt),
+                        kind: 'model_drift',
+                        status: autoConfirm ? 'auto_confirmed' : 'pending',
+                        passport_gaid: subjectId,
+                        agent_id: null,
+                        runtime_gaid: null,
+                        model_name: model.model,
+                        detected_at: detectedAt,
+                        reviewed_at: autoConfirm ? detectedAt : null,
+                        auto_confirm_after_first: true,
+                        confidence: 'medium',
+                        summary: `Capability drift detected in ${model.model}: ${driftSignals.join(', ')}`,
+                        evidence: {
+                            drift_signals: driftSignals,
+                            previous_snapshot: prevBehavior,
+                            current_quant: currentQuant,
+                            current_params: currentParams,
+                        },
+                    };
+                    deps.upsertPendingReview(review);
+                    if (autoConfirm)
+                        reviewsAutoConfirmed += 1;
+                    else
+                        reviewsQueued += 1;
+                    detections.push({ kind: 'model_drift', subjectId, subjectType: 'model', confidence: 'medium', summary: review.summary });
+                    deps.recordC2Event({
+                        eventType: 'connect_model_drift_detected',
+                        passportGaid: subjectId,
+                        modelName: model.model,
+                        metadata: { drift_signals: driftSignals, auto_confirmed: autoConfirm },
+                    });
+                }
+            }
+        }
+        // Update monitor record for this model
+        deps.upsertLifecycleMonitorRecord({
+            subject_id: subjectId,
+            subject_type: 'model',
+            last_monitored_at: nowIso(),
+            last_digest: currentDigest ?? existingRecord?.last_digest ?? null,
+            last_size_bytes: currentSize ?? existingRecord?.last_size_bytes ?? null,
+            last_weights_digest: currentWeightsDigest ?? existingRecord?.last_weights_digest ?? null,
+            last_tool_pattern_hash: existingRecord?.last_tool_pattern_hash ?? null,
+            last_behavior_snapshot: JSON.stringify({
+                quant: currentQuant,
+                params: currentParams,
+            }),
+            drift_count: (existingRecord?.drift_count ?? 0) + ((silentChangeSignals.length > 0 || driftSignals.length > 0) ? 1 : 0),
+            injection_count: existingRecord?.injection_count ?? 0,
+            updated_at: nowIso(),
+        });
+    }
+    // ── 2. Agent behavioral drift + prompt injection ──────────────────────────
+    const injectionDetectedForAgents = new Set();
+    for (const agent of state.detected_agents) {
+        if (agent.status === 'inactive')
+            continue;
+        const subjectId = agent.agent_id;
+        const existingRecord = state.lifecycle_monitor_records.find((r) => r.subject_id === subjectId && r.subject_type === 'agent');
+        if (isCooledDown(existingRecord, nowMs))
+            continue;
+        checksRun += 1;
+        const toolNames = extractAgentToolNames(agent);
+        // ── 2a. Prompt injection scan ───────────────────────────────────────────
+        // Inspect recently observed tool observation strings (tool names + display labels)
+        const observationText = toolNames.join(' ');
+        const rawObs = agent.metadata.recent_observations;
+        const recentObs = Array.isArray(rawObs) ? rawObs : [];
+        const observedContext = [
+            observationText,
+            ...recentObs.map((o) => (typeof o === 'string' ? o : JSON.stringify(o))).slice(0, 10),
+        ].join(' ');
+        const injectionMatches = INJECTION_PATTERNS.filter(({ pattern }) => pattern.test(observedContext));
+        if (injectionMatches.length > 0) {
+            const highConfidence = injectionMatches.some((m) => m.confidence === 'high');
+            const confidence = highConfidence ? 'high' : injectionMatches.some((m) => m.confidence === 'medium') ? 'medium' : 'low';
+            const alreadyPending = findExistingReview(state, 'prompt_injection', subjectId);
+            if (!alreadyPending) {
+                const detectedAt = nowIso();
+                const autoConfirm = hadPriorConfirmation(state, 'prompt_injection', subjectId);
+                const review = {
+                    review_id: makeReviewId('prompt_injection', subjectId, detectedAt),
+                    kind: 'prompt_injection',
+                    status: autoConfirm ? 'auto_confirmed' : 'pending',
+                    passport_gaid: null,
+                    agent_id: subjectId,
+                    runtime_gaid: null,
+                    model_name: null,
+                    detected_at: detectedAt,
+                    reviewed_at: autoConfirm ? detectedAt : null,
+                    auto_confirm_after_first: false, // Injection always needs human eyes initially
+                    confidence,
+                    summary: `Prompt injection pattern detected in agent ${agent.agent_id}: ${injectionMatches.map((m) => m.label).join(', ')}`,
+                    evidence: {
+                        matched_patterns: injectionMatches.map((m) => ({ label: m.label, confidence: m.confidence })),
+                        agent_type: agent.agent_type,
+                        tool_count: toolNames.length,
+                    },
+                };
+                deps.upsertPendingReview(review);
+                if (autoConfirm)
+                    reviewsAutoConfirmed += 1;
+                else
+                    reviewsQueued += 1;
+                detections.push({ kind: 'prompt_injection', subjectId, subjectType: 'agent', confidence, summary: review.summary });
+                injectionDetectedForAgents.add(subjectId);
+                deps.recordC2Event({
+                    eventType: 'connect_prompt_injection_suspected',
+                    agentId: subjectId,
+                    metadata: {
+                        matched_patterns: injectionMatches.map((m) => m.label),
+                        confidence,
+                        auto_confirmed: autoConfirm,
+                    },
+                });
+            }
+        }
+        // ── 2b. Agent behavioral drift ─────────────────────────────────────────
+        if (toolNames.length > 0 && existingRecord?.last_tool_pattern_hash) {
+            const currentHash = toolPatternHash(toolNames);
+            if (currentHash !== existingRecord.last_tool_pattern_hash) {
+                // Compute actual delta magnitude
+                const prevTools = new Set(existingRecord.last_behavior_snapshot
+                    ? (() => { try {
+                        const s = JSON.parse(existingRecord.last_behavior_snapshot);
+                        return Array.isArray(s.tools) ? s.tools : [];
+                    }
+                    catch {
+                        return [];
+                    } })()
+                    : []);
+                const currentTools = new Set(toolNames);
+                const added = [...currentTools].filter((t) => !prevTools.has(t));
+                const removed = [...prevTools].filter((t) => !currentTools.has(t));
+                const deltaCount = added.length + removed.length;
+                if (deltaCount >= AGENT_DRIFT_TOOL_DELTA_THRESHOLD) {
+                    const alreadyPending = findExistingReview(state, 'agent_drift', subjectId);
+                    if (!alreadyPending) {
+                        const detectedAt = nowIso();
+                        const autoConfirm = hadPriorConfirmation(state, 'agent_drift', subjectId);
+                        const review = {
+                            review_id: makeReviewId('agent_drift', subjectId, detectedAt),
+                            kind: 'agent_drift',
+                            status: autoConfirm ? 'auto_confirmed' : 'pending',
+                            passport_gaid: null,
+                            agent_id: subjectId,
+                            runtime_gaid: null,
+                            model_name: null,
+                            detected_at: detectedAt,
+                            reviewed_at: autoConfirm ? detectedAt : null,
+                            auto_confirm_after_first: true,
+                            confidence: deltaCount >= 4 ? 'high' : 'medium',
+                            summary: `Agent tool-set drift in ${agent.agent_id}: +${added.length} tools added, -${removed.length} tools removed`,
+                            evidence: {
+                                tools_added: added,
+                                tools_removed: removed,
+                                delta_count: deltaCount,
+                                previous_tool_hash: existingRecord.last_tool_pattern_hash,
+                                current_tool_hash: currentHash,
+                            },
+                        };
+                        deps.upsertPendingReview(review);
+                        if (autoConfirm)
+                            reviewsAutoConfirmed += 1;
+                        else
+                            reviewsQueued += 1;
+                        detections.push({ kind: 'agent_drift', subjectId, subjectType: 'agent', confidence: review.confidence, summary: review.summary });
+                        deps.recordC2Event({
+                            eventType: 'connect_agent_drift_detected',
+                            agentId: subjectId,
+                            metadata: {
+                                tools_added: added,
+                                tools_removed: removed,
+                                delta_count: deltaCount,
+                                auto_confirmed: autoConfirm,
+                            },
+                        });
+                    }
+                }
+            }
+        }
+        // ── 2c. Adversarial influence correlation ──────────────────────────────
+        // Injection + simultaneous model change on linked model = adversarial pattern
+        const agentLink = state.agent_links.find((l) => l.agent_id === subjectId);
+        const linkedGaid = agentLink?.passport_gaid ?? null;
+        if (injectionDetectedForAgents.has(subjectId) && linkedGaid) {
+            const recentSilentChange = state.pending_reviews.some((r) => r.kind === 'silent_model_change'
+                && r.passport_gaid === linkedGaid
+                && (nowMs - new Date(r.detected_at).getTime()) < ADVERSARIAL_CORRELATION_WINDOW_MS);
+            if (recentSilentChange) {
+                const alreadyPending = findExistingReview(state, 'adversarial_influence', subjectId);
+                if (!alreadyPending) {
+                    const detectedAt = nowIso();
+                    const review = {
+                        review_id: makeReviewId('adversarial_influence', subjectId, detectedAt),
+                        kind: 'adversarial_influence',
+                        status: 'pending', // NEVER auto-confirmed — always needs human eyes
+                        passport_gaid: linkedGaid,
+                        agent_id: subjectId,
+                        runtime_gaid: null,
+                        model_name: null,
+                        detected_at: detectedAt,
+                        reviewed_at: null,
+                        auto_confirm_after_first: false,
+                        confidence: 'high',
+                        summary: `Adversarial influence suspected: prompt injection in agent ${subjectId} correlates with silent change in linked model passport ${linkedGaid.slice(0, 16)}`,
+                        evidence: {
+                            injection_agent_id: subjectId,
+                            silent_change_passport: linkedGaid,
+                            correlation_window_ms: ADVERSARIAL_CORRELATION_WINDOW_MS,
+                        },
+                    };
+                    deps.upsertPendingReview(review);
+                    reviewsQueued += 1;
+                    detections.push({ kind: 'adversarial_influence', subjectId, subjectType: 'agent', confidence: 'high', summary: review.summary });
+                    deps.recordC2Event({
+                        eventType: 'connect_adversarial_influence_observed',
+                        agentId: subjectId,
+                        passportGaid: linkedGaid,
+                        metadata: {
+                            injection_agent_id: subjectId,
+                            correlated_silent_change_passport: linkedGaid,
+                            auto_confirmed: false,
+                        },
+                    });
+                }
+            }
+        }
+        // Update agent monitor record
+        deps.upsertLifecycleMonitorRecord({
+            subject_id: subjectId,
+            subject_type: 'agent',
+            last_monitored_at: nowIso(),
+            last_digest: null,
+            last_size_bytes: null,
+            last_weights_digest: null,
+            last_tool_pattern_hash: toolNames.length > 0 ? toolPatternHash(toolNames) : existingRecord?.last_tool_pattern_hash ?? null,
+            last_behavior_snapshot: toolNames.length > 0 ? JSON.stringify({ tools: [...new Set(toolNames)].sort() }) : existingRecord?.last_behavior_snapshot ?? null,
+            drift_count: (existingRecord?.drift_count ?? 0) + (detections.some((d) => d.kind === 'agent_drift' && d.subjectId === subjectId) ? 1 : 0),
+            injection_count: (existingRecord?.injection_count ?? 0) + (injectionDetectedForAgents.has(subjectId) ? 1 : 0),
+            updated_at: nowIso(),
+        });
+    }
+    return {
+        checksRun,
+        detections,
+        reviewsQueued,
+        reviewsAutoConfirmed,
+    };
+}
+// ─── Auto-provision helpers (used by service.ts) ─────────────────────────────
+/**
+ * Returns the list of passport GAIDs owned by the session that do not yet
+ * have a runtime-signal API key stored locally. Used by the service to decide
+ * which passports need auto-provisioning.
+ */
+function findPassportsNeedingApiKeyProvisioning(state) {
+    return [...new Set(state.model_bindings
+            .filter((b) => b.status === 'bound'
+            && typeof b.gaid === 'string'
+            && b.gaid.trim()
+            && !b.runtimeSignalKeyPresent
+            && b.remoteMatchSource === 'forkit_passports_mine')
+            .map((b) => b.gaid))];
+}
+//# sourceMappingURL=lifecycle-monitor.js.map

package/dist/v1/lmstudio.d.ts

@@ -0,0 +1,11 @@
+import { type RuntimeProvider, type RuntimeProviderScanResult } from './providers';
+export declare class LMStudioProvider implements RuntimeProvider {
+    readonly endpoint: string;
+    private readonly fetchImpl;
+    readonly runtimeName = "lmstudio";
+    readonly runtimeType: "local-http";
+    constructor(endpoint?: string, fetchImpl?: typeof fetch);
+    scan(): Promise<RuntimeProviderScanResult>;
+}
+export declare function scanLMStudio(endpoint?: string): Promise<RuntimeProviderScanResult>;
+//# sourceMappingURL=lmstudio.d.ts.map

package/dist/v1/lmstudio.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LMStudioProvider = void 0;
+exports.scanLMStudio = scanLMStudio;
+const providers_1 = require("./providers");
+/** Try the richer LM Studio /api/v0/models endpoint; fall back to v1 shape if unavailable. */
+async function fetchLMStudioV0Models(endpoint, fetchImpl) {
+    try {
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), 3000);
+        const res = await fetchImpl(`${endpoint}/api/v0/models`, {
+            method: 'GET',
+            signal: ac.signal,
+        }).finally(() => clearTimeout(timer));
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        return Array.isArray(body.data) ? body.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+class LMStudioProvider {
+    endpoint;
+    fetchImpl;
+    runtimeName = 'lmstudio';
+    runtimeType = 'local-http';
+    constructor(endpoint = 'http://localhost:1234', fetchImpl = fetch) {
+        this.endpoint = endpoint;
+        this.fetchImpl = fetchImpl;
+    }
+    async scan() {
+        const modelsEndpoint = `${this.endpoint}/v1/models`;
+        const now = new Date().toISOString();
+        try {
+            // Try enriched v0 endpoint first; fall back to v1 if unavailable.
+            const v0Models = await fetchLMStudioV0Models(this.endpoint, this.fetchImpl);
+            let models;
+            if (v0Models) {
+                models = v0Models
+                    .map((entry) => {
+                    const modelId = String(entry.id ?? '').trim();
+                    if (!modelId)
+                        return null;
+                    return (0, providers_1.normalizeDetectedModel)({
+                        runtimeName: this.runtimeName,
+                        runtimeType: this.runtimeType,
+                        modelName: modelId,
+                        modelId,
+                        sourceEndpoint: this.endpoint,
+                        detectedAt: now,
+                        digest: `lmstudio:${modelId}`,
+                        checksumValue: null,
+                        checksumAlgorithm: null,
+                        checksumSource: null,
+                        quantizationLevel: entry.quantization ?? null,
+                        architectureFamily: entry.arch ?? null,
+                        parameterSize: null,
+                        metadata: {
+                            object: entry.object ?? null,
+                            owned_by: entry.publisher ?? null,
+                            type: entry.type ?? null,
+                            publisher: entry.publisher ?? null,
+                            compatibility_type: entry.compatibility_type ?? null,
+                            state: entry.state ?? null,
+                            max_context_length: entry.max_context_length ?? null,
+                            // path is intentionally not stored in metadata to avoid exposing filesystem paths
+                            has_local_path: Boolean(entry.path),
+                        },
+                    });
+                })
+                    .filter((item) => Boolean(item));
+            }
+            else {
+                const response = await this.fetchImpl(modelsEndpoint, { method: 'GET' });
+                if (!response.ok) {
+                    return {
+                        ok: false,
+                        runtime: (0, providers_1.buildDetectedRuntime)({
+                            runtimeName: this.runtimeName,
+                            runtimeType: this.runtimeType,
+                            endpoint: this.endpoint,
+                            status: 'error',
+                            lastSeenAt: now,
+                            error: `http_${response.status}`,
+                        }),
+                        models: [],
+                        error: `http_${response.status}`,
+                    };
+                }
+                const body = await response.json();
+                models = (body.data ?? [])
+                    .map((entry) => {
+                    const modelId = String(entry.id ?? '').trim();
+                    if (!modelId)
+                        return null;
+                    return (0, providers_1.normalizeDetectedModel)({
+                        runtimeName: this.runtimeName,
+                        runtimeType: this.runtimeType,
+                        modelName: modelId,
+                        modelId,
+                        sourceEndpoint: this.endpoint,
+                        detectedAt: now,
+                        digest: `lmstudio:${modelId}`,
+                        metadata: {
+                            object: typeof entry.object === 'string' ? entry.object : null,
+                            owned_by: typeof entry.owned_by === 'string' ? entry.owned_by : null,
+                        },
+                    });
+                })
+                    .filter((item) => Boolean(item));
+            }
+            return {
+                ok: true,
+                runtime: (0, providers_1.buildDetectedRuntime)({
+                    runtimeName: this.runtimeName,
+                    runtimeType: this.runtimeType,
+                    endpoint: this.endpoint,
+                    status: 'detected',
+                    lastSeenAt: now,
+                }),
+                models,
+                error: null,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                runtime: (0, providers_1.buildDetectedRuntime)({
+                    runtimeName: this.runtimeName,
+                    runtimeType: this.runtimeType,
+                    endpoint: this.endpoint,
+                    status: 'error',
+                    lastSeenAt: now,
+                    error: error instanceof Error ? error.message : 'request_failed',
+                }),
+                models: [],
+                error: error instanceof Error ? error.message : 'request_failed',
+            };
+        }
+    }
+}
+exports.LMStudioProvider = LMStudioProvider;
+async function scanLMStudio(endpoint = 'http://localhost:1234') {
+    return new LMStudioProvider(endpoint).scan();
+}
+//# sourceMappingURL=lmstudio.js.map