forkit-connect 0.1.4 → 0.1.6

package/dist/v1/runtime-observation-runner.d.ts

@@ -0,0 +1,49 @@
+import { type RuntimeObservedTool } from './runtime-observer';
+import { type RuntimeContextRecord } from './runtime-context';
+import type { ApiCallResult } from './api';
+import type { ProcessListEntry } from './process-scout';
+import type { RuntimeObserverTarget } from './types';
+import { ConnectV1Service } from './service';
+export interface RuntimeObservationCollection {
+    accepted: boolean;
+    reason: 'no_scoped_runtime_activity' | null;
+    gaid: string;
+    runId: string | null;
+    observedAt: string;
+    repoRoot: string;
+    relativePath: string;
+    runtimeContext: RuntimeContextRecord | null;
+    scopedObservations: RuntimeObservedTool[];
+    ambientObservations: RuntimeObservedTool[];
+    modelLabels: string[];
+    folderLabels: string[];
+    summary: string | null;
+    metadata: Record<string, unknown> | null;
+    steps: Array<Record<string, unknown>>;
+    fingerprint: string | null;
+}
+export interface CollectRuntimeObservationOptions {
+    gaid: string;
+    cwd: string;
+    clientName?: string | null;
+    commandLabel?: string | null;
+    processEntries?: ProcessListEntry[];
+    target?: RuntimeObserverTarget | null;
+}
+export declare function collectRuntimeObservation(options: CollectRuntimeObservationOptions): Promise<RuntimeObservationCollection>;
+export declare function emitCollectedRuntimeObservation(service: ConnectV1Service, collection: RuntimeObservationCollection, options?: {
+    apiKey?: string | null;
+}): Promise<ApiCallResult>;
+export interface ObserveRegisteredRuntimeTargetsResult {
+    attempted: number;
+    emitted: number;
+    skipped: number;
+    idle: number;
+    failed: number;
+    checkedIn: number;
+}
+export declare function observeRegisteredRuntimeTargets(service: ConnectV1Service, options?: {
+    processEntries?: ProcessListEntry[];
+    minRepeatMs?: number;
+}): Promise<ObserveRegisteredRuntimeTargetsResult>;
+//# sourceMappingURL=runtime-observation-runner.d.ts.map

package/dist/v1/runtime-observation-runner.js

@@ -0,0 +1,508 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectRuntimeObservation = collectRuntimeObservation;
+exports.emitCollectedRuntimeObservation = emitCollectedRuntimeObservation;
+exports.observeRegisteredRuntimeTargets = observeRegisteredRuntimeTargets;
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = __importDefault(require("node:path"));
+const resource_meter_1 = require("../resource-meter");
+const ps_list_loader_1 = require("../ps-list-loader");
+const runtime_editor_activity_1 = require("./runtime-editor-activity");
+const repo_discovery_1 = require("./repo-discovery");
+const runtime_activity_1 = require("./runtime-activity");
+const runtime_observer_1 = require("./runtime-observer");
+const runtime_context_1 = require("./runtime-context");
+function compactActiveToolDetails(details) {
+    if (!details || typeof details !== 'object' || Array.isArray(details))
+        return undefined;
+    const value = details;
+    const compact = {};
+    if (typeof value.adapter === 'string' && value.adapter.trim())
+        compact.adapter = value.adapter.trim();
+    if (typeof value.primaryRole === 'string' && value.primaryRole.trim())
+        compact.primaryRole = value.primaryRole.trim();
+    if (Array.isArray(value.hosts) && value.hosts.length > 0)
+        compact.hosts = value.hosts.slice(0, 2);
+    if (Array.isArray(value.extensionIds) && value.extensionIds.length > 0)
+        compact.extensionIds = value.extensionIds.slice(0, 2);
+    if (Array.isArray(value.workspaceMarkers) && value.workspaceMarkers.length > 0)
+        compact.workspaceMarkers = value.workspaceMarkers.slice(0, 1);
+    if (value.enableLsp === true)
+        compact.enableLsp = true;
+    if (value.trustedRuntimeRoot === true)
+        compact.trustedRuntimeRoot = true;
+    if (value.worktreeTracked === true)
+        compact.worktreeTracked = true;
+    return Object.keys(compact).length > 0 ? compact : undefined;
+}
+function compactObservationForMetadata(observation, mode = 'scoped') {
+    const base = {
+        key: observation.key,
+        label: observation.label,
+        scoped: observation.scoped,
+    };
+    if (mode !== 'ambient') {
+        base.processCount = observation.processCount;
+        base.activeProcessCount = observation.activeProcessCount;
+        base.helperProcessCount = observation.helperProcessCount;
+        base.scopedProcessCount = observation.scopedProcessCount;
+        base.detectedBy = observation.detectedBy;
+    }
+    const compactDetails = compactActiveToolDetails(observation.details);
+    if (compactDetails) {
+        base.details = compactDetails;
+    }
+    if (mode === 'active' && observation.exampleProcesses.length > 0) {
+        base.exampleProcesses = observation.exampleProcesses.slice(0, 2);
+    }
+    if (mode === 'ambient' && compactDetails && typeof compactDetails.primaryRole === 'string') {
+        base.primaryRole = compactDetails.primaryRole;
+    }
+    return base;
+}
+function hashObservationFingerprint(value) {
+    return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(value), 'utf8').digest('hex');
+}
+function deriveFolderLabelsFromFileLabels(fileLabels) {
+    const labels = [];
+    const seen = new Set();
+    for (const fileLabel of fileLabels) {
+        const normalized = String(fileLabel || '').trim().replace(/\\/g, '/');
+        if (!normalized)
+            continue;
+        const folder = node_path_1.default.posix.dirname(normalized);
+        if (!folder || folder === '.' || seen.has(folder))
+            continue;
+        seen.add(folder);
+        labels.push(folder);
+        if (labels.length >= 6)
+            break;
+    }
+    return labels;
+}
+function readRuntimeActivityResources(metadata) {
+    const activitySummary = metadata?.activitySummary;
+    const resources = activitySummary && typeof activitySummary === 'object' && !Array.isArray(activitySummary)
+        ? activitySummary.resources
+        : null;
+    if (!resources || typeof resources !== 'object' || Array.isArray(resources)) {
+        return { accuracy: 'unknown', note: null };
+    }
+    const record = resources;
+    const accuracy = typeof record.accuracy === 'string' && ['reported', 'estimated', 'unknown'].includes(record.accuracy)
+        ? record.accuracy
+        : 'unknown';
+    const numeric = (value) => {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    };
+    const result = {
+        accuracy,
+        note: typeof record.note === 'string' && record.note.trim() ? record.note.trim() : null,
+    };
+    const cpuPercent = numeric(record.cpuPercent);
+    const memoryMb = numeric(record.memoryMb);
+    const vramMb = numeric(record.vramMb);
+    if (cpuPercent !== undefined)
+        result.cpuPercent = cpuPercent;
+    if (memoryMb !== undefined)
+        result.memoryMb = memoryMb;
+    if (vramMb !== undefined)
+        result.vramMb = vramMb;
+    return result;
+}
+function buildObserverCheckinSummary(target, collection) {
+    if (collection.summary) {
+        return collection.summary;
+    }
+    return `${collection.runtimeContext?.clientName ?? target.client_name ?? node_path_1.default.basename(collection.repoRoot)} standby`;
+}
+async function emitRuntimeObserverCheckin(service, target, collection) {
+    const state = service.getStateStore().readState();
+    const runtimeLabel = collection.runtimeContext?.clientName ?? target.client_name ?? node_path_1.default.basename(collection.repoRoot);
+    const accepted = collection.accepted;
+    const resources = readRuntimeActivityResources(collection.metadata);
+    const metadata = {
+        safe_metadata_only: true,
+        observerMode: accepted ? 'active' : 'standby',
+        summary: buildObserverCheckinSummary(target, collection),
+        observationRuntimeRoot: collection.repoRoot,
+        observationRelativeEntrypoint: collection.relativePath,
+        ...(collection.runtimeContext ? { runtimeContext: collection.runtimeContext } : {}),
+        ...(collection.metadata?.projectSubject && typeof collection.metadata.projectSubject === 'object'
+            ? { projectSubject: collection.metadata.projectSubject }
+            : {}),
+        ...(collection.metadata?.activitySummary && typeof collection.metadata.activitySummary === 'object'
+            ? { activitySummary: collection.metadata.activitySummary }
+            : {}),
+    };
+    return service.emitRuntimeObserverCheckin({
+        gaid: target.runtime_gaid,
+        sessionLabel: `${runtimeLabel} local session`,
+        environment: 'device-local',
+        ...(state.runtime_identity.hostname ? { hostLabel: state.runtime_identity.hostname } : {}),
+        runtimeLabel,
+        runtimeMode: accepted ? 'active' : 'standby',
+        resourceAccuracy: resources.accuracy,
+        ...(resources.note ? { resourceNote: resources.note } : {}),
+        ...(resources.cpuPercent !== undefined ? { cpuPercent: resources.cpuPercent } : {}),
+        ...(resources.memoryMb !== undefined ? { memoryMb: resources.memoryMb } : {}),
+        ...(resources.vramMb !== undefined ? { vramMb: resources.vramMb } : {}),
+        metadata,
+    });
+}
+function normalizeRuntimeContext(repoRoot, clientName, target) {
+    if (!repoRoot)
+        return null;
+    const existing = (0, runtime_context_1.readRuntimeContext)(repoRoot);
+    if (existing) {
+        return existing;
+    }
+    return (0, runtime_context_1.buildRuntimeContextRecord)({
+        existing: target
+            ? {
+                schemaVersion: 'forkit.runtime-context.v1',
+                ...(target.client_name ? { clientName: target.client_name } : {}),
+                ...(target.subject_id ? { subjectId: target.subject_id } : {}),
+                ...(target.worktree_id ? { worktreeId: target.worktree_id } : {}),
+            }
+            : null,
+        clientName,
+        defaultLabel: node_path_1.default.basename(repoRoot),
+    });
+}
+async function collectRuntimeObservation(options) {
+    const repo = (0, repo_discovery_1.detectRepository)(options.cwd);
+    const runtimeContext = normalizeRuntimeContext(repo.isGitRepo ? repo.rootPath : null, options.clientName ?? options.target?.client_name ?? null, options.target);
+    const processEntries = options.processEntries ?? await (0, ps_list_loader_1.listProcesses)();
+    const observations = (0, runtime_observer_1.detectActiveRuntimeTooling)(repo, processEntries);
+    const scopedObservations = observations.filter((item) => item.scoped);
+    const ambientObservations = observations.filter((item) => !item.scoped);
+    const observedAt = new Date().toISOString();
+    if (scopedObservations.length === 0) {
+        return {
+            accepted: false,
+            reason: 'no_scoped_runtime_activity',
+            gaid: options.gaid,
+            runId: null,
+            observedAt,
+            repoRoot: repo.rootPath || repo.cwd,
+            relativePath: repo.relativeCwd || '.',
+            runtimeContext,
+            scopedObservations,
+            ambientObservations,
+            modelLabels: [],
+            folderLabels: [],
+            summary: null,
+            metadata: null,
+            steps: [],
+            fingerprint: null,
+        };
+    }
+    const scopedKeys = new Set(scopedObservations.map((item) => item.key));
+    const codexThreads = scopedKeys.has('codex') ? (0, runtime_editor_activity_1.collectCodexEditorThreads)(repo) : [];
+    const copilotActivity = (scopedKeys.has('vscode') || scopedKeys.has('cursor'))
+        ? (0, runtime_editor_activity_1.collectCopilotEditorActivity)(repo)
+        : { threads: [], modelLabels: [], fileLabels: [], scopeFileLabels: [] };
+    const claudeActivity = scopedKeys.has('claude')
+        ? (0, runtime_editor_activity_1.collectClaudeProjectActivity)(repo)
+        : { threads: [], modelLabels: [], fileLabels: [], scopeFileLabels: [] };
+    const activityThreads = [
+        ...codexThreads,
+        ...copilotActivity.threads,
+        ...claudeActivity.threads,
+    ];
+    const fileLabels = claudeActivity.fileLabels;
+    const scopeFileLabels = Array.from(new Set([
+        ...copilotActivity.scopeFileLabels,
+    ])).slice(0, 6);
+    const folderLabels = Array.from(new Set([
+        ...(0, runtime_observer_1.extractObservedFolderLabels)(repo, scopedObservations),
+        ...deriveFolderLabelsFromFileLabels(fileLabels),
+        ...deriveFolderLabelsFromFileLabels(scopeFileLabels),
+    ])).slice(0, 6);
+    const modelLabels = Array.from(new Set([
+        ...(0, runtime_observer_1.extractObservedModelLabels)(scopedObservations),
+        ...copilotActivity.modelLabels,
+        ...claudeActivity.modelLabels,
+    ])).slice(0, 6);
+    const totalScopedCpuPercent = scopedObservations.reduce((sum, item) => sum + (typeof item.cpuPercent === 'number' ? item.cpuPercent : 0), 0);
+    const totalScopedMemoryMb = scopedObservations.reduce((sum, item) => sum + (typeof item.memoryMb === 'number' ? item.memoryMb : 0), 0);
+    const systemMetrics = await new resource_meter_1.ResourceMeter().captureMetrics();
+    const resourceAccuracy = (totalScopedCpuPercent > 0
+        || totalScopedMemoryMb > 0
+        || systemMetrics.vram_mb > 0) ? 'reported' : 'unknown';
+    const envelope = (0, runtime_activity_1.buildRuntimeActivityMetadata)({
+        cwd: options.cwd,
+        repo,
+        stableSubjectId: runtimeContext?.subjectId,
+        stableWorktreeId: runtimeContext?.worktreeId,
+        provider: 'forkit-connect',
+        model: modelLabels[0] ?? 'runtime-observer-v1',
+        serviceName: 'Forkit Connect Observer',
+        serviceKind: 'custom',
+        status: 'completed',
+        startedAt: observedAt,
+        endedAt: observedAt,
+        clientName: options.clientName ?? runtimeContext?.clientName ?? null,
+        commandLabel: options.commandLabel ?? 'runtime-observer',
+        includeServiceNameAsActor: false,
+        actorLabels: scopedObservations.map((item) => item.label),
+        activityThreads: activityThreads.map((thread) => ({
+            title: thread.threadLabel,
+            taskId: thread.threadId ?? null,
+            openedAt: thread.createdAt ?? null,
+            lastActiveAt: thread.lastActiveAt ?? null,
+            provider: thread.provider,
+            actorLabel: thread.actorLabel,
+            workspaceHost: thread.workspaceHost,
+            folderScope: thread.folderScope ?? null,
+        })),
+        folderLabels,
+        fileLabels,
+        scopeFileLabels,
+        modelLabels,
+        resources: {
+            ...(totalScopedCpuPercent > 0 ? { cpuPercent: totalScopedCpuPercent } : {}),
+            ...(totalScopedMemoryMb > 0 ? { memoryMb: totalScopedMemoryMb } : {}),
+            ...(systemMetrics.vram_mb > 0 ? { vramMb: systemMetrics.vram_mb } : {}),
+        },
+    });
+    const activitySummary = envelope.metadata.activitySummary;
+    if (activitySummary && typeof activitySummary === 'object' && !Array.isArray(activitySummary)) {
+        const summaryRecord = activitySummary;
+        summaryRecord.actors = scopedObservations.map((observation) => {
+            const details = observation.details && typeof observation.details === 'object' && !Array.isArray(observation.details)
+                ? observation.details
+                : null;
+            const hosts = Array.isArray(details?.hosts) ? details.hosts : [];
+            const observationModelLabels = Array.isArray(details?.modelLabels)
+                ? details.modelLabels.filter((value) => typeof value === 'string' && value.trim().length > 0)
+                : [];
+            return {
+                label: observation.label,
+                name: observation.label,
+                host: typeof hosts[0] === 'string' ? hosts[0] : 'cli',
+                primaryRole: typeof details?.primaryRole === 'string' ? details.primaryRole : 'observer',
+                ...(observationModelLabels[0] ? { model: observationModelLabels[0] } : {}),
+                activeProcessCount: observation.activeProcessCount,
+                helperProcessCount: observation.helperProcessCount,
+            };
+        });
+        summaryRecord.actorCount = scopedObservations.length;
+        summaryRecord.modelLabels = modelLabels;
+        summaryRecord.folderLabels = folderLabels;
+        summaryRecord.folderCount = folderLabels.length;
+        summaryRecord.resources = {
+            accuracy: resourceAccuracy,
+            ...(totalScopedCpuPercent > 0 ? { cpuPercent: Math.round(totalScopedCpuPercent * 100) / 100 } : {}),
+            ...(totalScopedMemoryMb > 0 ? { memoryMb: Math.round(totalScopedMemoryMb * 100) / 100 } : {}),
+            ...(systemMetrics.vram_mb > 0 ? { vramMb: systemMetrics.vram_mb } : {}),
+            note: [
+                totalScopedCpuPercent > 0 || totalScopedMemoryMb > 0
+                    ? 'CPU and memory are aggregated from repo-scoped process samples.'
+                    : null,
+                systemMetrics.vram_mb > 0
+                    ? 'VRAM is sampled from the local GPU device.'
+                    : null,
+            ].filter(Boolean).join(' '),
+        };
+    }
+    const runId = `runtime-observer-${Date.now()}`;
+    const steps = [
+        ...envelope.steps,
+        ...(0, runtime_observer_1.buildRuntimeObservationSteps)(runId, scopedObservations, {
+            observedAt,
+            provider: 'forkit-connect',
+            model: modelLabels[0] ?? 'runtime-observer-v1',
+        }),
+    ];
+    const metadata = {
+        ...envelope.metadata,
+        safe_metadata_only: true,
+        observedTooling: scopedObservations.map((item) => compactObservationForMetadata(item, 'active')),
+        ambientTooling: ambientObservations.map((item) => compactObservationForMetadata(item, 'ambient')).slice(0, 3),
+        observedToolCount: observations.length,
+        scopedToolCount: scopedObservations.length,
+        ambientToolCount: ambientObservations.length,
+        observationRuntimeRoot: repo.rootPath || repo.cwd,
+        observationRelativeEntrypoint: repo.relativeCwd || '.',
+    };
+    const fingerprint = hashObservationFingerprint({
+        repoRoot: repo.rootPath || repo.cwd,
+        relativePath: repo.relativeCwd || '.',
+        subjectId: runtimeContext?.subjectId ?? null,
+        worktreeId: runtimeContext?.worktreeId ?? null,
+        scopedObservations: scopedObservations.map((item) => compactObservationForMetadata(item, 'active')),
+        threads: activityThreads.map((thread) => ({
+            provider: thread.provider,
+            actorLabel: thread.actorLabel,
+            threadLabel: thread.threadLabel,
+            threadId: thread.threadId ?? null,
+            lastActiveAt: thread.lastActiveAt ?? null,
+        })),
+        modelLabels,
+        folderLabels,
+        fileLabels,
+        scopeFileLabels,
+    });
+    return {
+        accepted: true,
+        reason: null,
+        gaid: options.gaid,
+        runId,
+        observedAt,
+        repoRoot: repo.rootPath || repo.cwd,
+        relativePath: repo.relativeCwd || '.',
+        runtimeContext,
+        scopedObservations,
+        ambientObservations,
+        modelLabels,
+        folderLabels,
+        summary: envelope.summary,
+        metadata,
+        steps,
+        fingerprint,
+    };
+}
+async function emitCollectedRuntimeObservation(service, collection, options) {
+    return await service.emitRuntimeRunLog({
+        gaid: collection.gaid,
+        apiKey: options?.apiKey ?? null,
+        provider: 'forkit-connect',
+        model: collection.modelLabels[0] ?? 'runtime-observer-v1',
+        serviceName: 'Forkit Connect Observer',
+        serviceKind: 'custom',
+        runId: collection.runId ?? `runtime-observer-${Date.now()}`,
+        status: 'completed',
+        startedAt: collection.observedAt,
+        endedAt: collection.observedAt,
+        summary: collection.summary,
+        metadata: collection.metadata,
+        steps: collection.steps,
+    });
+}
+async function observeRegisteredRuntimeTargets(service, options) {
+    const targets = service.listRuntimeObserverTargets();
+    if (targets.length === 0) {
+        return { attempted: 0, emitted: 0, skipped: 0, idle: 0, failed: 0, checkedIn: 0 };
+    }
+    const processEntries = options?.processEntries ?? await (0, ps_list_loader_1.listProcesses)();
+    const minRepeatMs = Math.max(60_000, options?.minRepeatMs ?? 5 * 60 * 1000);
+    let emitted = 0;
+    let skipped = 0;
+    let idle = 0;
+    let failed = 0;
+    let checkedIn = 0;
+    for (const target of targets) {
+        try {
+            const collection = await collectRuntimeObservation({
+                gaid: target.runtime_gaid,
+                cwd: target.repo_root,
+                clientName: target.client_name,
+                commandLabel: 'daemon-observer',
+                processEntries,
+                target,
+            });
+            const persistedTarget = service.registerRuntimeObserverTarget({
+                gaid: target.runtime_gaid,
+                repoRoot: collection.repoRoot,
+                clientName: collection.runtimeContext?.clientName ?? target.client_name,
+                subjectId: collection.runtimeContext?.subjectId ?? target.subject_id,
+                worktreeId: collection.runtimeContext?.worktreeId ?? target.worktree_id,
+            });
+            const checkinResult = await emitRuntimeObserverCheckin(service, persistedTarget, collection);
+            const checkinBodyRecord = checkinResult.body && typeof checkinResult.body === 'object' && !Array.isArray(checkinResult.body)
+                ? checkinResult.body
+                : null;
+            if (!checkinResult.ok) {
+                service.updateRuntimeObserverTargetResult({
+                    gaid: target.runtime_gaid,
+                    observedAt: collection.observedAt,
+                    summary: buildObserverCheckinSummary(persistedTarget, collection),
+                    error: typeof checkinResult.body === 'string'
+                        ? checkinResult.body
+                        : checkinBodyRecord && typeof checkinBodyRecord.error === 'string'
+                            ? checkinBodyRecord.error
+                            : `runtime_observer_checkin_failed_${checkinResult.status || 'local'}`,
+                });
+                failed += 1;
+                continue;
+            }
+            checkedIn += 1;
+            if (!collection.accepted) {
+                service.updateRuntimeObserverTargetResult({
+                    gaid: target.runtime_gaid,
+                    observedAt: collection.observedAt,
+                    summary: buildObserverCheckinSummary(persistedTarget, collection),
+                    error: null,
+                });
+                idle += 1;
+                continue;
+            }
+            const previousEmittedAt = persistedTarget.last_emitted_at ? Date.parse(persistedTarget.last_emitted_at) : NaN;
+            const nextObservedAt = Date.parse(collection.observedAt);
+            const unchanged = persistedTarget.last_fingerprint && collection.fingerprint && persistedTarget.last_fingerprint === collection.fingerprint;
+            const withinCooldown = Number.isFinite(previousEmittedAt) && Number.isFinite(nextObservedAt) && (nextObservedAt - previousEmittedAt) < minRepeatMs;
+            if (unchanged && withinCooldown) {
+                service.updateRuntimeObserverTargetResult({
+                    gaid: target.runtime_gaid,
+                    observedAt: collection.observedAt,
+                    fingerprint: collection.fingerprint,
+                    summary: collection.summary,
+                    error: null,
+                });
+                skipped += 1;
+                continue;
+            }
+            const result = await emitCollectedRuntimeObservation(service, collection);
+            const bodyRecord = result.body && typeof result.body === 'object' && !Array.isArray(result.body)
+                ? result.body
+                : null;
+            if (!result.ok) {
+                service.updateRuntimeObserverTargetResult({
+                    gaid: target.runtime_gaid,
+                    observedAt: collection.observedAt,
+                    fingerprint: collection.fingerprint,
+                    summary: collection.summary,
+                    error: typeof result.body === 'string'
+                        ? result.body
+                        : bodyRecord && typeof bodyRecord.error === 'string'
+                            ? bodyRecord.error
+                            : `runtime_observer_emit_failed_${result.status || 'local'}`,
+                });
+                failed += 1;
+                continue;
+            }
+            service.updateRuntimeObserverTargetResult({
+                gaid: target.runtime_gaid,
+                observedAt: collection.observedAt,
+                emittedAt: collection.observedAt,
+                fingerprint: collection.fingerprint,
+                summary: collection.summary,
+                error: null,
+            });
+            emitted += 1;
+        }
+        catch (error) {
+            service.updateRuntimeObserverTargetResult({
+                gaid: target.runtime_gaid,
+                observedAt: new Date().toISOString(),
+                error: error instanceof Error ? error.message : 'runtime_observer_failed',
+            });
+            failed += 1;
+        }
+    }
+    return {
+        attempted: targets.length,
+        emitted,
+        skipped,
+        idle,
+        failed,
+        checkedIn,
+    };
+}
+//# sourceMappingURL=runtime-observation-runner.js.map

package/dist/v1/runtime-observer.d.ts

@@ -0,0 +1,50 @@
+import type { RepoDetectionResult } from './repo-discovery';
+import { type ProcessListEntry } from './process-scout';
+export type RuntimeObservedToolKey = 'antigravity' | 'cursor' | 'vscode' | 'claude' | 'anaconda' | 'jupyter' | 'codex';
+export interface RuntimeObservedTool {
+    key: RuntimeObservedToolKey;
+    label: string;
+    processCount: number;
+    activeProcessCount: number;
+    helperProcessCount: number;
+    scopedProcessCount: number;
+    ambientProcessCount: number;
+    detectedBy: Array<'binary' | 'agent_signature' | 'repo_scope' | 'process_cwd'>;
+    exampleProcesses: string[];
+    scoped: boolean;
+    cpuPercent?: number | null;
+    memoryMb?: number | null;
+    details?: Record<string, unknown>;
+}
+export interface RuntimeObservationStepLog extends Record<string, unknown> {
+    stepId: string;
+    parentRunId: string;
+    sequence: number;
+    stepKind: 'custom';
+    title: string;
+    status: 'completed';
+    provider: string;
+    model: string;
+    startedAt: string;
+    endedAt: string;
+    summary: string;
+    toolCalls: [];
+    metadata: Record<string, unknown>;
+}
+interface ClaudeLocalState {
+    trustedFolders: string[];
+    trackedWorktreePaths: string[];
+}
+export declare function detectActiveRuntimeTooling(repo: RepoDetectionResult, processEntries: ProcessListEntry[], options?: {
+    processCwdLookup?: (pid: number) => string | null;
+    claudeState?: ClaudeLocalState | null;
+}): RuntimeObservedTool[];
+export declare function extractObservedFolderLabels(repo: RepoDetectionResult, observations: RuntimeObservedTool[]): string[];
+export declare function extractObservedModelLabels(observations: RuntimeObservedTool[]): string[];
+export declare function buildRuntimeObservationSteps(runId: string, observations: RuntimeObservedTool[], options?: {
+    observedAt?: string | null;
+    provider?: string | null;
+    model?: string | null;
+}): RuntimeObservationStepLog[];
+export {};
+//# sourceMappingURL=runtime-observer.d.ts.map