@penclipai/server 2026.704.0 → 2026.714.0

package/dist/services/company-skills.js

@@ -2,14 +2,16 @@ import { createHash, randomUUID } from "node:crypto";
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { and, asc, desc, eq, isNull, sql } from "drizzle-orm";
-import { companies, companySkillComments, companySkillStars, companySkillVersions, companySkills } from "@penclipai/db";
-import { readPaperclipSkillSyncPreference } from "@penclipai/adapter-utils/server-utils";
-import { normalizeAgentUrlKey, parseFrontmatterMarkdown } from "@penclipai/shared";
+import { and, asc, desc, eq, inArray, isNull, lt, sql } from "drizzle-orm";
+import { agents as agentsTable, assets, authUsers, companies, companySkillComments, companySkillStars, companySkillTestInputs, companySkillTestRunTemplates, companySkillTestRuns, companySkillVersions, companySkills, costEvents, documents, issueAttachments, issueDocuments, issues, issueThreadInteractions, issueWorkProducts, } from "@penclipai/db";
+import { readPaperclipSkillSyncPreference, writePaperclipSkillSyncPreference } from "@penclipai/adapter-utils/server-utils";
+import { isUuidLike, normalizeAgentUrlKey, parseFrontmatterMarkdown } from "@penclipai/shared";
 import { resolvePaperclipInstanceRoot } from "../home-paths.js";
 import { conflict, notFound, unprocessable } from "../errors.js";
 import { ghFetch, gitHubApiBase, resolveRawGitHubUrl } from "./github-fetch.js";
 import { agentService } from "./agents.js";
+import { issueDocumentSelect, mapIssueDocumentRow } from "./documents.js";
+import { toIssueWorkProduct } from "./work-products.js";
 import { projectService } from "./projects.js";
 import { normalizePortablePath } from "./portable-path.js";
 import { copyCatalogSkillFile, getCatalogPackageMetadata, getCatalogSkillOrThrow, resolveCatalogSkillReference, } from "./skills-catalog.js";
@@ -649,6 +651,79 @@ function inventoryEntriesEqual(left, right) {
         return other?.path === entry.path && other.kind === entry.kind;
     });
 }
+function stableJsonComparable(value) {
+    if (value === undefined)
+        return undefined;
+    if (Array.isArray(value)) {
+        return value.map((entry) => stableJsonComparable(entry) ?? null);
+    }
+    if (isPlainRecord(value)) {
+        const out = {};
+        for (const key of Object.keys(value).sort()) {
+            const normalized = stableJsonComparable(value[key]);
+            if (normalized !== undefined)
+                out[key] = normalized ?? null;
+        }
+        return out;
+    }
+    return value;
+}
+function stableJsonEqual(left, right) {
+    return JSON.stringify(stableJsonComparable(left)) === JSON.stringify(stableJsonComparable(right));
+}
+function isPaperclipBundledSkillKey(key) {
+    return getBundledPaperclipSkillSlugFromKey(key) !== null;
+}
+function stripDerivedPaperclipBundledMetadata(key, metadata) {
+    if (metadata === null || metadata === undefined)
+        return {};
+    const comparable = stableJsonComparable(metadata);
+    if (!isPlainRecord(comparable))
+        return comparable;
+    const out = { ...comparable };
+    if (out.skillKey === key)
+        delete out.skillKey;
+    if (out.sourceKind === "paperclip_bundled")
+        delete out.sourceKind;
+    delete out.missingSource;
+    return out;
+}
+function importedSkillMetadataEqual(existing, values) {
+    const incomingMetadata = isPlainRecord(values.metadata) ? values.metadata : null;
+    if (isPaperclipBundledSkillKey(values.key) && asString(incomingMetadata?.sourceKind) === "paperclip_bundled") {
+        return JSON.stringify(stripDerivedPaperclipBundledMetadata(existing.key, existing.metadata))
+            === JSON.stringify(stripDerivedPaperclipBundledMetadata(values.key, values.metadata));
+    }
+    return stableJsonEqual(existing.metadata ?? null, values.metadata);
+}
+function stringArraysEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((entry, index) => entry === right[index]);
+}
+function importedSkillPersistValuesMatchExisting(existing, values) {
+    return existing.companyId === values.companyId
+        && existing.key === values.key
+        && existing.slug === values.slug
+        && existing.name === values.name
+        && existing.description === values.description
+        && existing.markdown === values.markdown
+        && existing.sourceType === values.sourceType
+        && existing.sourceLocator === values.sourceLocator
+        && existing.sourceRef === values.sourceRef
+        && existing.trustLevel === values.trustLevel
+        && existing.compatibility === values.compatibility
+        && inventoryEntriesEqual(existing.fileInventory, normalizeFileInventory({ fileInventory: values.fileInventory }))
+        && existing.iconUrl === values.iconUrl
+        && existing.color === values.color
+        && existing.tagline === values.tagline
+        && existing.authorName === values.authorName
+        && existing.homepageUrl === values.homepageUrl
+        && stringArraysEqual(existing.categories, normalizeCategoryList(values.categories))
+        && existing.sharingScope === values.sharingScope
+        && existing.installCount === values.installCount
+        && importedSkillMetadataEqual(existing, values);
+}
 function inferLocalSkillInventoryMode(skill) {
     const metadata = isPlainRecord(skill.metadata) ? skill.metadata : null;
     const sourceKind = asString(metadata?.sourceKind);
@@ -999,15 +1074,31 @@ function normalizeMutableSharingScope(value) {
     }
     throw unprocessable("Invalid skill sharing scope.");
 }
-function normalizeCategorySlug(value) {
+function normalizeCategoryName(value) {
     if (typeof value !== "string")
         return null;
-    return normalizeSkillSlug(value);
+    const normalized = value.trim().replace(/\s+/g, " ");
+    return normalized.length > 0 ? normalized : null;
+}
+function categoryLookupKey(value) {
+    return value.toLocaleLowerCase();
 }
 function normalizeCategoryList(values) {
     if (!Array.isArray(values))
         return [];
-    return Array.from(new Set(values.map(normalizeCategorySlug).filter((value) => Boolean(value))));
+    const seen = new Set();
+    const categories = [];
+    for (const value of values) {
+        const category = normalizeCategoryName(value);
+        if (!category)
+            continue;
+        const key = categoryLookupKey(category);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        categories.push(category);
+    }
+    return categories;
 }
 function normalizeStoreText(value, maxLength = 500) {
     const text = asString(value);
@@ -1075,6 +1166,127 @@ function toCompanySkillComment(row) {
         deletedAt: row.deletedAt ?? null,
     };
 }
+function toCompanySkillTestInput(row) {
+    return {
+        ...row,
+        deletedAt: row.deletedAt ?? null,
+    };
+}
+const BUILT_IN_SKILL_TEST_RUN_TEMPLATE_ID = "built-in:default-test-template";
+const BUILT_IN_SKILL_TEST_RUN_TEMPLATE_DATE = new Date("2026-01-01T00:00:00.000Z");
+const BUILT_IN_SKILL_TEST_RUN_TEMPLATE_BODY = [
+    "You are running a Skills Studio test for `{{skillName}}` (`{{skillKey}}`), skill version v{{skillVersion}}.",
+    "",
+    "Invoke and use the selected skill under test: `{{skillInvocation}}`. Use the pinned skill revision supplied by Paperclip as the source of truth, regardless of any other runtime skills.",
+    "",
+    "This is a test run. Do not make durable changes outside this test task. Do not mutate unrelated issues, push, publish, send external messages, or affect real work.",
+    "",
+    "If the skill would create documents, images, videos, files, or other assets, create test versions in an obviously test-scoped location when applicable, then post the results back to this task as issue documents, attachments, or work products.",
+    "",
+    "Write the final result to issue document `{{outputDocumentKey}}`, then mark this test task done.",
+].join("\n");
+function builtInSkillTestRunTemplate(companyId) {
+    return {
+        id: BUILT_IN_SKILL_TEST_RUN_TEMPLATE_ID,
+        companyId,
+        name: "Default test template",
+        description: "Paperclip's read-only default harness instructions for Skills Studio runs.",
+        body: BUILT_IN_SKILL_TEST_RUN_TEMPLATE_BODY,
+        builtIn: true,
+        createdByAgentId: null,
+        createdByUserId: null,
+        updatedByAgentId: null,
+        updatedByUserId: null,
+        deletedAt: null,
+        createdAt: BUILT_IN_SKILL_TEST_RUN_TEMPLATE_DATE,
+        updatedAt: BUILT_IN_SKILL_TEST_RUN_TEMPLATE_DATE,
+    };
+}
+function toCompanySkillTestRunTemplate(row) {
+    return {
+        ...row,
+        description: row.description ?? null,
+        builtIn: false,
+        createdByAgentId: row.createdByAgentId ?? null,
+        createdByUserId: row.createdByUserId ?? null,
+        updatedByAgentId: row.updatedByAgentId ?? null,
+        updatedByUserId: row.updatedByUserId ?? null,
+        deletedAt: row.deletedAt ?? null,
+    };
+}
+const ALLOWED_SKILL_TEST_TEMPLATE_PLACEHOLDERS = new Set([
+    "skillName",
+    "skillKey",
+    "skillInvocation",
+    "skillVersion",
+    "runId",
+    "issueId",
+    "outputDocumentKey",
+]);
+function validateSkillTestTemplatePlaceholders(body) {
+    const unknown = new Set();
+    const recognized = /\{\{\s*([A-Za-z][A-Za-z0-9]*)\s*\}\}/g;
+    for (const match of body.matchAll(recognized)) {
+        const key = match[1] ?? "";
+        if (!ALLOWED_SKILL_TEST_TEMPLATE_PLACEHOLDERS.has(key)) {
+            unknown.add(key);
+        }
+    }
+    if (body.replace(recognized, "").includes("{{") || body.replace(recognized, "").includes("}}")) {
+        throw unprocessable("Malformed template placeholder. Use explicit placeholders like {{skillName}}.");
+    }
+    if (unknown.size > 0) {
+        throw unprocessable(`Unknown template placeholder${unknown.size === 1 ? "" : "s"}: ${Array.from(unknown).sort().join(", ")}`);
+    }
+}
+function renderSkillTestTemplate(body, values) {
+    validateSkillTestTemplatePlaceholders(body);
+    return body.replace(/\{\{\s*([A-Za-z][A-Za-z0-9]*)\s*\}\}/g, (_match, rawKey) => values[rawKey] ?? "");
+}
+function buildHarnessIssueDescription(inputSnapshot, renderedTemplateBody) {
+    const trimmedInput = inputSnapshot.trim();
+    const trimmedTemplate = renderedTemplateBody?.trim() ?? "";
+    return trimmedTemplate ? `${trimmedInput}\n\n---\n\n${trimmedTemplate}` : trimmedInput;
+}
+function normalizeTestRunStatus(value) {
+    return value === "running" || value === "succeeded" || value === "failed" || value === "cancelled"
+        ? value
+        : "queued";
+}
+function emptyTestRunCost() {
+    return {
+        costCents: 0,
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0,
+    };
+}
+function toCompanySkillTestRun(row, cost = emptyTestRunCost(), taskExpired = false) {
+    return {
+        ...row,
+        inputId: row.inputId ?? null,
+        agentConfigSnapshot: isPlainRecord(row.agentConfigSnapshot) ? row.agentConfigSnapshot : {},
+        templateId: row.templateId ?? null,
+        templateName: row.templateName ?? null,
+        templateBody: row.templateBody ?? null,
+        renderedTemplateBody: row.renderedTemplateBody ?? null,
+        harnessIssueDescription: row.harnessIssueDescription || row.inputSnapshot,
+        status: normalizeTestRunStatus(row.status),
+        outputDocumentKey: row.outputDocumentKey || "output",
+        outputSnapshot: row.outputSnapshot ?? "",
+        error: row.error ?? null,
+        deletedAt: row.deletedAt ?? null,
+        supersededAt: row.supersededAt ?? null,
+        harnessIssueExpiresAt: row.harnessIssueExpiresAt ?? null,
+        harnessIssueDeletedAt: row.harnessIssueDeletedAt ?? null,
+        cost,
+        taskExpired,
+    };
+}
+function versionInventorySnapshotEqual(left, right) {
+    const normalize = (entries) => JSON.stringify([...entries].sort((a, b) => a.path.localeCompare(b.path)));
+    return normalize(left) === normalize(right);
+}
 function getSkillMeta(skill) {
     return isPlainRecord(skill.metadata) ? skill.metadata : {};
 }
@@ -1197,10 +1409,12 @@ async function assertVersionMatchesSkill(db, companyId, skillId, versionId) {
         });
     }
 }
-async function resolveRequestedSkillEntriesOrThrow(db, companyId, skills, requestedSelections) {
+async function resolveRequestedSkillEntriesOrThrow(db, companyId, skills, requestedSelections, options = {}) {
     const missing = new Set();
     const ambiguous = new Set();
     const resolved = new Map();
+    const unresolved = [];
+    const seenUnresolved = new Set();
     for (const rawSelection of requestedSelections) {
         const selection = normalizeRequestedDesiredSkillSelection(rawSelection);
         if (!selection.key)
@@ -1223,8 +1437,19 @@ async function resolveRequestedSkillEntriesOrThrow(db, companyId, skills, reques
             ambiguous.add(selection.key);
             continue;
         }
+        // Unknown / stale reference (no longer in the company library).
+        if (options.tolerateUnknownReferences) {
+            if (!seenUnresolved.has(selection.key)) {
+                seenUnresolved.add(selection.key);
+                unresolved.push(selection.key);
+            }
+            continue;
+        }
         missing.add(selection.key);
     }
+    // Ambiguous references are always a hard error — they signal a genuine
+    // conflict the caller must disambiguate. Unknown references are only fatal
+    // when the caller has not opted into tolerating (and preserving) stale keys.
     if (ambiguous.size > 0 || missing.size > 0) {
         const problems = [];
         if (ambiguous.size > 0) {
@@ -1235,7 +1460,7 @@ async function resolveRequestedSkillEntriesOrThrow(db, companyId, skills, reques
         }
         throw unprocessable(`Invalid company skill selection (${problems.join("; ")}).`);
     }
-    return Array.from(resolved.values());
+    return { resolved: Array.from(resolved.values()), unresolved };
 }
 function resolveDesiredSkillKeys(skills, config) {
     const preference = readPaperclipSkillSyncPreference(config);
@@ -1611,17 +1836,52 @@ function deriveSkillSourceInfo(skill) {
         sourcePath: null,
     };
 }
-function enrichSkill(skill, attachedAgentCount, usedByAgents = [], currentVersion = null, starredByCurrentActor = false) {
+function enrichSkill(skill, attachedAgentCount, usedByAgents = [], currentVersion = null, starredByCurrentActor = false, existingForks = []) {
     const source = deriveSkillSourceInfo(skill);
     return {
         ...skill,
         attachedAgentCount,
         usedByAgents,
+        existingForks,
         currentVersion,
         starredByCurrentActor,
         ...source,
     };
 }
+function summarizeOriginalSkill(skill) {
+    return {
+        id: skill.id,
+        name: skill.name,
+        slug: skill.slug,
+        sourceType: skill.sourceType,
+        sourceLocator: skill.sourceLocator,
+        sourceRef: skill.sourceRef,
+    };
+}
+function forkCreatedByActor(skill, actor) {
+    const metadata = getSkillMeta(skill);
+    if (actor?.type === "agent" && actor.agentId) {
+        return asString(metadata.forkedByAgentId) === actor.agentId;
+    }
+    if (actor?.type === "user" && actor.userId) {
+        return asString(metadata.forkedByUserId) === actor.userId;
+    }
+    return false;
+}
+function summarizeForkSkill(skill, actor, versionCount) {
+    const metadata = getSkillMeta(skill);
+    return {
+        ...summarizeOriginalSkill(skill),
+        key: skill.key,
+        forkedFromSkillId: skill.forkedFromSkillId,
+        forkedFromCompanyId: skill.forkedFromCompanyId,
+        currentVersionId: skill.currentVersionId,
+        createdByCurrentActor: forkCreatedByActor(skill, actor),
+        diverged: versionCount > 1 || Boolean(asString(metadata.userModifiedAt)),
+        createdAt: skill.createdAt,
+        updatedAt: skill.updatedAt,
+    };
+}
 function toCompanySkillListItem(skill, attachedAgentCount) {
     const source = deriveSkillSourceInfo(skill);
     const metadata = getSkillMeta(skill);
@@ -1672,6 +1932,47 @@ function toCompanySkillListItem(skill, attachedAgentCount) {
         packageVersion,
     };
 }
+async function listLastEditorsBySkillId(db, companyId, skillIds) {
+    if (skillIds.length === 0)
+        return new Map();
+    const rows = await db
+        .selectDistinctOn([companySkillVersions.companySkillId], {
+        companySkillId: companySkillVersions.companySkillId,
+        authorAgentId: companySkillVersions.authorAgentId,
+        authorUserId: companySkillVersions.authorUserId,
+        userName: authUsers.name,
+        userImage: authUsers.image,
+        agentName: agentsTable.name,
+    })
+        .from(companySkillVersions)
+        .leftJoin(authUsers, eq(authUsers.id, companySkillVersions.authorUserId))
+        .leftJoin(agentsTable, and(eq(agentsTable.companyId, companyId), eq(agentsTable.id, companySkillVersions.authorAgentId)))
+        .where(and(eq(companySkillVersions.companyId, companyId), inArray(companySkillVersions.companySkillId, skillIds)))
+        .orderBy(companySkillVersions.companySkillId, desc(companySkillVersions.createdAt), desc(companySkillVersions.revisionNumber), desc(companySkillVersions.id));
+    const editors = new Map();
+    for (const row of rows) {
+        if (row.authorUserId) {
+            editors.set(row.companySkillId, {
+                kind: "user",
+                id: row.authorUserId,
+                name: row.userName ?? null,
+                imageUrl: row.userImage ?? null,
+            });
+            continue;
+        }
+        if (row.authorAgentId) {
+            editors.set(row.companySkillId, {
+                kind: "agent",
+                id: row.authorAgentId,
+                name: row.agentName ?? null,
+                imageUrl: null,
+            });
+            continue;
+        }
+        editors.set(row.companySkillId, null);
+    }
+    return editors;
+}
 export function companySkillService(db) {
     const agents = agentService(db);
     const projects = projectService(db);
@@ -1727,6 +2028,8 @@ export function companySkillService(db) {
         for (const skill of skills) {
             if (skill.sourceType !== "local_path")
                 continue;
+            if (isPaperclipBundledSkillKey(skill.key) || asString(skill.metadata?.sourceKind) === "paperclip_bundled")
+                continue;
             if (!missingIds.has(skill.id)) {
                 const metadata = getMissingSourceMarker(skill.metadata)
                     ? withoutMissingSourceMarker(skill.metadata)
@@ -1737,7 +2040,7 @@ export function companySkillService(db) {
                     : null;
                 const nextTrustLevel = nextInventory ? deriveTrustLevel(nextInventory) : skill.trustLevel;
                 const inventoryChanged = nextInventory ? !inventoryEntriesEqual(skill.fileInventory, nextInventory) : false;
-                const metadataChanged = JSON.stringify(metadata ?? {}) !== JSON.stringify(skill.metadata ?? {});
+                const metadataChanged = !stableJsonEqual(metadata ?? {}, skill.metadata ?? {});
                 if (inventoryChanged || metadataChanged || nextTrustLevel !== skill.trustLevel) {
                     await db
                         .update(companySkills)
@@ -1754,7 +2057,7 @@ export function companySkillService(db) {
             const usedByAgents = await usage(companyId, skill.key);
             if (usedByAgents.length > 0) {
                 const metadata = withMissingSourceMarker(skill.metadata, buildMissingLocalSourceMarker(skill));
-                if (JSON.stringify(metadata) !== JSON.stringify(skill.metadata ?? {})) {
+                if (!stableJsonEqual(metadata, skill.metadata ?? {})) {
                     await db
                         .update(companySkills)
                         .set({ metadata, updatedAt: new Date() })
@@ -1836,11 +2139,14 @@ export function companySkillService(db) {
             .then((entries) => entries.map((entry) => toCompanySkillListRow(entry)));
         const agentRows = await agents.list(companyId);
         const q = query.q?.trim().toLowerCase() ?? "";
-        const categories = new Set((query.categories ?? []).map(normalizeCategorySlug).filter((value) => Boolean(value)));
+        const categories = new Set((query.categories ?? [])
+            .map(normalizeCategoryName)
+            .filter((value) => Boolean(value))
+            .map(categoryLookupKey));
         const filtered = rows.filter((skill) => {
             if (query.scope && skill.sharingScope !== query.scope)
                 return false;
-            if (categories.size > 0 && !skill.categories.some((category) => categories.has(category)))
+            if (categories.size > 0 && !skill.categories.some((category) => categories.has(categoryLookupKey(category))))
                 return false;
             if (q) {
                 const haystack = [
@@ -1878,6 +2184,13 @@ export function companySkillService(db) {
                 return right.forkCount - left.forkCount || left.name.localeCompare(right.name);
             return left.name.localeCompare(right.name) || left.key.localeCompare(right.key);
         });
+        if (query.include?.includes("lastEditor")) {
+            const lastEditors = await listLastEditorsBySkillId(db, companyId, items.map((item) => item.id));
+            return items.map((item) => ({
+                ...item,
+                lastEditor: lastEditors.get(item.id) ?? null,
+            }));
+        }
         return items;
     }
     async function listFull(companyId) {
@@ -1928,6 +2241,18 @@ export function companySkillService(db) {
             .then((rows) => rows[0] ?? null);
         return row ? toCompanySkill(row) : null;
     }
+    async function getBySlugIfUnique(companyId, slug) {
+        const rows = await db
+            .select(selectCompanySkillColumns())
+            .from(companySkills)
+            .where(and(eq(companySkills.companyId, companyId), eq(companySkills.slug, slug)));
+        return rows.length === 1 ? toCompanySkill(rows[0]) : null;
+    }
+    async function getByRouteRef(companyId, ref) {
+        return (isUuidLike(ref) ? await getById(companyId, ref) : null)
+            ?? await getBySlugIfUnique(companyId, ref)
+            ?? await getByKey(companyId, ref);
+    }
     async function getVersion(companyId, skillId, versionId) {
         const row = await db
             .select()
@@ -2019,13 +2344,48 @@ export function companySkillService(db) {
             versionId: desiredEntry.versionId ?? null,
         }));
     }
+    async function versionCount(companyId, skillId) {
+        const [{ value }] = await db
+            .select({ value: sql `count(*)::int` })
+            .from(companySkillVersions)
+            .where(and(eq(companySkillVersions.companyId, companyId), eq(companySkillVersions.companySkillId, skillId)));
+        return Number(value ?? 0);
+    }
+    async function existingForkSummaries(companyId, sourceSkillId, actor) {
+        const rows = await db
+            .select(selectCompanySkillColumns())
+            .from(companySkills)
+            .where(and(eq(companySkills.companyId, companyId), eq(companySkills.forkedFromSkillId, sourceSkillId)))
+            .orderBy(desc(companySkills.updatedAt), asc(companySkills.name));
+        const summaries = [];
+        for (const row of rows) {
+            const skill = toCompanySkill(row);
+            summaries.push(summarizeForkSkill(skill, actor, await versionCount(companyId, skill.id)));
+        }
+        return summaries;
+    }
     async function detail(companyId, id, actor) {
         await ensureSkillInventoryCurrent(companyId);
-        const skill = await getById(companyId, id);
+        const skill = await getByRouteRef(companyId, id);
         if (!skill)
             return null;
         const usedByAgents = await usage(companyId, skill.key);
-        return enrichSkill(skill, usedByAgents.length, usedByAgents, await getCurrentVersion(skill), await isStarredByActor(companyId, id, actor));
+        const existingForks = await existingForkSummaries(companyId, skill.id, actor);
+        return enrichSkill(skill, usedByAgents.length, usedByAgents, await getCurrentVersion(skill), await isStarredByActor(companyId, skill.id, actor), existingForks);
+    }
+    async function forkPrecheck(companyId, skillId, actor) {
+        await ensureSkillInventoryCurrent(companyId);
+        const skill = await getById(companyId, skillId);
+        if (!skill)
+            return null;
+        const usedByAgents = await usage(companyId, skill.key);
+        return {
+            skillId: skill.id,
+            original: summarizeOriginalSkill(skill),
+            agentUsageCount: usedByAgents.length,
+            usedByAgents,
+            existingForks: await existingForkSummaries(companyId, skill.id, actor),
+        };
     }
     async function collectVersionFileInventory(companyId, skill) {
         const out = [];
@@ -2231,6 +2591,117 @@ export function companySkillService(db) {
             throw notFound("Skill comment not found");
         return toCompanySkillComment(row);
     }
+    async function planSkillReassignments(companyId, source, forkKey, reassignAgentIds) {
+        const requestedAgentIds = Array.from(new Set(reassignAgentIds ?? []));
+        if (requestedAgentIds.length === 0)
+            return [];
+        const skills = await listReferenceTargets(companyId);
+        const agentRows = await agents.list(companyId, { includeTerminated: true });
+        const byId = new Map(agentRows.map((agent) => [agent.id, agent]));
+        const missingAgentIds = requestedAgentIds.filter((agentId) => !byId.has(agentId));
+        if (missingAgentIds.length > 0) {
+            throw notFound(`Agent not found for skill reassignment: ${missingAgentIds.join(", ")}`);
+        }
+        return requestedAgentIds.map((agentId) => {
+            const agent = byId.get(agentId);
+            if (agent.companyId !== companyId) {
+                throw unprocessable("Cannot reassign a skill for an agent in another company.", { agentId });
+            }
+            const adapterConfig = agent.adapterConfig;
+            const desiredEntries = resolveDesiredSkillEntries(skills, adapterConfig);
+            const hasSource = desiredEntries.some((entry) => entry.key === source.key);
+            if (!hasSource) {
+                throw unprocessable(`Agent "${agent.name}" does not currently use skill "${source.name}".`, {
+                    agentId,
+                    skillId: source.id,
+                    skillKey: source.key,
+                });
+            }
+            return {
+                agentId,
+                reassignment: {
+                    agentId,
+                    previousSkillKey: source.key,
+                    nextSkillKey: forkKey,
+                },
+            };
+        });
+    }
+    async function applySkillReassignments(companyId, source, forkKey, planned) {
+        if (planned.length === 0)
+            return [];
+        const skills = await listReferenceTargets(companyId);
+        await db.transaction(async (tx) => {
+            for (const item of planned) {
+                const row = await tx
+                    .select({
+                    id: agentsTable.id,
+                    name: agentsTable.name,
+                    adapterConfig: agentsTable.adapterConfig,
+                })
+                    .from(agentsTable)
+                    .where(and(eq(agentsTable.companyId, companyId), eq(agentsTable.id, item.agentId)))
+                    .for("update")
+                    .then((rows) => rows[0] ?? null);
+                if (!row)
+                    throw notFound(`Agent not found for skill reassignment: ${item.agentId}`);
+                const adapterConfig = row.adapterConfig;
+                const desiredEntries = resolveDesiredSkillEntries(skills, adapterConfig);
+                const hasSource = desiredEntries.some((entry) => entry.key === source.key);
+                if (!hasSource) {
+                    throw unprocessable(`Agent "${row.name}" does not currently use skill "${source.name}".`, {
+                        agentId: item.agentId,
+                        skillId: source.id,
+                        skillKey: source.key,
+                    });
+                }
+                const nextEntries = desiredEntries.map((entry) => entry.key === source.key
+                    ? { key: forkKey, versionId: null }
+                    : entry);
+                const updated = await tx
+                    .update(agentsTable)
+                    .set({
+                    adapterConfig: writePaperclipSkillSyncPreference(adapterConfig, nextEntries),
+                    updatedAt: new Date(),
+                })
+                    .where(and(eq(agentsTable.companyId, companyId), eq(agentsTable.id, item.agentId)))
+                    .returning({ id: agentsTable.id })
+                    .then((rows) => rows[0] ?? null);
+                if (!updated)
+                    throw notFound(`Agent not found for skill reassignment: ${item.agentId}`);
+            }
+        });
+        return planned.map((item) => item.reassignment);
+    }
+    async function cleanupFailedFork(companyId, sourceSkillId, forkSkillId, forkDir) {
+        await db.transaction(async (tx) => {
+            await tx
+                .update(companySkills)
+                .set({ currentVersionId: null, updatedAt: new Date() })
+                .where(and(eq(companySkills.id, forkSkillId), eq(companySkills.companyId, companyId)));
+            await tx
+                .delete(companySkillComments)
+                .where(and(eq(companySkillComments.companyId, companyId), eq(companySkillComments.companySkillId, forkSkillId)));
+            await tx
+                .delete(companySkillStars)
+                .where(and(eq(companySkillStars.companyId, companyId), eq(companySkillStars.companySkillId, forkSkillId)));
+            await tx
+                .delete(companySkillVersions)
+                .where(and(eq(companySkillVersions.companyId, companyId), eq(companySkillVersions.companySkillId, forkSkillId)));
+            await tx
+                .delete(companySkills)
+                .where(and(eq(companySkills.id, forkSkillId), eq(companySkills.companyId, companyId)));
+            await tx
+                .update(companySkills)
+                .set({
+                forkCount: sql `greatest(${companySkills.forkCount} - 1, 0)`,
+                installCount: sql `greatest(${companySkills.installCount} - 1, 0)`,
+                updatedAt: new Date(),
+            })
+                .where(and(eq(companySkills.id, sourceSkillId), eq(companySkills.companyId, companyId)));
+        });
+        await fs.rm(forkDir, { recursive: true, force: true });
+    }
     async function forkSkill(companyId, skillId, input = {}, actor = null) {
         await ensureSkillInventoryCurrent(companyId);
         const source = await getById(companyId, skillId);
@@ -2240,6 +2711,8 @@ export function companySkillService(db) {
         const usedSlugs = new Set(existing.map((skill) => normalizeSkillSlug(skill.slug) ?? skill.slug));
         const forkSlug = uniqueSkillSlug(normalizeSkillSlug(input.slug ?? `${source.slug}-fork`) ?? `${source.slug}-fork`, usedSlugs);
         const forkName = input.name?.trim() || `${source.name} Fork`;
+        const forkKey = `company/${companyId}/${forkSlug}`;
+        const plannedReassignments = await planSkillReassignments(companyId, source, forkKey, input.reassignAgentIds);
         const managedRoot = resolveManagedSkillsRoot(companyId);
         const forkDir = path.resolve(managedRoot, forkSlug);
         await fs.rm(forkDir, { recursive: true, force: true });
@@ -2267,7 +2740,7 @@ export function companySkillService(db) {
             forkedByUserId: actor?.type === "user" ? actor.userId ?? null : null,
         };
         const imported = await upsertImportedSkills(companyId, [{
-                key: `company/${companyId}/${forkSlug}`,
+                key: forkKey,
                 slug: forkSlug,
                 name: asString(parsed.frontmatter.name) ?? forkName,
                 description: asString(parsed.frontmatter.description) ?? source.description,
@@ -2305,11 +2778,24 @@ export function companySkillService(db) {
         })
             .where(and(eq(companySkills.id, source.id), eq(companySkills.companyId, companyId)));
         await createVersion(companyId, forked.id, { label: "Initial version" }, actor);
-        return getById(companyId, forked.id).then((skill) => {
+        const persistedFork = await getById(companyId, forked.id).then((skill) => {
             if (!skill)
                 throw notFound("Forked skill not found");
             return skill;
         });
+        let reassignments;
+        try {
+            reassignments = await applySkillReassignments(companyId, source, forkKey, plannedReassignments);
+        }
+        catch (error) {
+            await cleanupFailedFork(companyId, source.id, forked.id, forkDir);
+            throw error;
+        }
+        return {
+            skill: persistedFork,
+            original: summarizeOriginalSkill(source),
+            reassignments,
+        };
     }
     async function updateStatus(companyId, skillId) {
         await ensureSkillInventoryCurrent(companyId);
@@ -2676,6 +3162,58 @@ export function companySkillService(db) {
             throw notFound("Skill file not found");
         return detail;
     }
+    async function deleteFile(companyId, skillId, input, actor = null) {
+        await ensureSkillInventoryCurrent(companyId);
+        const skill = await getById(companyId, skillId);
+        if (!skill)
+            throw notFound("Skill not found");
+        const source = deriveSkillSourceInfo(skill);
+        if (!source.editable || skill.sourceType !== "local_path") {
+            throw unprocessable(source.editableReason ?? "This skill cannot be edited.");
+        }
+        const normalizedPath = normalizePortablePath(input.path);
+        if (!normalizedPath) {
+            throw unprocessable("Skill file path is required.");
+        }
+        const deletedPaths = input.target === "folder"
+            ? skill.fileInventory
+                .map((entry) => normalizePortablePath(entry.path))
+                .filter((entryPath) => entryPath.startsWith(`${normalizedPath}/`))
+            : skill.fileInventory
+                .map((entry) => normalizePortablePath(entry.path))
+                .filter((entryPath) => entryPath === normalizedPath);
+        if (deletedPaths.length === 0) {
+            throw notFound(input.target === "folder" ? "Skill folder not found" : "Skill file not found");
+        }
+        if (deletedPaths.includes("SKILL.md")) {
+            throw unprocessable("SKILL.md cannot be deleted.");
+        }
+        const absolutePath = resolveLocalSkillFilePath(skill, normalizedPath);
+        if (!absolutePath)
+            throw notFound("Skill file not found");
+        await fs.rm(absolutePath, {
+            recursive: input.target === "folder",
+            force: false,
+        }).catch((error) => {
+            if (error.code === "ENOENT") {
+                throw notFound(input.target === "folder" ? "Skill folder not found" : "Skill file not found");
+            }
+            throw error;
+        });
+        await db
+            .update(companySkills)
+            .set({ updatedAt: new Date() })
+            .where(eq(companySkills.id, skill.id));
+        await createVersion(companyId, skillId, {
+            label: input.target === "folder" ? `Deleted ${normalizedPath}/` : `Deleted ${normalizedPath}`,
+        }, actor);
+        return {
+            skillId: skill.id,
+            path: normalizedPath,
+            target: input.target,
+            deletedPaths,
+        };
+    }
     async function installUpdate(companyId, skillId, options = {}) {
         await ensureSkillInventoryCurrent(companyId);
         const skill = await getById(companyId, skillId);
@@ -3690,6 +4228,10 @@ export function companySkillService(db) {
                 metadata,
                 updatedAt: new Date(),
             };
+            if (existing && importedSkillPersistValuesMatchExisting(existing, values)) {
+                out.push(existing);
+                continue;
+            }
             const row = existing
                 ? await db
                     .update(companySkills)
@@ -3745,6 +4287,630 @@ export function companySkillService(db) {
         const imported = await upsertImportedSkills(companyId, filteredSkills);
         return { imported, warnings };
     }
+    async function listTestInputs(companyId, skillId) {
+        const skill = await getById(companyId, skillId);
+        if (!skill)
+            throw notFound("Skill not found");
+        const rows = await db
+            .select()
+            .from(companySkillTestInputs)
+            .where(and(eq(companySkillTestInputs.companyId, companyId), eq(companySkillTestInputs.skillId, skillId), isNull(companySkillTestInputs.deletedAt)))
+            .orderBy(asc(companySkillTestInputs.name), asc(companySkillTestInputs.createdAt));
+        return rows.map(toCompanySkillTestInput);
+    }
+    async function createTestInput(companyId, skillId, input, actor = null) {
+        const skill = await getById(companyId, skillId);
+        if (!skill)
+            throw notFound("Skill not found");
+        const row = await db
+            .insert(companySkillTestInputs)
+            .values({
+            companyId,
+            skillId,
+            name: input.name.trim(),
+            content: input.content,
+            createdBy: actor?.type === "agent"
+                ? actor.agentId ?? null
+                : actor?.type === "user"
+                    ? actor.userId ?? null
+                    : null,
+        })
+            .returning()
+            .then((rows) => rows[0] ?? null);
+        if (!row)
+            throw notFound("Failed to persist test input");
+        return toCompanySkillTestInput(row);
+    }
+    async function updateTestInput(companyId, skillId, inputId, input) {
+        const patch = { updatedAt: new Date() };
+        if (input.name !== undefined)
+            patch.name = input.name.trim();
+        if (input.content !== undefined)
+            patch.content = input.content;
+        const row = await db
+            .update(companySkillTestInputs)
+            .set(patch)
+            .where(and(eq(companySkillTestInputs.companyId, companyId), eq(companySkillTestInputs.skillId, skillId), eq(companySkillTestInputs.id, inputId), isNull(companySkillTestInputs.deletedAt)))
+            .returning()
+            .then((rows) => rows[0] ?? null);
+        return row ? toCompanySkillTestInput(row) : null;
+    }
+    async function deleteTestInput(companyId, skillId, inputId) {
+        const row = await db
+            .update(companySkillTestInputs)
+            .set({ deletedAt: new Date(), updatedAt: new Date() })
+            .where(and(eq(companySkillTestInputs.companyId, companyId), eq(companySkillTestInputs.skillId, skillId), eq(companySkillTestInputs.id, inputId), isNull(companySkillTestInputs.deletedAt)))
+            .returning()
+            .then((rows) => rows[0] ?? null);
+        return row ? toCompanySkillTestInput(row) : null;
+    }
+    async function listTestRunTemplates(companyId) {
+        const rows = await db
+            .select()
+            .from(companySkillTestRunTemplates)
+            .where(and(eq(companySkillTestRunTemplates.companyId, companyId), isNull(companySkillTestRunTemplates.deletedAt)))
+            .orderBy(asc(companySkillTestRunTemplates.name), asc(companySkillTestRunTemplates.createdAt));
+        return [
+            builtInSkillTestRunTemplate(companyId),
+            ...rows.map(toCompanySkillTestRunTemplate),
+        ];
+    }
+    async function createTestRunTemplate(companyId, input, actor = null) {
+        validateSkillTestTemplatePlaceholders(input.body);
+        const row = await db
+            .insert(companySkillTestRunTemplates)
+            .values({
+            companyId,
+            name: input.name.trim(),
+            description: input.description?.trim() || null,
+            body: input.body,
+            createdByAgentId: actor?.type === "agent" ? actor.agentId ?? null : null,
+            createdByUserId: actor?.type === "user" ? actor.userId ?? null : null,
+            updatedByAgentId: actor?.type === "agent" ? actor.agentId ?? null : null,
+            updatedByUserId: actor?.type === "user" ? actor.userId ?? null : null,
+        })
+            .returning()
+            .then((rows) => rows[0] ?? null);
+        if (!row)
+            throw notFound("Failed to persist test run template");
+        return toCompanySkillTestRunTemplate(row);
+    }
+    async function updateTestRunTemplate(companyId, templateId, input, actor = null) {
+        if (templateId === BUILT_IN_SKILL_TEST_RUN_TEMPLATE_ID) {
+            throw unprocessable("Built-in test run templates are read-only.");
+        }
+        if (input.body !== undefined) {
+            validateSkillTestTemplatePlaceholders(input.body);
+        }
+        const patch = {
+            updatedAt: new Date(),
+            updatedByAgentId: actor?.type === "agent" ? actor.agentId ?? null : null,
+            updatedByUserId: actor?.type === "user" ? actor.userId ?? null : null,
+        };
+        if (input.name !== undefined)
+            patch.name = input.name.trim();
+        if (input.description !== undefined)
+            patch.description = input.description?.trim() || null;
+        if (input.body !== undefined)
+            patch.body = input.body;
+        const row = await db
+            .update(companySkillTestRunTemplates)
+            .set(patch)
+            .where(and(eq(companySkillTestRunTemplates.companyId, companyId), eq(companySkillTestRunTemplates.id, templateId), isNull(companySkillTestRunTemplates.deletedAt)))
+            .returning()
+            .then((rows) => rows[0] ?? null);
+        return row ? toCompanySkillTestRunTemplate(row) : null;
+    }
+    async function deleteTestRunTemplate(companyId, templateId) {
+        if (templateId === BUILT_IN_SKILL_TEST_RUN_TEMPLATE_ID) {
+            throw unprocessable("Built-in test run templates are read-only.");
+        }
+        const row = await db
+            .update(companySkillTestRunTemplates)
+            .set({ deletedAt: new Date(), updatedAt: new Date() })
+            .where(and(eq(companySkillTestRunTemplates.companyId, companyId), eq(companySkillTestRunTemplates.id, templateId), isNull(companySkillTestRunTemplates.deletedAt)))
+            .returning()
+            .then((rows) => rows[0] ?? null);
+        return row ? toCompanySkillTestRunTemplate(row) : null;
+    }
+    async function resolveTestRunTemplateSnapshot(companyId, input) {
+        if (input.templateSnapshot !== undefined) {
+            const snapshot = input.templateSnapshot;
+            if (!snapshot || snapshot.templateId === null)
+                return null;
+            validateSkillTestTemplatePlaceholders(snapshot.templateBody ?? "");
+            return {
+                templateId: snapshot.templateId,
+                templateName: snapshot.templateName,
+                templateBody: snapshot.templateBody,
+            };
+        }
+        const templateId = input.templateId === undefined ? BUILT_IN_SKILL_TEST_RUN_TEMPLATE_ID : input.templateId;
+        if (templateId === null)
+            return null;
+        if (templateId === BUILT_IN_SKILL_TEST_RUN_TEMPLATE_ID) {
+            const template = builtInSkillTestRunTemplate(companyId);
+            return {
+                templateId: template.id,
+                templateName: template.name,
+                templateBody: template.body,
+            };
+        }
+        const row = await db
+            .select()
+            .from(companySkillTestRunTemplates)
+            .where(and(eq(companySkillTestRunTemplates.companyId, companyId), eq(companySkillTestRunTemplates.id, templateId), isNull(companySkillTestRunTemplates.deletedAt)))
+            .then((rows) => rows[0] ?? null);
+        if (!row)
+            throw notFound("Test run template not found");
+        return {
+            templateId: row.id,
+            templateName: row.name,
+            templateBody: row.body,
+        };
+    }
+    async function ensureRunSkillVersion(companyId, skill, actor) {
+        const currentSnapshot = serializeVersionFileInventory(await collectVersionFileInventory(companyId, skill));
+        if (currentSnapshot.length === 0) {
+            throw unprocessable("Cannot run a skill test for a skill with zero files.");
+        }
+        const currentVersion = await getCurrentVersion(skill);
+        if (!currentVersion || !versionInventorySnapshotEqual(currentVersion.fileInventory, currentSnapshot)) {
+            return createVersion(companyId, skill.id, { label: "Auto version for test run" }, actor);
+        }
+        return currentVersion;
+    }
+    function snapshotAgentConfig(agent) {
+        if (!agent)
+            return {};
+        const adapterConfig = isPlainRecord(agent.adapterConfig) ? agent.adapterConfig : {};
+        const runtimeConfig = isPlainRecord(agent.runtimeConfig) ? agent.runtimeConfig : {};
+        return {
+            agentId: agent.id,
+            name: agent.name,
+            role: agent.role,
+            adapterType: agent.adapterType,
+            model: asString(adapterConfig.model) ?? asString(runtimeConfig.model) ?? null,
+            adapterConfig,
+            runtimeConfig,
+            assignedSkills: isPlainRecord(adapterConfig.paperclipSkillSync)
+                ? adapterConfig.paperclipSkillSync
+                : null,
+            instructionsRef: asString(adapterConfig.instructionsFilePath) ??
+                asString(adapterConfig.instructionsPath) ??
+                asString(adapterConfig.instructionsRef) ??
+                null,
+        };
+    }
+    async function testRunCostByIssueIds(companyId, issueIds) {
+        if (issueIds.length === 0)
+            return new Map();
+        const rows = await db
+            .select({
+            issueId: costEvents.issueId,
+            costCents: sql `coalesce(sum(${costEvents.costCents}), 0)::int`,
+            inputTokens: sql `coalesce(sum(${costEvents.inputTokens}), 0)::int`,
+            cachedInputTokens: sql `coalesce(sum(${costEvents.cachedInputTokens}), 0)::int`,
+            outputTokens: sql `coalesce(sum(${costEvents.outputTokens}), 0)::int`,
+        })
+            .from(costEvents)
+            .where(and(eq(costEvents.companyId, companyId), inArray(costEvents.issueId, issueIds)))
+            .groupBy(costEvents.issueId);
+        return new Map(rows.flatMap((row) => row.issueId
+            ? [[row.issueId, {
+                        costCents: Number(row.costCents ?? 0),
+                        inputTokens: Number(row.inputTokens ?? 0),
+                        cachedInputTokens: Number(row.cachedInputTokens ?? 0),
+                        outputTokens: Number(row.outputTokens ?? 0),
+                    }]]
+            : []));
+    }
+    async function hydrateTestRuns(companyId, rows) {
+        const costByIssueId = await testRunCostByIssueIds(companyId, rows.map((row) => row.issueId));
+        return rows.map((row) => toCompanySkillTestRun(row, costByIssueId.get(row.issueId) ?? emptyTestRunCost(), Boolean(row.harnessIssueDeletedAt)));
+    }
+    async function createTestRun(companyId, skillId, input, actor, deps) {
+        const skill = await getById(companyId, skillId);
+        if (!skill)
+            throw notFound("Skill not found");
+        const agent = await agents.getById(input.agentId);
+        if (!agent || agent.companyId !== companyId)
+            throw notFound("Agent not found");
+        if (agent.status === "paused")
+            throw unprocessable("Paused agents cannot run skill tests.");
+        const sourceInput = input.inputId
+            ? await db
+                .select()
+                .from(companySkillTestInputs)
+                .where(and(eq(companySkillTestInputs.companyId, companyId), eq(companySkillTestInputs.skillId, skillId), eq(companySkillTestInputs.id, input.inputId), isNull(companySkillTestInputs.deletedAt)))
+                .then((rows) => rows[0] ?? null)
+            : null;
+        if (input.inputId && !sourceInput)
+            throw notFound("Test input not found");
+        const inputSnapshot = (sourceInput?.content ?? input.content ?? "").trim();
+        if (!inputSnapshot)
+            throw unprocessable("Test input content cannot be empty.");
+        // Re-run pins the viewed run's version so the new run reproduces the same
+        // snapshots; a plain run auto-snapshots the live head.
+        const version = input.skillVersionId
+            ? await getVersion(companyId, skillId, input.skillVersionId)
+            : await ensureRunSkillVersion(companyId, skill, actor);
+        if (!version)
+            throw notFound("Skill version not found");
+        const runId = randomUUID();
+        const issueId = randomUUID();
+        const outputDocumentKey = "output";
+        const templateSnapshot = await resolveTestRunTemplateSnapshot(companyId, input);
+        const renderedTemplateBody = templateSnapshot?.templateBody
+            ? renderSkillTestTemplate(templateSnapshot.templateBody, {
+                skillName: skill.name,
+                skillKey: skill.key,
+                skillInvocation: skill.key,
+                skillVersion: String(version.revisionNumber),
+                runId,
+                issueId,
+                outputDocumentKey,
+            }).trim()
+            : null;
+        const harnessIssueDescription = buildHarnessIssueDescription(inputSnapshot, renderedTemplateBody);
+        await deps.createHarnessIssue({
+            id: issueId,
+            title: `Skill test: ${skill.name}`,
+            description: harnessIssueDescription,
+            assigneeAgentId: agent.id,
+            harnessKind: "skill_test",
+            workMode: "skill_test",
+            status: "todo",
+            originKind: "skill_test",
+            originId: runId,
+            originFingerprint: `skill_test:${runId}`,
+        });
+        const now = new Date();
+        const retentionDays = Math.max(0, deps.retentionDays ?? 7);
+        const previousExpiresAt = new Date(now.getTime() + retentionDays * 24 * 60 * 60 * 1000);
+        const cleanupCreatedHarnessIssue = async () => {
+            await deps.cleanupHarnessIssue?.(issueId).catch(() => { });
+        };
+        const row = await db.transaction(async (tx) => {
+            await tx
+                .update(companySkillTestRuns)
+                .set({
+                supersededAt: now,
+                status: sql `
+            case when ${companySkillTestRuns.status} in ('queued', 'running')
+              then 'cancelled'
+              else ${companySkillTestRuns.status}
+            end
+          `,
+                error: sql `
+            case when ${companySkillTestRuns.status} in ('queued', 'running')
+              then coalesce(${companySkillTestRuns.error}, 'Superseded by newer run')
+              else ${companySkillTestRuns.error}
+            end
+          `,
+                harnessIssueExpiresAt: previousExpiresAt,
+                updatedAt: now,
+            })
+                .where(and(eq(companySkillTestRuns.companyId, companyId), eq(companySkillTestRuns.skillId, skillId), sourceInput?.id
+                ? eq(companySkillTestRuns.inputId, sourceInput.id)
+                : isNull(companySkillTestRuns.inputId), isNull(companySkillTestRuns.supersededAt)));
+            return await tx
+                .insert(companySkillTestRuns)
+                .values({
+                id: runId,
+                companyId,
+                skillId,
+                inputId: sourceInput?.id ?? null,
+                inputSnapshot,
+                skillVersionId: version.id,
+                agentId: agent.id,
+                agentConfigSnapshot: snapshotAgentConfig(agent),
+                issueId,
+                templateId: templateSnapshot?.templateId ?? null,
+                templateName: templateSnapshot?.templateName ?? null,
+                templateBody: templateSnapshot?.templateBody ?? null,
+                renderedTemplateBody,
+                harnessIssueDescription,
+                status: "queued",
+                outputDocumentKey,
+            })
+                .returning()
+                .then((rows) => rows[0] ?? null);
+        }).catch(async (error) => {
+            await cleanupCreatedHarnessIssue();
+            throw error;
+        });
+        if (!row) {
+            await cleanupCreatedHarnessIssue();
+            throw notFound("Failed to persist skill test run");
+        }
+        await deps.wakeHarnessIssue(issueId, agent.id);
+        return (await hydrateTestRuns(companyId, [row]))[0];
+    }
+    async function listTestRuns(companyId, skillId, query = {}) {
+        const skill = await getById(companyId, skillId);
+        if (!skill)
+            throw notFound("Skill not found");
+        const conditions = [
+            eq(companySkillTestRuns.companyId, companyId),
+            eq(companySkillTestRuns.skillId, skillId),
+            isNull(companySkillTestRuns.deletedAt),
+        ];
+        if (query.inputId)
+            conditions.push(eq(companySkillTestRuns.inputId, query.inputId));
+        const rows = await db
+            .select()
+            .from(companySkillTestRuns)
+            .where(and(...conditions))
+            .orderBy(desc(companySkillTestRuns.createdAt), desc(companySkillTestRuns.id));
+        return hydrateTestRuns(companyId, rows);
+    }
+    async function getTestRunDetail(companyId, skillId, runId) {
+        const row = await db
+            .select()
+            .from(companySkillTestRuns)
+            .where(and(eq(companySkillTestRuns.companyId, companyId), eq(companySkillTestRuns.skillId, skillId), eq(companySkillTestRuns.id, runId), isNull(companySkillTestRuns.deletedAt)))
+            .then((rows) => rows[0] ?? null);
+        if (!row)
+            return null;
+        const [run] = await hydrateTestRuns(companyId, [row]);
+        if (!run)
+            return null;
+        const harnessIssueGone = Boolean(row.harnessIssueDeletedAt);
+        const [version, issue, documentRows, interactionRows, attachmentRows, workProductRows] = await Promise.all([
+            getVersion(companyId, skillId, row.skillVersionId),
+            harnessIssueGone
+                ? Promise.resolve(null)
+                : db
+                    .select({
+                    id: issues.id,
+                    identifier: issues.identifier,
+                    title: issues.title,
+                    status: issues.status,
+                    hiddenAt: issues.hiddenAt,
+                })
+                    .from(issues)
+                    .where(and(eq(issues.companyId, companyId), eq(issues.id, row.issueId)))
+                    .then((rows) => rows[0] ?? null),
+            harnessIssueGone
+                ? Promise.resolve([])
+                : db
+                    .select(issueDocumentSelect)
+                    .from(issueDocuments)
+                    .innerJoin(documents, eq(issueDocuments.documentId, documents.id))
+                    .where(and(eq(issueDocuments.companyId, companyId), eq(issueDocuments.issueId, row.issueId)))
+                    .orderBy(asc(issueDocuments.key)),
+            harnessIssueGone
+                ? Promise.resolve([])
+                : db
+                    .select({
+                    id: issueThreadInteractions.id,
+                    kind: issueThreadInteractions.kind,
+                    status: issueThreadInteractions.status,
+                    title: issueThreadInteractions.title,
+                    createdAt: issueThreadInteractions.createdAt,
+                    updatedAt: issueThreadInteractions.updatedAt,
+                })
+                    .from(issueThreadInteractions)
+                    .where(and(eq(issueThreadInteractions.companyId, companyId), eq(issueThreadInteractions.issueId, row.issueId)))
+                    .orderBy(desc(issueThreadInteractions.createdAt)),
+            harnessIssueGone
+                ? Promise.resolve([])
+                : db
+                    .select({
+                    id: issueAttachments.id,
+                    companyId: issueAttachments.companyId,
+                    issueId: issueAttachments.issueId,
+                    issueCommentId: issueAttachments.issueCommentId,
+                    assetId: issueAttachments.assetId,
+                    provider: assets.provider,
+                    objectKey: assets.objectKey,
+                    contentType: assets.contentType,
+                    byteSize: assets.byteSize,
+                    sha256: assets.sha256,
+                    originalFilename: assets.originalFilename,
+                    createdByAgentId: assets.createdByAgentId,
+                    createdByUserId: assets.createdByUserId,
+                    createdAt: issueAttachments.createdAt,
+                    updatedAt: issueAttachments.updatedAt,
+                })
+                    .from(issueAttachments)
+                    .innerJoin(assets, eq(issueAttachments.assetId, assets.id))
+                    .where(and(eq(issueAttachments.companyId, companyId), eq(issueAttachments.issueId, row.issueId)))
+                    .orderBy(desc(issueAttachments.createdAt)),
+            harnessIssueGone
+                ? Promise.resolve([])
+                : db
+                    .select()
+                    .from(issueWorkProducts)
+                    .where(and(eq(issueWorkProducts.companyId, companyId), eq(issueWorkProducts.issueId, row.issueId)))
+                    .orderBy(desc(issueWorkProducts.isPrimary), desc(issueWorkProducts.updatedAt)),
+        ]);
+        if (!version)
+            throw notFound("Skill version not found");
+        const harnessAvailable = !harnessIssueGone && issue !== null;
+        const harnessDocuments = harnessAvailable
+            ? documentRows.map((doc) => ({
+                ...mapIssueDocumentRow(doc, false),
+                format: doc.format,
+                body: doc.latestBody,
+            }))
+            : [];
+        const harnessAttachments = harnessAvailable
+            ? attachmentRows.map((attachment) => ({
+                ...attachment,
+                contentPath: `/api/attachments/${attachment.id}/content`,
+                openPath: `/api/attachments/${attachment.id}/content`,
+                downloadPath: `/api/attachments/${attachment.id}/content?download=1`,
+            }))
+            : [];
+        const harnessWorkProducts = harnessAvailable ? workProductRows.map(toIssueWorkProduct) : [];
+        const harnessContent = {
+            available: harnessAvailable,
+            unavailableReason: harnessAvailable
+                ? null
+                : harnessIssueGone
+                    ? (row.harnessIssueExpiresAt && row.harnessIssueDeletedAt && row.harnessIssueExpiresAt <= row.harnessIssueDeletedAt
+                        ? "expired"
+                        : "deleted")
+                    : "missing",
+            documents: harnessDocuments,
+            attachments: harnessAttachments,
+            workProducts: harnessWorkProducts,
+        };
+        return {
+            ...run,
+            skillVersion: version,
+            outputBody: run.outputSnapshot,
+            harnessContent,
+            harnessIssue: issue ? {
+                id: issue.id,
+                identifier: issue.identifier ?? null,
+                title: issue.title,
+                status: issue.status,
+                hiddenAt: issue.hiddenAt ?? null,
+            } : null,
+            documents: harnessDocuments.map((doc) => ({
+                key: doc.key,
+                title: doc.title ?? null,
+                updatedAt: doc.updatedAt,
+                body: doc.body,
+            })),
+            interactions: interactionRows.map((interaction) => ({
+                id: interaction.id,
+                kind: interaction.kind,
+                status: interaction.status,
+                title: interaction.title ?? interaction.kind,
+                createdAt: interaction.createdAt,
+                updatedAt: interaction.updatedAt,
+            })),
+            artifacts: [
+                ...harnessAttachments.map((attachment) => ({
+                    id: attachment.id,
+                    kind: "attachment",
+                    title: attachment.originalFilename ?? "Attachment",
+                    summary: null,
+                    createdAt: attachment.createdAt,
+                })),
+                ...harnessWorkProducts.map((product) => ({
+                    id: product.id,
+                    kind: "work_product",
+                    title: product.title,
+                    summary: product.summary ?? null,
+                    createdAt: product.createdAt,
+                })),
+            ].sort((left, right) => right.createdAt.getTime() - left.createdAt.getTime()),
+        };
+    }
+    async function completeTestRunForIssue(input) {
+        const row = await db
+            .select()
+            .from(companySkillTestRuns)
+            .where(and(eq(companySkillTestRuns.companyId, input.companyId), eq(companySkillTestRuns.issueId, input.issueId), isNull(companySkillTestRuns.deletedAt), isNull(companySkillTestRuns.supersededAt)))
+            .then((rows) => rows[0] ?? null);
+        if (!row || ["succeeded", "failed", "cancelled"].includes(row.status))
+            return row
+                ? (await hydrateTestRuns(input.companyId, [row]))[0] ?? null
+                : null;
+        const outputDocumentKey = row.outputDocumentKey || "output";
+        const outputDocument = await db
+            .select({ body: documents.latestBody })
+            .from(issueDocuments)
+            .innerJoin(documents, eq(issueDocuments.documentId, documents.id))
+            .where(and(eq(issueDocuments.companyId, input.companyId), eq(issueDocuments.issueId, input.issueId), eq(issueDocuments.key, outputDocumentKey)))
+            .then((rows) => rows[0] ?? null);
+        const updated = await db
+            .update(companySkillTestRuns)
+            .set({
+            status: input.outcome,
+            outputSnapshot: outputDocument?.body ?? row.outputSnapshot ?? "",
+            error: input.error ?? null,
+            updatedAt: new Date(),
+        })
+            .where(and(eq(companySkillTestRuns.companyId, input.companyId), eq(companySkillTestRuns.id, row.id)))
+            .returning()
+            .then((rows) => rows[0] ?? null);
+        return updated ? (await hydrateTestRuns(input.companyId, [updated]))[0] ?? null : null;
+    }
+    async function markTestRunRunning(companyId, issueId) {
+        const row = await db
+            .update(companySkillTestRuns)
+            .set({ status: "running", updatedAt: new Date() })
+            .where(and(eq(companySkillTestRuns.companyId, companyId), eq(companySkillTestRuns.issueId, issueId), eq(companySkillTestRuns.status, "queued"), isNull(companySkillTestRuns.deletedAt), isNull(companySkillTestRuns.supersededAt)))
+            .returning()
+            .then((rows) => rows[0] ?? null);
+        return row ? (await hydrateTestRuns(companyId, [row]))[0] ?? null : null;
+    }
+    async function cancelTestRun(companyId, skillId, runId, deps) {
+        const existing = await db
+            .select()
+            .from(companySkillTestRuns)
+            .where(and(eq(companySkillTestRuns.companyId, companyId), eq(companySkillTestRuns.skillId, skillId), eq(companySkillTestRuns.id, runId), isNull(companySkillTestRuns.deletedAt), isNull(companySkillTestRuns.supersededAt)))
+            .then((rows) => rows[0] ?? null);
+        if (!existing)
+            return null;
+        if (["succeeded", "failed", "cancelled"].includes(existing.status)) {
+            return (await hydrateTestRuns(companyId, [existing]))[0] ?? null;
+        }
+        await deps.cancelHarnessIssue(existing.issueId);
+        return completeTestRunForIssue({
+            companyId,
+            issueId: existing.issueId,
+            outcome: "cancelled",
+            error: "Cancelled by operator",
+        });
+    }
+    async function deleteTestRun(companyId, skillId, runId, deps) {
+        const existing = await db
+            .select()
+            .from(companySkillTestRuns)
+            .where(and(eq(companySkillTestRuns.companyId, companyId), eq(companySkillTestRuns.skillId, skillId), eq(companySkillTestRuns.id, runId), isNull(companySkillTestRuns.deletedAt)))
+            .then((rows) => rows[0] ?? null);
+        if (!existing)
+            return null;
+        // Only terminal runs are deletable — an in-flight run must be cancelled first
+        // so we never orphan a live harness task.
+        if (!["succeeded", "failed", "cancelled"].includes(existing.status)) {
+            throw unprocessable("Cancel the run before deleting it.");
+        }
+        const now = new Date();
+        const updated = await db.transaction(async (tx) => {
+            return await tx
+                .update(companySkillTestRuns)
+                .set({ deletedAt: now, harnessIssueDeletedAt: existing.harnessIssueDeletedAt ?? now, updatedAt: now })
+                .where(and(eq(companySkillTestRuns.companyId, companyId), eq(companySkillTestRuns.id, runId)))
+                .returning()
+                .then((rows) => rows[0] ?? null);
+        });
+        // Hide the (already-terminal) harness task so the deleted run leaves nothing
+        // dangling on the board; best-effort, run row is the source of truth.
+        if (!existing.harnessIssueDeletedAt) {
+            await deps.hideHarnessIssue(existing.issueId).catch(() => { });
+        }
+        return updated ? (await hydrateTestRuns(companyId, [updated]))[0] ?? null : null;
+    }
+    async function pruneExpiredTestHarnessIssues(companyId, now = new Date()) {
+        const rows = await db
+            .select({
+            id: companySkillTestRuns.id,
+            issueId: companySkillTestRuns.issueId,
+        })
+            .from(companySkillTestRuns)
+            .where(and(eq(companySkillTestRuns.companyId, companyId), lt(companySkillTestRuns.harnessIssueExpiresAt, now), isNull(companySkillTestRuns.harnessIssueDeletedAt)));
+        for (const row of rows) {
+            await db.transaction(async (tx) => {
+                await tx
+                    .update(issues)
+                    .set({ hiddenAt: now, updatedAt: now })
+                    .where(and(eq(issues.companyId, companyId), eq(issues.id, row.issueId), eq(issues.harnessKind, "skill_test")));
+                await tx
+                    .update(companySkillTestRuns)
+                    .set({ harnessIssueDeletedAt: now, updatedAt: now })
+                    .where(and(eq(companySkillTestRuns.companyId, companyId), eq(companySkillTestRuns.id, row.id)));
+            });
+        }
+        return { pruned: rows.length };
+    }
     async function deleteSkill(companyId, skillId) {
         const row = await db
             .select()
@@ -3781,16 +4947,18 @@ export function companySkillService(db) {
         listFull,
         getById,
         getByKey,
+        getByRouteRef,
         resolveRequestedSkillKeys: async (companyId, requestedReferences) => {
             const skills = await listFull(companyId);
             return resolveRequestedSkillKeysOrThrow(skills, requestedReferences);
         },
-        resolveRequestedSkillEntries: async (companyId, requestedSelections) => {
+        resolveRequestedSkillEntries: async (companyId, requestedSelections, options) => {
             const skills = await listFull(companyId);
-            return resolveRequestedSkillEntriesOrThrow(db, companyId, skills, requestedSelections);
+            return resolveRequestedSkillEntriesOrThrow(db, companyId, skills, requestedSelections, options);
         },
         categoryCounts,
         detail,
+        forkPrecheck,
         listVersions,
         getVersion,
         createVersion,
@@ -3805,8 +4973,25 @@ export function companySkillService(db) {
         readFile,
         updateSkill,
         updateFile,
+        deleteFile,
         createLocalSkill,
         deleteSkill,
+        listTestInputs,
+        createTestInput,
+        updateTestInput,
+        deleteTestInput,
+        listTestRunTemplates,
+        createTestRunTemplate,
+        updateTestRunTemplate,
+        deleteTestRunTemplate,
+        createTestRun,
+        listTestRuns,
+        getTestRunDetail,
+        completeTestRunForIssue,
+        markTestRunRunning,
+        cancelTestRun,
+        deleteTestRun,
+        pruneExpiredTestHarnessIssues,
         importFromSource,
         installFromCatalog,
         scanProjectWorkspaces,