vgxness 1.20.4 → 1.20.6

package/dist/storage/skills/repositories/skills.js

@@ -0,0 +1,1084 @@
+import { randomUUID } from 'node:crypto';
+export class SkillRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    register(input) {
+        const validation = validateSkill(input);
+        if (!validation.ok)
+            return validation;
+        const result = this.db.transaction(() => {
+            const existing = this.findByNaturalKey(input.project, input.scope, input.name);
+            const id = existing?.id ?? randomUUID();
+            const now = new Date().toISOString();
+            this.db.connection
+                .prepare(`
+        INSERT INTO skills(id, project, scope, name, description, created_at, updated_at)
+        VALUES (@id, @project, @scope, @name, @description, @createdAt, @updatedAt)
+        ON CONFLICT(project, scope, name) DO UPDATE SET
+          description=excluded.description,
+          updated_at=excluded.updated_at
+      `)
+                .run({
+                id,
+                project: input.project,
+                scope: input.scope,
+                name: input.name,
+                description: input.description,
+                createdAt: existing?.created_at ?? now,
+                updatedAt: now,
+            });
+            const read = this.getById(id);
+            if (!read.ok)
+                throw new Error(read.error.message);
+            return read.value;
+        });
+        return result;
+    }
+    addVersion(input) {
+        const validation = validateVersion(input);
+        if (!validation.ok)
+            return validation;
+        const result = this.db.transaction(() => {
+            const skill = this.getById(input.skillId);
+            if (!skill.ok)
+                throw new SkillRegistryValidationError(skill.error.message);
+            const existing = this.findVersion(input.skillId, input.version);
+            const id = existing?.id ?? randomUUID();
+            const now = new Date().toISOString();
+            const status = input.activate === true ? 'active' : (input.status ?? existing?.status ?? 'draft');
+            this.db.connection
+                .prepare(`
+        INSERT INTO skill_versions(id, skill_id, version, source_kind, source_path, source_url, source_inline_metadata_json, compatibility_json, status, created_at)
+        VALUES (@id, @skillId, @version, @sourceKind, @sourcePath, @sourceUrl, @sourceInlineMetadataJson, @compatibilityJson, @status, @createdAt)
+        ON CONFLICT(skill_id, version) DO UPDATE SET
+          source_kind=excluded.source_kind,
+          source_path=excluded.source_path,
+          source_url=excluded.source_url,
+          source_inline_metadata_json=excluded.source_inline_metadata_json,
+          compatibility_json=excluded.compatibility_json,
+          status=excluded.status
+      `)
+                .run({
+                id,
+                skillId: input.skillId,
+                version: input.version,
+                sourceKind: input.source.kind,
+                sourcePath: input.source.path ?? null,
+                sourceUrl: input.source.url ?? null,
+                sourceInlineMetadataJson: JSON.stringify(input.source.inlineMetadata ?? {}),
+                compatibilityJson: JSON.stringify(input.compatibility ?? {}),
+                status,
+                createdAt: existing?.created_at ?? now,
+            });
+            if (input.activate === true) {
+                this.db.connection.prepare('UPDATE skills SET current_version_id=?, updated_at=? WHERE id=?').run(id, now, input.skillId);
+            }
+            const read = this.getVersion(id);
+            if (!read.ok)
+                throw new Error(read.error.message);
+            return read.value;
+        });
+        if (!result.ok && result.error.cause instanceof SkillRegistryValidationError) {
+            return validationFailure(result.error.cause.message);
+        }
+        return result;
+    }
+    attach(input) {
+        const validation = validateAttachment(input);
+        if (!validation.ok)
+            return validation;
+        const result = this.db.transaction(() => {
+            const skill = this.getById(input.skillId);
+            if (!skill.ok)
+                throw new SkillRegistryValidationError(skill.error.message);
+            if (input.versionId !== undefined)
+                assertVersionBelongsToSkill(this.db, input.versionId, input.skillId);
+            const existing = this.db.connection
+                .prepare('SELECT * FROM skill_attachments WHERE skill_id=? AND target_type=? AND target_key=?')
+                .get(input.skillId, input.targetType, input.targetKey);
+            const id = existing?.id ?? randomUUID();
+            const now = new Date().toISOString();
+            this.db.connection
+                .prepare(`
+        INSERT INTO skill_attachments(id, skill_id, version_id, target_type, target_key, metadata_json, created_at)
+        VALUES (@id, @skillId, @versionId, @targetType, @targetKey, @metadataJson, @createdAt)
+        ON CONFLICT(skill_id, target_type, target_key) DO UPDATE SET
+          version_id=excluded.version_id,
+          metadata_json=excluded.metadata_json
+      `)
+                .run({
+                id,
+                skillId: input.skillId,
+                versionId: input.versionId ?? null,
+                targetType: input.targetType,
+                targetKey: input.targetKey,
+                metadataJson: JSON.stringify(input.metadata ?? {}),
+                createdAt: existing?.created_at ?? now,
+            });
+            const read = this.getAttachment(id);
+            if (!read.ok)
+                throw new Error(read.error.message);
+            return read.value;
+        });
+        if (!result.ok && result.error.cause instanceof SkillRegistryValidationError) {
+            return validationFailure(result.error.cause.message);
+        }
+        return result;
+    }
+    detach(skillId, targetType, targetKey) {
+        try {
+            const result = this.db.connection
+                .prepare('DELETE FROM skill_attachments WHERE skill_id=? AND target_type=? AND target_key=?')
+                .run(skillId, targetType, targetKey);
+            return ok({ detached: result.changes > 0 });
+        }
+        catch (cause) {
+            return fail('Failed to detach skill', cause);
+        }
+    }
+    recordUsage(input) {
+        const validation = validateUsage(input);
+        if (!validation.ok)
+            return validation;
+        const result = this.db.transaction(() => {
+            const skill = this.getById(input.skillId);
+            if (!skill.ok)
+                throw new SkillRegistryValidationError(skill.error.message);
+            if (input.versionId !== undefined)
+                assertVersionBelongsToSkill(this.db, input.versionId, input.skillId);
+            const id = randomUUID();
+            const now = new Date().toISOString();
+            this.db.connection
+                .prepare(`
+        INSERT INTO skill_usage_records(id, skill_id, version_id, run_id, target_type, target_key, outcome, notes, created_at, workflow, phase, provider_adapter, agent_id, intent_json, evidence_json)
+        VALUES (@id, @skillId, @versionId, @runId, @targetType, @targetKey, @outcome, @notes, @createdAt, @workflow, @phase, @providerAdapter, @agentId, @intentJson, @evidenceJson)
+      `)
+                .run({
+                id,
+                skillId: input.skillId,
+                versionId: input.versionId ?? null,
+                runId: input.runId ?? null,
+                targetType: input.targetType ?? null,
+                targetKey: input.targetKey ?? null,
+                outcome: input.outcome,
+                notes: input.notes ?? null,
+                createdAt: now,
+                workflow: input.workflow ?? null,
+                phase: input.phase ?? null,
+                providerAdapter: input.providerAdapter ?? null,
+                agentId: input.agentId ?? null,
+                intentJson: input.intent === undefined ? null : JSON.stringify(input.intent),
+                evidenceJson: input.evidence === undefined ? null : JSON.stringify(input.evidence),
+            });
+            const read = this.getUsage(id);
+            if (!read.ok)
+                throw new Error(read.error.message);
+            return read.value;
+        });
+        if (!result.ok && result.error.cause instanceof SkillRegistryValidationError) {
+            return validationFailure(result.error.cause.message);
+        }
+        return result;
+    }
+    recordActivation(input) {
+        const validation = validateActivation(input);
+        if (!validation.ok)
+            return validation;
+        const result = this.db.transaction(() => {
+            const skill = this.getById(input.skillId);
+            if (!skill.ok)
+                throw new SkillRegistryValidationError(skill.error.message);
+            if (input.versionId !== undefined)
+                assertVersionBelongsToSkill(this.db, input.versionId, input.skillId);
+            if (skill.value.project !== input.project || skill.value.scope !== input.scope)
+                throw new SkillRegistryValidationError('Skill does not belong to the requested project/scope');
+            const id = randomUUID();
+            const now = new Date().toISOString();
+            this.db.connection
+                .prepare(`
+        INSERT INTO skill_activation_records(id, project, scope, skill_id, version_id, run_id, agent_id, workflow, phase, provider_adapter, intent_json, reason, payload_metadata_json, created_at)
+        VALUES (@id, @project, @scope, @skillId, @versionId, @runId, @agentId, @workflow, @phase, @providerAdapter, @intentJson, @reason, @payloadMetadataJson, @createdAt)
+      `)
+                .run({
+                id,
+                project: input.project,
+                scope: input.scope,
+                skillId: input.skillId,
+                versionId: input.versionId ?? null,
+                runId: input.runId ?? null,
+                agentId: input.agentId ?? null,
+                workflow: input.workflow ?? null,
+                phase: input.phase ?? null,
+                providerAdapter: input.providerAdapter ?? null,
+                intentJson: input.intent === undefined ? null : JSON.stringify(input.intent),
+                reason: input.reason ?? null,
+                payloadMetadataJson: JSON.stringify(input.payloadMetadata ?? {}),
+                createdAt: now,
+            });
+            const read = this.getActivation(id);
+            if (!read.ok)
+                throw new Error(read.error.message);
+            return read.value;
+        });
+        if (!result.ok && result.error.cause instanceof SkillRegistryValidationError) {
+            return validationFailure(result.error.cause.message);
+        }
+        return result;
+    }
+    createDraft(input) {
+        const validation = validateCreateDraft(input);
+        if (!validation.ok)
+            return validation;
+        const result = this.db.transaction(() => {
+            const existing = this.findByNaturalKey(input.project, input.scope ?? 'project', input.name);
+            const skill = existing === undefined
+                ? this.register({ project: input.project, scope: input.scope ?? 'project', name: input.name, description: input.description })
+                : ok(mapSkill(existing));
+            if (!skill.ok)
+                throw new SkillRegistryValidationError(skill.error.message);
+            if (input.draftParentVersionId !== undefined)
+                assertVersionBelongsToSkill(this.db, input.draftParentVersionId, skill.value.id);
+            if (this.findVersion(skill.value.id, input.version) !== undefined)
+                throw new SkillRegistryValidationError(`Skill version already exists: ${input.version}`);
+            const now = new Date().toISOString();
+            const id = randomUUID();
+            this.db.connection
+                .prepare(`
+        INSERT INTO skill_versions(id, skill_id, version, source_kind, source_path, source_url, source_inline_metadata_json, compatibility_json, status, created_at, lifecycle_label, draft_parent_version_id, draft_revision, governance_json)
+        VALUES (@id, @skillId, @version, @sourceKind, @sourcePath, @sourceUrl, @sourceInlineMetadataJson, @compatibilityJson, 'draft', @createdAt, 'draft', @draftParentVersionId, 1, @governanceJson)
+      `)
+                .run({
+                id,
+                skillId: skill.value.id,
+                version: input.version,
+                sourceKind: input.source.kind,
+                sourcePath: input.source.path ?? null,
+                sourceUrl: input.source.url ?? null,
+                sourceInlineMetadataJson: JSON.stringify(input.source.inlineMetadata ?? {}),
+                compatibilityJson: JSON.stringify(input.compatibility ?? {}),
+                createdAt: now,
+                draftParentVersionId: input.draftParentVersionId ?? null,
+                governanceJson: JSON.stringify(input.governance ?? {}),
+            });
+            const version = this.getVersion(id);
+            if (!version.ok)
+                throw new Error(version.error.message);
+            const after = versionSnapshot(version.value);
+            const event = this.recordLifecycleEvent({
+                project: skill.value.project,
+                scope: skill.value.scope,
+                skillId: skill.value.id,
+                versionId: version.value.id,
+                eventType: 'draft-created',
+                actor: input.actor,
+                ...(input.runId === undefined ? {} : { runId: input.runId }),
+                ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+                ...(input.reason === undefined ? {} : { reason: input.reason }),
+                before: existing === undefined ? {} : { skillExisted: true, currentVersionId: existing.current_version_id ?? null },
+                after,
+                ...(input.evidence === undefined ? {} : { evidence: input.evidence }),
+            });
+            if (!event.ok)
+                throw new Error(event.error.message);
+            return { skill: skill.value, version: version.value, event: event.value };
+        });
+        if (!result.ok && result.error.cause instanceof SkillRegistryValidationError)
+            return validationFailure(result.error.cause.message);
+        return result;
+    }
+    updateDraft(input) {
+        const validation = validateUpdateDraft(input);
+        if (!validation.ok)
+            return validation;
+        const result = this.db.transaction(() => {
+            const skill = resolveSkillForMutation(this, input.project, input.scope ?? 'project', input.skillId, input.name);
+            const version = resolveVersionForMutation(this, skill.id, input.versionId, input.version);
+            if (version.status !== 'draft')
+                throw new SkillRegistryValidationError(`Cannot update ${version.status} skill versions; only draft versions can be updated`);
+            if (input.expectedDraftRevision !== undefined && (version.draftRevision ?? 0) !== input.expectedDraftRevision) {
+                throw new SkillRegistryValidationError(`Draft revision conflict: expected ${input.expectedDraftRevision}, found ${version.draftRevision ?? 0}`);
+            }
+            const before = versionSnapshot(version);
+            const nextRevision = (version.draftRevision ?? 0) + 1;
+            this.db.connection
+                .prepare(`
+        UPDATE skill_versions SET
+          source_kind=COALESCE(@sourceKind, source_kind),
+          source_path=@sourcePath,
+          source_url=@sourceUrl,
+          source_inline_metadata_json=COALESCE(@sourceInlineMetadataJson, source_inline_metadata_json),
+          compatibility_json=COALESCE(@compatibilityJson, compatibility_json),
+          draft_revision=@draftRevision,
+          governance_json=COALESCE(@governanceJson, governance_json)
+        WHERE id=@id
+      `)
+                .run({
+                id: version.id,
+                sourceKind: input.source?.kind ?? null,
+                sourcePath: input.source === undefined ? (version.source.path ?? null) : (input.source.path ?? null),
+                sourceUrl: input.source === undefined ? (version.source.url ?? null) : (input.source.url ?? null),
+                sourceInlineMetadataJson: input.source === undefined ? null : JSON.stringify(input.source.inlineMetadata ?? {}),
+                compatibilityJson: input.compatibility === undefined ? null : JSON.stringify(input.compatibility),
+                draftRevision: nextRevision,
+                governanceJson: input.governance === undefined ? null : JSON.stringify(input.governance),
+            });
+            const updated = this.getVersion(version.id);
+            if (!updated.ok)
+                throw new Error(updated.error.message);
+            const event = this.recordLifecycleEvent({
+                project: skill.project,
+                scope: skill.scope,
+                skillId: skill.id,
+                versionId: updated.value.id,
+                eventType: 'draft-updated',
+                actor: input.actor,
+                ...(input.runId === undefined ? {} : { runId: input.runId }),
+                ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+                ...(input.reason === undefined ? {} : { reason: input.reason }),
+                before,
+                after: versionSnapshot(updated.value),
+                ...(input.evidence === undefined ? {} : { evidence: input.evidence }),
+            });
+            if (!event.ok)
+                throw new Error(event.error.message);
+            return { skill, version: updated.value, event: event.value };
+        });
+        if (!result.ok && result.error.cause instanceof SkillRegistryValidationError)
+            return validationFailure(result.error.cause.message);
+        return result;
+    }
+    publishVersion(input) {
+        const validation = validatePublishVersion(input);
+        if (!validation.ok)
+            return validation;
+        const result = this.db.transaction(() => {
+            const skill = resolveSkillForMutation(this, input.project, input.scope ?? 'project', input.skillId, input.name);
+            const version = resolveVersionForMutation(this, skill.id, input.versionId, input.version);
+            if (version.status !== 'draft')
+                throw new SkillRegistryValidationError(`Cannot publish ${version.status} skill versions; only draft versions can be published`);
+            const before = { skill: { currentVersionId: skill.currentVersionId ?? null }, version: versionSnapshot(version) };
+            const previousCurrentVersionId = skill.currentVersionId ?? null;
+            const now = new Date().toISOString();
+            this.db.connection
+                .prepare(`
+        UPDATE skill_versions SET status='active', lifecycle_label='published', published_at=@publishedAt, published_by=@publishedBy, governance_json=COALESCE(@governanceJson, governance_json)
+        WHERE id=@id
+      `)
+                .run({
+                id: version.id,
+                publishedAt: now,
+                publishedBy: input.actor.id,
+                governanceJson: input.governance === undefined ? null : JSON.stringify(input.governance),
+            });
+            this.db.connection.prepare('UPDATE skills SET current_version_id=?, updated_at=? WHERE id=?').run(version.id, now, skill.id);
+            const updatedSkill = this.getById(skill.id);
+            if (!updatedSkill.ok)
+                throw new Error(updatedSkill.error.message);
+            const updated = this.getVersion(version.id);
+            if (!updated.ok)
+                throw new Error(updated.error.message);
+            const event = this.recordLifecycleEvent({
+                project: updatedSkill.value.project,
+                scope: updatedSkill.value.scope,
+                skillId: updatedSkill.value.id,
+                versionId: updated.value.id,
+                eventType: 'version-published',
+                actor: input.actor,
+                ...(input.runId === undefined ? {} : { runId: input.runId }),
+                ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+                reason: input.reason,
+                before,
+                after: { skill: { currentVersionId: updated.value.id }, version: versionSnapshot(updated.value) },
+                ...(input.evidence === undefined ? {} : { evidence: input.evidence }),
+            });
+            if (!event.ok)
+                throw new Error(event.error.message);
+            return { skill: updatedSkill.value, version: updated.value, event: event.value, previousCurrentVersionId };
+        });
+        if (!result.ok && result.error.cause instanceof SkillRegistryValidationError)
+            return validationFailure(result.error.cause.message);
+        return result;
+    }
+    getById(id) {
+        try {
+            const row = this.db.connection.prepare('SELECT * FROM skills WHERE id=?').get(id);
+            return row ? ok(mapSkill(row)) : missing(`Skill not found: ${id}`);
+        }
+        catch (cause) {
+            return fail('Failed to read skill', cause);
+        }
+    }
+    getByName(project, scope, name) {
+        try {
+            const row = this.findByNaturalKey(project, scope, name);
+            return row ? ok(mapSkill(row)) : missing(`Skill not found: ${project}/${scope}/${name}`);
+        }
+        catch (cause) {
+            return fail('Failed to read skill by name', cause);
+        }
+    }
+    getDetails(id) {
+        const skill = this.getById(id);
+        if (!skill.ok)
+            return skill;
+        const versions = this.listVersions(id);
+        if (!versions.ok)
+            return versions;
+        const attachments = this.listAttachments(id);
+        if (!attachments.ok)
+            return attachments;
+        const usage = this.listUsage(id);
+        if (!usage.ok)
+            return usage;
+        const details = { ...skill.value, versions: versions.value, attachments: attachments.value, usage: usage.value };
+        const currentVersion = versions.value.find((version) => version.id === skill.value.currentVersionId);
+        if (currentVersion !== undefined)
+            details.currentVersion = currentVersion;
+        return ok(details);
+    }
+    list(filters = {}) {
+        try {
+            const where = [];
+            const parameters = {};
+            if (filters.project !== undefined) {
+                where.push('project=@project');
+                parameters.project = filters.project;
+            }
+            if (filters.scope !== undefined) {
+                where.push('scope=@scope');
+                parameters.scope = filters.scope;
+            }
+            const rows = this.db.connection
+                .prepare(`
+        SELECT * FROM skills
+        ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
+        ORDER BY name ASC
+      `)
+                .all(parameters);
+            return ok(rows.map((row) => {
+                const summary = mapSkill(row);
+                if (summary.currentVersionId !== undefined) {
+                    const version = this.getVersion(summary.currentVersionId);
+                    if (version.ok)
+                        summary.currentVersion = version.value;
+                }
+                return summary;
+            }));
+        }
+        catch (cause) {
+            return fail('Failed to list skills', cause);
+        }
+    }
+    search(input) {
+        try {
+            const limit = normalizeLimit(input.limit);
+            const where = ['s.project=@project', 's.scope=@scope'];
+            const parameters = { project: input.project, scope: input.scope ?? 'project', limit };
+            if (input.query !== undefined && input.query.trim().length > 0) {
+                where.push('(s.name LIKE @query OR s.description LIKE @query OR cv.version LIKE @query)');
+                parameters.query = `%${input.query.trim()}%`;
+            }
+            if (input.status !== undefined) {
+                where.push('cv.status=@status');
+                parameters.status = input.status;
+            }
+            if (input.sourceKind !== undefined) {
+                where.push('cv.source_kind=@sourceKind');
+                parameters.sourceKind = input.sourceKind;
+            }
+            const rows = this.db.connection
+                .prepare(`
+        SELECT
+          s.*,
+          cv.id AS current_version_row_id,
+          cv.version AS current_version,
+          cv.source_kind AS current_source_kind,
+          cv.source_path AS current_source_path,
+          cv.source_url AS current_source_url,
+          cv.source_inline_metadata_json AS current_source_inline_metadata_json,
+          cv.status AS current_status,
+          (SELECT COUNT(*) FROM skill_versions sv WHERE sv.skill_id=s.id) AS version_count,
+          (SELECT COUNT(*) FROM skill_attachments sa WHERE sa.skill_id=s.id) AS attachment_count
+        FROM skills s
+        LEFT JOIN skill_versions cv ON cv.id=s.current_version_id
+        WHERE ${where.join(' AND ')}
+        ORDER BY s.name ASC, s.id ASC
+        LIMIT @limit
+      `)
+                .all(parameters);
+            return ok(rows.map(mapSearchItem));
+        }
+        catch (cause) {
+            return fail('Failed to search skills', cause);
+        }
+    }
+    countSearchMatches(input) {
+        try {
+            const where = ['s.project=@project', 's.scope=@scope'];
+            const parameters = { project: input.project, scope: input.scope ?? 'project' };
+            if (input.query !== undefined && input.query.trim().length > 0) {
+                where.push('(s.name LIKE @query OR s.description LIKE @query OR cv.version LIKE @query)');
+                parameters.query = `%${input.query.trim()}%`;
+            }
+            if (input.status !== undefined) {
+                where.push('cv.status=@status');
+                parameters.status = input.status;
+            }
+            if (input.sourceKind !== undefined) {
+                where.push('cv.source_kind=@sourceKind');
+                parameters.sourceKind = input.sourceKind;
+            }
+            const row = this.db.connection
+                .prepare(`SELECT COUNT(*) AS count FROM skills s LEFT JOIN skill_versions cv ON cv.id=s.current_version_id WHERE ${where.join(' AND ')}`)
+                .get(parameters);
+            return ok(row.count);
+        }
+        catch (cause) {
+            return fail('Failed to count skill search matches', cause);
+        }
+    }
+    getV2Counts(project, scope) {
+        try {
+            const versions = zeroVersionCounts();
+            for (const row of this.db.connection
+                .prepare(`SELECT sv.status AS status, COUNT(*) AS count FROM skill_versions sv JOIN skills s ON s.id=sv.skill_id WHERE s.project=? AND s.scope=? GROUP BY sv.status`)
+                .all(project, scope)) {
+                versions[row.status] = row.count;
+            }
+            const proposals = zeroProposalCounts();
+            for (const row of this.db.connection
+                .prepare(`SELECT p.status AS status, COUNT(*) AS count FROM skill_improvement_proposals p JOIN skills s ON s.id=p.skill_id WHERE s.project=? AND s.scope=? GROUP BY p.status`)
+                .all(project, scope)) {
+                proposals[row.status] = row.count;
+            }
+            const evaluationRequests = zeroEvaluationRequestCounts();
+            for (const row of this.db.connection
+                .prepare('SELECT status, COUNT(*) AS count FROM skill_evaluation_requests WHERE project=? AND scope=? GROUP BY status')
+                .all(project, scope)) {
+                evaluationRequests[row.status] = row.count;
+            }
+            const evaluationResults = zeroEvaluationResultCounts();
+            for (const row of this.db.connection
+                .prepare(`SELECT r.status AS status, COUNT(*) AS count FROM skill_evaluation_results r JOIN skill_evaluation_scenarios e ON e.id=r.scenario_id JOIN skills s ON s.id=e.skill_id WHERE s.project=? AND s.scope=? GROUP BY r.status`)
+                .all(project, scope)) {
+                evaluationResults[row.status] = row.count;
+            }
+            return ok({
+                versions,
+                attachments: countScoped(this.db, 'skill_attachments', project, scope),
+                usageRecords: countScoped(this.db, 'skill_usage_records', project, scope),
+                activationRecords: countDirectScoped(this.db, 'skill_activation_records', project, scope),
+                improvementProposals: proposals,
+                evaluationScenarios: countScoped(this.db, 'skill_evaluation_scenarios', project, scope),
+                evaluationRequests,
+                evaluationResults,
+                drafts: versions.draft,
+                deprecated: versions.deprecated,
+                archived: versions.archived,
+            });
+        }
+        catch (cause) {
+            return fail('Failed to count skill registry v2 records', cause);
+        }
+    }
+    listVersions(skillId) {
+        try {
+            const rows = this.db.connection.prepare('SELECT * FROM skill_versions WHERE skill_id=? ORDER BY created_at DESC, version DESC').all(skillId);
+            return ok(rows.map(mapVersion));
+        }
+        catch (cause) {
+            return fail('Failed to list skill versions', cause);
+        }
+    }
+    listAttachments(skillId) {
+        try {
+            const rows = this.db.connection.prepare('SELECT * FROM skill_attachments WHERE skill_id=? ORDER BY target_type ASC, target_key ASC').all(skillId);
+            return ok(rows.map(mapAttachment));
+        }
+        catch (cause) {
+            return fail('Failed to list skill attachments', cause);
+        }
+    }
+    listAttachmentsForTargets(targets) {
+        try {
+            if (targets.length === 0)
+                return ok([]);
+            const rows = [];
+            const read = this.db.connection.prepare('SELECT * FROM skill_attachments WHERE target_type=? AND target_key=? ORDER BY created_at ASC, id ASC');
+            for (const target of targets)
+                rows.push(...read.all(target.targetType, target.targetKey));
+            return ok(rows.map(mapAttachment));
+        }
+        catch (cause) {
+            return fail('Failed to list skill attachments for targets', cause);
+        }
+    }
+    listUsage(skillId) {
+        try {
+            const rows = this.db.connection.prepare('SELECT * FROM skill_usage_records WHERE skill_id=? ORDER BY created_at DESC').all(skillId);
+            return ok(rows.map(mapUsage));
+        }
+        catch (cause) {
+            return fail('Failed to list skill usage', cause);
+        }
+    }
+    getVersion(id) {
+        try {
+            const row = this.db.connection.prepare('SELECT * FROM skill_versions WHERE id=?').get(id);
+            return row ? ok(mapVersion(row)) : missing(`Skill version not found: ${id}`);
+        }
+        catch (cause) {
+            return fail('Failed to read skill version', cause);
+        }
+    }
+    getVersionBySkillVersion(skillId, version) {
+        try {
+            const row = this.findVersion(skillId, version);
+            return row ? ok(mapVersion(row)) : missing(`Skill version not found: ${version}`);
+        }
+        catch (cause) {
+            return fail('Failed to read skill version', cause);
+        }
+    }
+    getAttachment(id) {
+        try {
+            const row = this.db.connection.prepare('SELECT * FROM skill_attachments WHERE id=?').get(id);
+            return row ? ok(mapAttachment(row)) : missing(`Skill attachment not found: ${id}`);
+        }
+        catch (cause) {
+            return fail('Failed to read skill attachment', cause);
+        }
+    }
+    getUsage(id) {
+        try {
+            const row = this.db.connection.prepare('SELECT * FROM skill_usage_records WHERE id=?').get(id);
+            return row ? ok(mapUsage(row)) : missing(`Skill usage record not found: ${id}`);
+        }
+        catch (cause) {
+            return fail('Failed to read skill usage record', cause);
+        }
+    }
+    getActivation(id) {
+        try {
+            const row = this.db.connection.prepare('SELECT * FROM skill_activation_records WHERE id=?').get(id);
+            return row ? ok(mapActivation(row)) : missing(`Skill activation record not found: ${id}`);
+        }
+        catch (cause) {
+            return fail('Failed to read skill activation record', cause);
+        }
+    }
+    recordLifecycleEvent(input) {
+        try {
+            const id = randomUUID();
+            const now = new Date().toISOString();
+            this.db.connection
+                .prepare(`
+        INSERT INTO skill_lifecycle_events(id, project, scope, skill_id, version_id, event_type, actor_type, actor_id, run_id, agent_id, reason, before_json, after_json, evidence_json, created_at)
+        VALUES (@id, @project, @scope, @skillId, @versionId, @eventType, @actorType, @actorId, @runId, @agentId, @reason, @beforeJson, @afterJson, @evidenceJson, @createdAt)
+      `)
+                .run({
+                id,
+                project: input.project,
+                scope: input.scope,
+                skillId: input.skillId,
+                versionId: input.versionId ?? null,
+                eventType: input.eventType,
+                actorType: input.actor?.type ?? null,
+                actorId: input.actor?.id ?? null,
+                runId: input.runId ?? null,
+                agentId: input.agentId ?? null,
+                reason: input.reason ?? null,
+                beforeJson: input.before === undefined ? null : JSON.stringify(input.before),
+                afterJson: input.after === undefined ? null : JSON.stringify(input.after),
+                evidenceJson: input.evidence === undefined ? null : JSON.stringify(input.evidence),
+                createdAt: now,
+            });
+            const row = this.db.connection.prepare('SELECT * FROM skill_lifecycle_events WHERE id=?').get(id);
+            return row ? ok(mapLifecycleEvent(row)) : missing(`Skill lifecycle event not found: ${id}`);
+        }
+        catch (cause) {
+            return fail('Failed to record skill lifecycle event', cause);
+        }
+    }
+    findByNaturalKey(project, scope, name) {
+        return this.db.connection.prepare('SELECT * FROM skills WHERE project=? AND scope=? AND name=?').get(project, scope, name);
+    }
+    findVersion(skillId, version) {
+        return this.db.connection.prepare('SELECT * FROM skill_versions WHERE skill_id=? AND version=?').get(skillId, version);
+    }
+}
+function validateSkill(input) {
+    if (!input.project.trim())
+        return validationFailure('Skill project is required');
+    if (!input.name.trim())
+        return validationFailure('Skill name is required');
+    if (!input.description.trim())
+        return validationFailure('Skill description is required');
+    return ok(undefined);
+}
+function validateVersion(input) {
+    if (!input.skillId.trim())
+        return validationFailure('Skill id is required');
+    if (!input.version.trim())
+        return validationFailure('Skill version is required');
+    if (input.source.kind === 'path' && !input.source.path?.trim())
+        return validationFailure('Path skill sources require source.path');
+    if (input.source.kind === 'url' && !input.source.url?.trim())
+        return validationFailure('URL skill sources require source.url');
+    if (input.source.kind === 'inline' && (input.source.path !== undefined || input.source.url !== undefined))
+        return validationFailure('Inline skill sources cannot include source.path or source.url');
+    return ok(undefined);
+}
+function validateAttachment(input) {
+    if (!input.skillId.trim())
+        return validationFailure('Skill id is required');
+    if (!input.targetKey.trim())
+        return validationFailure('Skill attachment target key is required');
+    return ok(undefined);
+}
+function validateUsage(input) {
+    if (!input.skillId.trim())
+        return validationFailure('Skill id is required');
+    if (input.targetType !== undefined && !input.targetKey?.trim())
+        return validationFailure('Skill usage target key is required when target type is set');
+    if (input.targetType === undefined && input.targetKey !== undefined)
+        return validationFailure('Skill usage target type is required when target key is set');
+    if (input.versionId !== undefined && !input.versionId.trim())
+        return validationFailure('Skill version id must not be empty');
+    return ok(undefined);
+}
+function validateActivation(input) {
+    if (!input.project.trim())
+        return validationFailure('Skill activation project is required');
+    if (!input.skillId.trim())
+        return validationFailure('Skill id is required');
+    if (input.versionId !== undefined && !input.versionId.trim())
+        return validationFailure('Skill version id must not be empty');
+    return ok(undefined);
+}
+function validateCreateDraft(input) {
+    if (!input.project.trim())
+        return validationFailure('Skill draft project is required');
+    if (!input.name.trim())
+        return validationFailure('Skill draft name is required');
+    if (!input.description.trim())
+        return validationFailure('Skill draft description is required');
+    if (!input.version.trim())
+        return validationFailure('Skill draft version is required');
+    const source = validateSource(input.source);
+    if (!source.ok)
+        return source;
+    return validateLifecycleActor(input.actor);
+}
+function validateUpdateDraft(input) {
+    if (!input.project.trim())
+        return validationFailure('Skill draft project is required');
+    if ((input.skillId === undefined || !input.skillId.trim()) && (input.name === undefined || !input.name.trim()))
+        return validationFailure('Either skillId or name is required');
+    if ((input.versionId === undefined || !input.versionId.trim()) && (input.version === undefined || !input.version.trim()))
+        return validationFailure('Either versionId or version is required');
+    if (input.versionId !== undefined && input.version !== undefined)
+        return validationFailure('Use either versionId or version, not both');
+    if (input.source === undefined && input.compatibility === undefined && input.governance === undefined)
+        return validationFailure('At least one draft update field is required');
+    if (input.expectedDraftRevision !== undefined && (!Number.isSafeInteger(input.expectedDraftRevision) || input.expectedDraftRevision < 1)) {
+        return validationFailure('expectedDraftRevision must be a positive safe integer');
+    }
+    if (input.source !== undefined) {
+        const source = validateSource(input.source);
+        if (!source.ok)
+            return source;
+    }
+    return validateLifecycleActor(input.actor);
+}
+function validatePublishVersion(input) {
+    if (!input.project.trim())
+        return validationFailure('Skill publish project is required');
+    if ((input.skillId === undefined || !input.skillId.trim()) && (input.name === undefined || !input.name.trim()))
+        return validationFailure('Either skillId or name is required');
+    if ((input.versionId === undefined || !input.versionId.trim()) && (input.version === undefined || !input.version.trim()))
+        return validationFailure('Either versionId or version is required');
+    if (input.versionId !== undefined && input.version !== undefined)
+        return validationFailure('Use either versionId or version, not both');
+    if (!input.reason.trim())
+        return validationFailure('Publish reason is required');
+    return validateLifecycleActor(input.actor);
+}
+function validateLifecycleActor(actor) {
+    if (!['human', 'agent', 'system'].includes(actor.type))
+        return validationFailure('Lifecycle actor type must be human, agent, or system');
+    if (!actor.id.trim())
+        return validationFailure('Lifecycle actor id is required');
+    return ok(undefined);
+}
+function validateSource(source) {
+    if (source.kind === 'path' && !source.path?.trim())
+        return validationFailure('Path skill sources require source.path');
+    if (source.kind === 'url' && !source.url?.trim())
+        return validationFailure('URL skill sources require source.url');
+    if (source.kind === 'inline' && (source.path !== undefined || source.url !== undefined))
+        return validationFailure('Inline skill sources cannot include source.path or source.url');
+    return ok(undefined);
+}
+function assertVersionBelongsToSkill(db, versionId, skillId) {
+    const row = db.connection.prepare('SELECT skill_id FROM skill_versions WHERE id=?').get(versionId);
+    if (row === undefined)
+        throw new SkillRegistryValidationError(`Skill version not found: ${versionId}`);
+    if (row.skill_id !== skillId)
+        throw new SkillRegistryValidationError('Skill version must belong to the attached skill');
+}
+function mapSkill(row) {
+    const skill = {
+        id: row.id,
+        project: row.project,
+        scope: row.scope,
+        name: row.name,
+        description: row.description,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+    if (row.current_version_id !== null)
+        skill.currentVersionId = row.current_version_id;
+    return skill;
+}
+function mapSearchItem(row) {
+    const source = mapNullableSource(row.current_source_kind, row.current_source_path, row.current_source_url, row.current_source_inline_metadata_json);
+    const currentVersionId = row.current_version_row_id ?? null;
+    return {
+        id: row.id,
+        project: row.project,
+        scope: row.scope,
+        name: row.name,
+        description: row.description,
+        currentVersionId,
+        currentVersion: row.current_version ?? null,
+        status: row.current_status ?? (row.current_version_id === null ? 'missing-current-version' : 'missing-current-version-record'),
+        source,
+        attachments: Number(row.attachment_count ?? 0),
+        versions: Number(row.version_count ?? 0),
+    };
+}
+function mapNullableSource(kind, path, url, inlineMetadataJson) {
+    if (kind === null)
+        return null;
+    const source = { kind: kind };
+    if (path !== null)
+        source.path = path;
+    if (url !== null)
+        source.url = url;
+    const inlineMetadata = JSON.parse(inlineMetadataJson ?? '{}');
+    if (Object.keys(inlineMetadata).length > 0)
+        source.inlineMetadata = inlineMetadata;
+    return source;
+}
+function mapVersion(row) {
+    const source = { kind: row.source_kind };
+    if (row.source_path !== null)
+        source.path = row.source_path;
+    if (row.source_url !== null)
+        source.url = row.source_url;
+    const inlineMetadata = JSON.parse(row.source_inline_metadata_json ?? '{}');
+    if (Object.keys(inlineMetadata).length > 0)
+        source.inlineMetadata = inlineMetadata;
+    const version = {
+        id: row.id,
+        skillId: row.skill_id,
+        version: row.version,
+        source,
+        compatibility: JSON.parse(row.compatibility_json),
+        status: row.status,
+        createdAt: row.created_at,
+    };
+    if (row.lifecycle_label !== null && row.lifecycle_label !== undefined)
+        version.lifecycleLabel = row.lifecycle_label;
+    if (row.draft_parent_version_id !== null && row.draft_parent_version_id !== undefined)
+        version.draftParentVersionId = row.draft_parent_version_id;
+    if (row.draft_revision !== null && row.draft_revision !== undefined)
+        version.draftRevision = row.draft_revision;
+    if (row.governance_json !== null && row.governance_json !== undefined)
+        version.governance = JSON.parse(row.governance_json);
+    if (row.published_at !== null && row.published_at !== undefined)
+        version.publishedAt = row.published_at;
+    if (row.published_by !== null && row.published_by !== undefined)
+        version.publishedBy = row.published_by;
+    if (row.deprecated_at !== null && row.deprecated_at !== undefined)
+        version.deprecatedAt = row.deprecated_at;
+    if (row.archived_at !== null && row.archived_at !== undefined)
+        version.archivedAt = row.archived_at;
+    return version;
+}
+function mapLifecycleEvent(row) {
+    const event = {
+        id: row.id,
+        project: row.project,
+        scope: row.scope,
+        skillId: row.skill_id,
+        eventType: row.event_type,
+        createdAt: row.created_at,
+    };
+    if (row.version_id !== null)
+        event.versionId = row.version_id;
+    if (row.actor_type !== null && row.actor_id !== null)
+        event.actor = { type: row.actor_type, id: row.actor_id };
+    if (row.run_id !== null)
+        event.runId = row.run_id;
+    if (row.agent_id !== null)
+        event.agentId = row.agent_id;
+    if (row.reason !== null)
+        event.reason = row.reason;
+    if (row.before_json !== null)
+        event.before = JSON.parse(row.before_json);
+    if (row.after_json !== null)
+        event.after = JSON.parse(row.after_json);
+    if (row.evidence_json !== null)
+        event.evidence = JSON.parse(row.evidence_json);
+    return event;
+}
+function resolveSkillForMutation(repository, project, scope, skillId, name) {
+    const result = skillId !== undefined ? repository.getById(skillId) : repository.getByName(project, scope, name ?? '');
+    if (!result.ok)
+        throw new SkillRegistryValidationError(result.error.message);
+    if (result.value.project !== project || result.value.scope !== scope)
+        throw new SkillRegistryValidationError('Skill does not belong to the requested project/scope');
+    return result.value;
+}
+function resolveVersionForMutation(repository, skillId, versionId, version) {
+    const result = versionId !== undefined ? repository.getVersion(versionId) : repository.getVersionBySkillVersion(skillId, version ?? '');
+    if (!result.ok)
+        throw new SkillRegistryValidationError(result.error.message);
+    if (result.value.skillId !== skillId)
+        throw new SkillRegistryValidationError('Skill version must belong to the requested skill');
+    return result.value;
+}
+function versionSnapshot(version) {
+    return {
+        id: version.id,
+        skillId: version.skillId,
+        version: version.version,
+        status: version.status,
+        draftRevision: version.draftRevision ?? null,
+        lifecycleLabel: version.lifecycleLabel ?? null,
+        publishedAt: version.publishedAt ?? null,
+        publishedBy: version.publishedBy ?? null,
+    };
+}
+function mapAttachment(row) {
+    const attachment = {
+        id: row.id,
+        skillId: row.skill_id,
+        targetType: row.target_type,
+        targetKey: row.target_key,
+        metadata: JSON.parse(row.metadata_json),
+        createdAt: row.created_at,
+    };
+    if (row.version_id !== null)
+        attachment.versionId = row.version_id;
+    return attachment;
+}
+function mapUsage(row) {
+    const usage = {
+        id: row.id,
+        skillId: row.skill_id,
+        outcome: row.outcome,
+        createdAt: row.created_at,
+    };
+    if (row.version_id !== null)
+        usage.versionId = row.version_id;
+    if (row.run_id !== null)
+        usage.runId = row.run_id;
+    if (row.target_type !== null)
+        usage.targetType = row.target_type;
+    if (row.target_key !== null)
+        usage.targetKey = row.target_key;
+    if (row.notes !== null)
+        usage.notes = row.notes;
+    if (row.workflow !== null)
+        usage.workflow = row.workflow;
+    if (row.phase !== null)
+        usage.phase = row.phase;
+    if (row.provider_adapter !== null)
+        usage.providerAdapter = row.provider_adapter;
+    if (row.agent_id !== null)
+        usage.agentId = row.agent_id;
+    if (row.intent_json !== null)
+        usage.intent = JSON.parse(row.intent_json);
+    if (row.evidence_json !== null)
+        usage.evidence = JSON.parse(row.evidence_json);
+    return usage;
+}
+function mapActivation(row) {
+    const activation = {
+        id: row.id,
+        project: row.project,
+        scope: row.scope,
+        skillId: row.skill_id,
+        createdAt: row.created_at,
+    };
+    if (row.version_id !== null)
+        activation.versionId = row.version_id;
+    if (row.run_id !== null)
+        activation.runId = row.run_id;
+    if (row.agent_id !== null)
+        activation.agentId = row.agent_id;
+    if (row.workflow !== null)
+        activation.workflow = row.workflow;
+    if (row.phase !== null)
+        activation.phase = row.phase;
+    if (row.provider_adapter !== null)
+        activation.providerAdapter = row.provider_adapter;
+    if (row.intent_json !== null)
+        activation.intent = JSON.parse(row.intent_json);
+    if (row.reason !== null)
+        activation.reason = row.reason;
+    if (row.payload_metadata_json !== null)
+        activation.payloadMetadata = JSON.parse(row.payload_metadata_json);
+    return activation;
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function missing(message) {
+    return { ok: false, error: { code: 'not_found', message } };
+}
+function validationFailure(message) {
+    return { ok: false, error: { code: 'validation_failed', message } };
+}
+function fail(message, cause) {
+    const error = { code: 'validation_failed', message };
+    if (cause !== undefined)
+        error.cause = cause;
+    return { ok: false, error };
+}
+class SkillRegistryValidationError extends Error {
+}
+function normalizeLimit(limit) {
+    if (limit === undefined)
+        return 25;
+    if (!Number.isSafeInteger(limit) || limit < 1)
+        return 25;
+    return Math.min(limit, 100);
+}
+function zeroVersionCounts() {
+    return { draft: 0, active: 0, deprecated: 0, archived: 0 };
+}
+function zeroProposalCounts() {
+    return { draft: 0, 'pending-approval': 0, approved: 0, rejected: 0, cancelled: 0, applied: 0 };
+}
+function zeroEvaluationResultCounts() {
+    return { passed: 0, failed: 0, 'needs-review': 0, 'not-applicable': 0 };
+}
+function zeroEvaluationRequestCounts() {
+    return { requested: 0, planned: 0, running: 0, completed: 0, failed: 0, cancelled: 0, skipped: 0 };
+}
+function countScoped(db, table, project, scope) {
+    const row = db.connection
+        .prepare(`SELECT COUNT(*) AS count FROM ${table} t JOIN skills s ON s.id=t.skill_id WHERE s.project=? AND s.scope=?`)
+        .get(project, scope);
+    return row.count;
+}
+function countDirectScoped(db, table, project, scope) {
+    const row = db.connection.prepare(`SELECT COUNT(*) AS count FROM ${table} WHERE project=? AND scope=?`).get(project, scope);
+    return row.count;
+}