forkit-connect 0.1.4 → 0.1.6

package/dist/v1/runtime-activity.js

@@ -0,0 +1,388 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRuntimeActivityMetadata = buildRuntimeActivityMetadata;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const MAX_ACTIVITY_ACTORS = 6;
+const MAX_ACTIVITY_TASKS = 6;
+const MAX_ACTIVITY_FILES = 12;
+const MAX_ACTIVITY_FOLDERS = 6;
+const MAX_LABEL_LENGTH = 160;
+const MAX_TASK_TITLE_LENGTH = 120;
+const MAX_SUMMARY_LENGTH = 4000;
+const RUNTIME_PROJECT_SUBJECT_VERSION = 'runtime.subject.v1';
+function normalizeLabel(value, maxLength = MAX_LABEL_LENGTH) {
+    const normalized = String(value || '').trim().replace(/\s+/g, ' ');
+    if (!normalized)
+        return null;
+    return normalized.slice(0, maxLength);
+}
+function dedupeBoundedLabels(values, maxItems, maxLength = MAX_LABEL_LENGTH) {
+    const result = [];
+    const seen = new Set();
+    for (const value of values) {
+        const normalized = normalizeLabel(value, maxLength);
+        if (!normalized)
+            continue;
+        const key = normalized.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(normalized);
+        if (result.length >= maxItems)
+            break;
+    }
+    return result;
+}
+function readFiniteNumber(value) {
+    const numeric = typeof value === 'number' ? value : Number(value);
+    return Number.isFinite(numeric) ? numeric : null;
+}
+function normalizeRelativeLabel(value, cwd, rootPath, entrypointRelativePath) {
+    const raw = String(value || '').trim();
+    if (!raw)
+        return null;
+    const normalizedRaw = raw.replace(/\\/g, '/');
+    const preferRepoRoot = Boolean(rootPath
+        && entrypointRelativePath
+        && (normalizedRaw === entrypointRelativePath || normalizedRaw.startsWith(`${entrypointRelativePath}/`)));
+    const resolved = (() => {
+        if (node_path_1.default.isAbsolute(raw)) {
+            return node_path_1.default.resolve(raw);
+        }
+        const cwdCandidate = node_path_1.default.resolve(cwd, raw);
+        const repoCandidate = rootPath ? node_path_1.default.resolve(rootPath, raw) : null;
+        if (repoCandidate && node_fs_1.default.existsSync(repoCandidate) && !node_fs_1.default.existsSync(cwdCandidate)) {
+            return repoCandidate;
+        }
+        if (node_fs_1.default.existsSync(cwdCandidate) && (!repoCandidate || !node_fs_1.default.existsSync(repoCandidate))) {
+            return cwdCandidate;
+        }
+        if (preferRepoRoot && repoCandidate) {
+            return repoCandidate;
+        }
+        return cwdCandidate;
+    })();
+    if (rootPath) {
+        const relative = node_path_1.default.relative(rootPath, resolved).replace(/\\/g, '/');
+        if (!relative || relative.startsWith('..'))
+            return null;
+        return normalizeLabel(relative);
+    }
+    return normalizeLabel(node_path_1.default.basename(resolved));
+}
+function deriveFolderLabelsFromFiles(files) {
+    const folders = [];
+    const seen = new Set();
+    for (const file of files) {
+        const dirname = node_path_1.default.posix.dirname(file);
+        if (!dirname || dirname === '.' || seen.has(dirname))
+            continue;
+        seen.add(dirname);
+        folders.push(dirname);
+        if (folders.length >= MAX_ACTIVITY_FOLDERS)
+            break;
+    }
+    return folders;
+}
+function collapseFolderLabels(labels) {
+    const result = [];
+    for (const label of labels) {
+        if (result.some((existing) => label === existing || label.startsWith(`${existing}/`))) {
+            continue;
+        }
+        result.push(label);
+        if (result.length >= MAX_ACTIVITY_FOLDERS)
+            break;
+    }
+    return result;
+}
+function buildWorktreeId(rootPath, repoSlug) {
+    return (0, node_crypto_1.createHash)('sha256')
+        .update(`${repoSlug || 'local'}:${rootPath}`)
+        .digest('hex')
+        .slice(0, 16);
+}
+function hashHex(value) {
+    return (0, node_crypto_1.createHash)('sha256').update(value, 'utf8').digest('hex');
+}
+function slugifyLabel(value, maxLength = 80) {
+    const normalized = value
+        .trim()
+        .replace(/[\\/]+/g, '-')
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/-{2,}/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return (normalized || 'runtime').slice(0, maxLength);
+}
+function fallbackTaskLabel(summary) {
+    const normalized = normalizeLabel(summary, MAX_TASK_TITLE_LENGTH);
+    if (!normalized)
+        return [];
+    return [normalized];
+}
+function normalizeActivityThreads(threads) {
+    if (!Array.isArray(threads))
+        return [];
+    const result = [];
+    const seen = new Set();
+    for (const thread of threads) {
+        if (!thread || typeof thread !== 'object')
+            continue;
+        const title = normalizeLabel(thread.title, MAX_TASK_TITLE_LENGTH);
+        if (!title)
+            continue;
+        const taskId = normalizeLabel(thread.taskId, 64);
+        const key = `${taskId || title}`.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push({
+            title,
+            ...(taskId ? { taskId } : {}),
+            ...(normalizeLabel(thread.openedAt, 64) ? { openedAt: normalizeLabel(thread.openedAt, 64) } : {}),
+            ...(normalizeLabel(thread.lastActiveAt, 64) ? { lastActiveAt: normalizeLabel(thread.lastActiveAt, 64) } : {}),
+            ...(normalizeLabel(thread.provider, 40) ? { provider: normalizeLabel(thread.provider, 40) } : {}),
+            ...(normalizeLabel(thread.actorLabel, 40) ? { actorLabel: normalizeLabel(thread.actorLabel, 40) } : {}),
+            ...(normalizeLabel(thread.workspaceHost, 20) ? { workspaceHost: normalizeLabel(thread.workspaceHost, 20) } : {}),
+            ...(normalizeLabel(thread.folderScope, 96) ? { folderScope: normalizeLabel(thread.folderScope, 96) } : {}),
+        });
+        if (result.length >= MAX_ACTIVITY_TASKS)
+            break;
+    }
+    return result;
+}
+function buildStepTitle(actorLabels, taskLabels) {
+    const firstTask = taskLabels[0];
+    if (taskLabels.length === 1 && firstTask)
+        return firstTask;
+    const firstActor = actorLabels[0];
+    if (actorLabels.length === 1 && firstActor)
+        return `${firstActor} activity observed`.slice(0, 255);
+    return 'Runtime activity observed';
+}
+function buildNarrativeSummary(input) {
+    const lead = input.actorLabels.length === 1
+        ? `${input.actorLabels[0]} active`
+        : input.actorLabels.length > 1
+            ? `${input.actorLabels.length} actors active`
+            : null;
+    const taskPart = input.taskLabels.length === 1
+        ? input.taskLabels[0]
+        : input.taskLabels.length > 1
+            ? `${input.taskLabels.length} tasks`
+            : null;
+    const repoPart = input.repoRootLabel ? `in ${input.repoRootLabel}` : null;
+    const filePart = input.fileCount > 0 ? `${input.fileCount} files touched` : null;
+    const scopeFilePart = input.fileCount === 0 && input.scopeFileCount > 0 ? `${input.scopeFileCount} files in scope` : null;
+    const modelPart = input.modelLabels.length === 1
+        ? `model ${input.modelLabels[0]}`
+        : input.modelLabels.length > 1
+            ? `${input.modelLabels.length} models`
+            : null;
+    const summary = [lead, taskPart, repoPart, filePart || scopeFilePart, modelPart]
+        .filter((value) => Boolean(value))
+        .join(' · ')
+        .slice(0, MAX_SUMMARY_LENGTH);
+    return summary || null;
+}
+function buildRuntimeActivityMetadata(input) {
+    const repoRootLabel = input.repo.rootPath ? normalizeLabel(node_path_1.default.basename(input.repo.rootPath)) : null;
+    const entrypointRelativePath = normalizeLabel(input.repo.relativeCwd || '.', 255) || '.';
+    const normalizedThreads = normalizeActivityThreads(input.activityThreads);
+    const explicitFiles = dedupeBoundedLabels((input.fileLabels || [])
+        .map((value) => normalizeRelativeLabel(value, input.cwd, input.repo.rootPath, input.repo.relativeCwd))
+        .filter((value) => Boolean(value)), MAX_ACTIVITY_FILES);
+    const allFiles = explicitFiles;
+    const scopeFiles = dedupeBoundedLabels((input.scopeFileLabels || [])
+        .map((value) => normalizeRelativeLabel(value, input.cwd, input.repo.rootPath, input.repo.relativeCwd))
+        .filter((value) => Boolean(value)), MAX_ACTIVITY_FILES);
+    const explicitFolders = dedupeBoundedLabels((input.folderLabels || [])
+        .map((value) => normalizeRelativeLabel(value, input.cwd, input.repo.rootPath, input.repo.relativeCwd))
+        .filter((value) => Boolean(value)), MAX_ACTIVITY_FOLDERS);
+    const derivedFolders = explicitFolders.length > 0
+        ? explicitFolders
+        : dedupeBoundedLabels([
+            input.repo.relativeCwd,
+            ...deriveFolderLabelsFromFiles(explicitFiles),
+        ], MAX_ACTIVITY_FOLDERS);
+    const folderLabels = collapseFolderLabels(explicitFolders.length > 0 ? explicitFolders : derivedFolders);
+    const actorLabels = dedupeBoundedLabels([
+        ...(input.actorLabels || []),
+        ...(input.includeServiceNameAsActor === false ? [] : [input.serviceName]),
+    ], MAX_ACTIVITY_ACTORS);
+    const taskLabels = dedupeBoundedLabels((input.taskLabels && input.taskLabels.length > 0
+        ? input.taskLabels
+        : normalizedThreads.length > 0
+            ? normalizedThreads.map((thread) => thread.title)
+            : fallbackTaskLabel(input.summary ?? null)).map((value) => normalizeLabel(value, MAX_TASK_TITLE_LENGTH)), MAX_ACTIVITY_TASKS, MAX_TASK_TITLE_LENGTH);
+    const modelLabels = dedupeBoundedLabels([...(input.modelLabels || []), input.model], MAX_ACTIVITY_TASKS);
+    const fileCount = explicitFiles.length;
+    const scopeFileCount = scopeFiles.length;
+    const activitySummary = buildNarrativeSummary({
+        actorLabels,
+        taskLabels,
+        fileCount,
+        scopeFileCount,
+        repoRootLabel,
+        modelLabels,
+    });
+    const metadata = {
+        sourceSurface: 'connect_assisted',
+    };
+    if (input.repo.isGitRepo && input.repo.rootPath && input.repo.headCommit) {
+        const repoRootFingerprint = hashHex(`repo-root:${input.repo.rootPath}`);
+        const preferredRemote = input.repo.preferredRemote?.fetchUrl || input.repo.preferredRemote?.pushUrl || input.repo.repoSlug || '';
+        const repoRemoteFingerprint = preferredRemote ? hashHex(`repo-remote:${preferredRemote}`) : undefined;
+        const canonicalWorktreeId = normalizeLabel(input.stableWorktreeId, 120)
+            || slugifyLabel(`${repoRootLabel || 'runtime'}-${buildWorktreeId(input.repo.rootPath, input.repo.repoSlug)}`, 120);
+        const subjectSeed = [repoRootFingerprint, canonicalWorktreeId, entrypointRelativePath].join('|');
+        const subjectId = normalizeLabel(input.stableSubjectId, 160)
+            || `subj_${slugifyLabel(repoRootLabel || 'runtime', 48)}_${hashHex(subjectSeed).slice(0, 12)}`;
+        metadata.projectSubject = {
+            schemaVersion: RUNTIME_PROJECT_SUBJECT_VERSION,
+            subjectType: 'git_worktree',
+            subjectId,
+            subjectLabel: normalizeLabel(input.clientName || repoRootLabel || 'runtime', 160),
+            repoRootName: normalizeLabel(repoRootLabel || 'runtime', 160),
+            repoRootFingerprint,
+            ...(repoRemoteFingerprint ? { repoRemoteFingerprint } : {}),
+            worktreeId: canonicalWorktreeId,
+            branch: normalizeLabel(input.repo.branch || 'detached', 160),
+            commit: normalizeLabel(input.repo.headCommit, 64),
+            dirty: input.repo.dirty === true,
+            entrypointRelativePath,
+            commandLabel: normalizeLabel(input.commandLabel || `${input.serviceName} session`, 255),
+            sourceSurface: 'connect_assisted',
+        };
+    }
+    if (input.clientName) {
+        metadata.runtimeContext = {
+            clientName: normalizeLabel(input.clientName),
+        };
+    }
+    if (fileCount > 0) {
+        metadata.fileImpact = {
+            count: fileCount,
+            files: allFiles,
+        };
+    }
+    const resourceSummary = {};
+    const cpuPercent = readFiniteNumber(input.resources?.cpuPercent);
+    const memoryMb = readFiniteNumber(input.resources?.memoryMb);
+    const vramMb = readFiniteNumber(input.resources?.vramMb);
+    if (cpuPercent !== null && cpuPercent >= 0)
+        resourceSummary.cpuPercent = cpuPercent;
+    if (memoryMb !== null && memoryMb >= 0)
+        resourceSummary.memoryMb = memoryMb;
+    if (vramMb !== null && vramMb >= 0)
+        resourceSummary.vramMb = vramMb;
+    metadata.activitySummary = {
+        actorCount: actorLabels.length,
+        taskCount: taskLabels.length,
+        folderCount: folderLabels.length || (repoRootLabel ? 1 : 0),
+        ...(fileCount > 0 ? { fileCount } : {}),
+        ...(scopeFileCount > 0 ? { scopeFileCount } : {}),
+        ...(modelLabels.length > 0 ? { modelLabels } : {}),
+        ...(folderLabels.length > 0 ? { folderLabels } : {}),
+        ...(allFiles.length > 0 ? { fileLabels: allFiles } : {}),
+        ...(scopeFiles.length > 0 ? { scopeFileLabels: scopeFiles } : {}),
+        actors: actorLabels.map((label) => ({
+            label,
+            name: label,
+            host: 'cli',
+            primaryRole: normalizeLabel(input.serviceKind || 'custom'),
+            ...(modelLabels[0] ? { model: modelLabels[0] } : {}),
+            activeProcessCount: 1,
+            helperProcessCount: 0,
+        })),
+        threads: (normalizedThreads.length > 0
+            ? normalizedThreads.map((thread) => ({
+                title: thread.title,
+                taskTitle: thread.title,
+                taskId: thread.taskId ?? (0, node_crypto_1.createHash)('sha1').update(thread.title).digest('hex').slice(0, 12),
+                openedAt: thread.openedAt ?? input.startedAt,
+                lastActiveAt: thread.lastActiveAt ?? (input.endedAt || input.startedAt),
+                ...(thread.provider ? { provider: thread.provider } : {}),
+                ...(thread.actorLabel ? { actorLabel: thread.actorLabel } : {}),
+                ...(thread.workspaceHost ? { workspaceHost: thread.workspaceHost } : {}),
+                ...(thread.folderScope ? { folderScope: thread.folderScope } : {}),
+            }))
+            : taskLabels.map((title, index) => ({
+                title,
+                taskTitle: title,
+                taskId: (0, node_crypto_1.createHash)('sha1').update(`${title}:${index}`).digest('hex').slice(0, 12),
+                openedAt: input.startedAt,
+                lastActiveAt: input.endedAt || input.startedAt,
+            }))),
+        ...(Object.keys(resourceSummary).length > 0 ? { resources: resourceSummary } : {}),
+    };
+    if (taskLabels.length > 0) {
+        metadata.activityThreads = normalizedThreads.length > 0
+            ? normalizedThreads.map((thread) => ({
+                title: thread.title,
+                taskTitle: thread.title,
+                taskId: thread.taskId ?? (0, node_crypto_1.createHash)('sha1').update(`${thread.title}:thread`).digest('hex').slice(0, 12),
+                openedAt: thread.openedAt ?? input.startedAt,
+                lastActiveAt: thread.lastActiveAt ?? (input.endedAt || input.startedAt),
+                ...(thread.provider ? { provider: thread.provider } : {}),
+                ...(thread.actorLabel ? { actorLabel: thread.actorLabel } : {}),
+                ...(thread.workspaceHost ? { workspaceHost: thread.workspaceHost } : {}),
+                ...(thread.folderScope ? { folderScope: thread.folderScope } : {}),
+            }))
+            : taskLabels.map((title, index) => ({
+                title,
+                taskTitle: title,
+                taskId: (0, node_crypto_1.createHash)('sha1').update(`${title}:${index}:thread`).digest('hex').slice(0, 12),
+                openedAt: input.startedAt,
+                lastActiveAt: input.endedAt || input.startedAt,
+            }));
+    }
+    const totalTokens = readFiniteNumber(input.totalTokens);
+    const latencyMs = readFiniteNumber(input.latencyMs);
+    const stepUsage = {};
+    if (readFiniteNumber(input.promptTokens) !== null)
+        stepUsage.promptTokens = Math.max(0, Math.trunc(Number(input.promptTokens)));
+    if (readFiniteNumber(input.completionTokens) !== null)
+        stepUsage.completionTokens = Math.max(0, Math.trunc(Number(input.completionTokens)));
+    if (readFiniteNumber(input.cachedPromptTokens) !== null)
+        stepUsage.cachedPromptTokens = Math.max(0, Math.trunc(Number(input.cachedPromptTokens)));
+    if (readFiniteNumber(input.reasoningTokens) !== null)
+        stepUsage.reasoningTokens = Math.max(0, Math.trunc(Number(input.reasoningTokens)));
+    if (totalTokens !== null && totalTokens >= 0)
+        stepUsage.totalTokens = Math.trunc(totalTokens);
+    if (latencyMs !== null && latencyMs >= 0)
+        stepUsage.latencyMs = Math.trunc(latencyMs);
+    if (Object.keys(stepUsage).length > 0)
+        stepUsage.currency = 'USD';
+    const steps = [];
+    if (activitySummary) {
+        steps.push({
+            stepId: `observe-${(0, node_crypto_1.createHash)('sha1').update(activitySummary).digest('hex').slice(0, 12)}`,
+            sequence: 0,
+            stepKind: 'custom',
+            title: buildStepTitle(actorLabels, taskLabels),
+            status: normalizeLabel(input.status || 'completed') || 'completed',
+            provider: normalizeLabel(input.provider),
+            model: modelLabels[0] || normalizeLabel(input.model),
+            startedAt: input.startedAt,
+            ...(input.endedAt ? { endedAt: input.endedAt } : {}),
+            ...(Object.keys(stepUsage).length > 0 ? { usage: stepUsage } : {}),
+            summary: activitySummary,
+            metadata: {
+                sourceSurface: 'connect_assisted',
+                safe_metadata_only: true,
+            },
+        });
+    }
+    return {
+        metadata,
+        steps,
+        summary: normalizeLabel(input.summary, MAX_SUMMARY_LENGTH) || activitySummary,
+    };
+}
+//# sourceMappingURL=runtime-activity.js.map

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

@@ -0,0 +1,18 @@
+export declare const RUNTIME_CONTEXT_SCHEMA_VERSION = "forkit.runtime-context.v1";
+export interface RuntimeContextRecord {
+    schemaVersion: typeof RUNTIME_CONTEXT_SCHEMA_VERSION;
+    clientName?: string;
+    subjectId?: string;
+    worktreeId?: string;
+}
+export declare function buildRuntimeContextRecord(options?: {
+    existing?: RuntimeContextRecord | null;
+    clientName?: string | null;
+    defaultLabel?: string | null;
+}): RuntimeContextRecord;
+export declare function readRuntimeContext(repoRoot: string): RuntimeContextRecord | null;
+export declare function ensureRuntimeContext(repoRoot: string, options?: {
+    clientName?: string | null;
+    defaultLabel?: string | null;
+}): RuntimeContextRecord | null;
+//# sourceMappingURL=runtime-context.d.ts.map

package/dist/v1/runtime-context.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_CONTEXT_SCHEMA_VERSION = void 0;
+exports.buildRuntimeContextRecord = buildRuntimeContextRecord;
+exports.readRuntimeContext = readRuntimeContext;
+exports.ensureRuntimeContext = ensureRuntimeContext;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.RUNTIME_CONTEXT_SCHEMA_VERSION = 'forkit.runtime-context.v1';
+function normalizeText(value, maxLength) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim().replace(/\s+/g, ' ');
+    if (!normalized)
+        return null;
+    return normalized.slice(0, maxLength);
+}
+function slugifyLabel(value, maxLength = 48) {
+    const normalized = value
+        .trim()
+        .replace(/[\\/]+/g, '-')
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/-{2,}/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return (normalized || 'runtime').slice(0, maxLength);
+}
+function createStableId(prefix, label, size) {
+    const suffix = (0, node_crypto_1.randomUUID)().replace(/-/g, '').slice(0, size);
+    return `${prefix}_${slugifyLabel(label)}_${suffix}`;
+}
+function getRuntimeContextPath(repoRoot) {
+    return node_path_1.default.join(repoRoot, '.forkit', 'runtime-context.json');
+}
+function buildRuntimeContextRecord(options) {
+    const existing = options?.existing ?? null;
+    const preferredLabel = normalizeText(options?.clientName, 160)
+        || existing?.clientName
+        || normalizeText(options?.defaultLabel, 160)
+        || 'runtime';
+    return {
+        schemaVersion: exports.RUNTIME_CONTEXT_SCHEMA_VERSION,
+        ...(preferredLabel ? { clientName: preferredLabel } : {}),
+        subjectId: existing?.subjectId || createStableId('subj', preferredLabel, 12),
+        worktreeId: existing?.worktreeId || createStableId('wt', preferredLabel, 16),
+    };
+}
+function readRuntimeContext(repoRoot) {
+    const contextPath = getRuntimeContextPath(repoRoot);
+    if (!node_fs_1.default.existsSync(contextPath))
+        return null;
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(contextPath, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return null;
+        const record = parsed;
+        if (record.schemaVersion !== exports.RUNTIME_CONTEXT_SCHEMA_VERSION)
+            return null;
+        return {
+            schemaVersion: exports.RUNTIME_CONTEXT_SCHEMA_VERSION,
+            ...(normalizeText(record.clientName, 160) ? { clientName: normalizeText(record.clientName, 160) } : {}),
+            ...(normalizeText(record.subjectId, 160) ? { subjectId: normalizeText(record.subjectId, 160) } : {}),
+            ...(normalizeText(record.worktreeId, 120) ? { worktreeId: normalizeText(record.worktreeId, 120) } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function ensureRuntimeContext(repoRoot, options) {
+    const contextPath = getRuntimeContextPath(repoRoot);
+    const existing = readRuntimeContext(repoRoot);
+    const nextRecord = buildRuntimeContextRecord({
+        existing,
+        clientName: options?.clientName ?? null,
+        defaultLabel: options?.defaultLabel ?? slugifyLabel(node_path_1.default.basename(repoRoot), 80),
+    });
+    if (existing
+        && existing.clientName === nextRecord.clientName
+        && existing.subjectId === nextRecord.subjectId
+        && existing.worktreeId === nextRecord.worktreeId) {
+        return existing;
+    }
+    try {
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(contextPath), { recursive: true });
+        node_fs_1.default.writeFileSync(contextPath, `${JSON.stringify(nextRecord, null, 2)}\n`, 'utf8');
+        return nextRecord;
+    }
+    catch {
+        return existing;
+    }
+}
+//# sourceMappingURL=runtime-context.js.map

package/dist/v1/runtime-editor-activity.d.ts

@@ -0,0 +1,47 @@
+import type { RepoDetectionResult } from './repo-discovery';
+type WorkspaceHost = 'vscode' | 'cursor' | 'claude';
+export interface RuntimeEditorActivityThread {
+    provider: string;
+    actorLabel: string;
+    threadLabel: string;
+    threadId?: string;
+    createdAt?: string;
+    lastActiveAt?: string;
+    folderScope?: string;
+    workspaceHost: WorkspaceHost;
+}
+export interface RuntimeEditorActivitySnapshot {
+    threads: RuntimeEditorActivityThread[];
+    modelLabels: string[];
+    fileLabels: string[];
+    scopeFileLabels: string[];
+}
+type ClaudeSessionSummary = {
+    thread: RuntimeEditorActivityThread | null;
+    modelLabels: string[];
+    fileLabels: string[];
+};
+export declare function parseClaudeSessionJsonl(raw: string | null, options: {
+    folderScope?: string | null;
+    repoRoot?: string | null;
+}): ClaudeSessionSummary;
+export declare function parseEditorActivityThreadsBlob(raw: string | null, options: {
+    actorLabel: string;
+    providerTypes?: Set<string>;
+    providerLabel?: string | null;
+    folderScope?: string | null;
+    workspaceHost: WorkspaceHost;
+}): RuntimeEditorActivityThread[];
+export declare function parseCopilotChatSessionIndexBlob(raw: string | null, options: {
+    workspaceHost: WorkspaceHost;
+    folderScope?: string | null;
+}): RuntimeEditorActivityThread[];
+export declare function parseCopilotSelectedModelLabels(raw: string | null): string[];
+export declare function parseEditorOpenFileStateBlob(raw: string | null, options: {
+    repoRoot: string;
+}): string[];
+export declare function collectCodexEditorThreads(repo: RepoDetectionResult): RuntimeEditorActivityThread[];
+export declare function collectCopilotEditorActivity(repo: RepoDetectionResult): RuntimeEditorActivitySnapshot;
+export declare function collectClaudeProjectActivity(repo: RepoDetectionResult): RuntimeEditorActivitySnapshot;
+export {};
+//# sourceMappingURL=runtime-editor-activity.d.ts.map