@jingyi0605/codingns 0.4.0 → 0.5.0

package/dist/server/modules/skills/skill-controller.js

@@ -10,7 +10,12 @@ export class SkillController {
     };
     add = async (request, reply) => {
         requireUserId(request);
-        reply.send(this.skillManagerService.addManagedSkill(request.body ?? { sourcePath: "", targetCli: [], sourceType: "local-import" }));
+        const body = request.body;
+        if (isMarkdownSkillInput(body)) {
+            reply.send(this.skillManagerService.addManagedSkillFromMarkdown(body));
+            return;
+        }
+        reply.send(this.skillManagerService.addManagedSkill(body ?? { sourcePath: "", targetCli: [], sourceType: "local-import" }));
     };
     import = async (request, reply) => {
         requireUserId(request);
@@ -21,6 +26,9 @@ export class SkillController {
         reply.send(this.skillManagerService.syncManagedSkill(request.body ?? { skillId: "", targetCli: [] }));
     };
 }
+function isMarkdownSkillInput(input) {
+    return Boolean(input && "markdownContent" in input && typeof input.markdownContent === "string");
+}
 function normalizeTargetCliQuery(query) {
     if (!query?.targetCli) {
         return {};

package/dist/server/modules/skills/skill-controller.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill-controller.js","sourceRoot":"","sources":["../../../../src/modules/skills/skill-controller.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAazD,MAAM,OAAO,eAAe;IACG;IAA7B,YAA6B,mBAAwC;QAAxC,wBAAmB,GAAnB,mBAAmB,CAAqB;IAAG,CAAC;IAEhE,WAAW,GAAG,KAAK,EAC1B,OAA4D,EAC5D,KAAmB,EACJ,EAAE;QACjB,aAAa,CAAC,OAAO,CAAC,CAAC;QACvB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,uBAAuB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC3F,CAAC,CAAC;IAEO,GAAG,GAAG,KAAK,EAClB,OAAuD,EACvD,KAAmB,EACJ,EAAE;QACjB,aAAa,CAAC,OAAO,CAAC,CAAC;QACvB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC;IACtI,CAAC,CAAC;IAEO,MAAM,GAAG,KAAK,EACrB,OAA4D,EAC5D,KAAmB,EACJ,EAAE;QACjB,aAAa,CAAC,OAAO,CAAC,CAAC;QACvB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACvH,CAAC,CAAC;IAEO,IAAI,GAAG,KAAK,EACnB,OAAwD,EACxD,KAAmB,EACJ,EAAE;QACjB,aAAa,CAAC,OAAO,CAAC,CAAC;QACvB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACxG,CAAC,CAAC;CACH;AAED,SAAS,uBAAuB,CAAC,KAAqC;IACpE,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;QACtB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC;QAC9C,CAAC,CAAC,KAAK,CAAC,SAAS;QACjB,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAE1E,OAAO;QACL,SAAS,EAAE,SAA2C;KACvD,CAAC;AACJ,CAAC"}
+{"version":3,"file":"skill-controller.js","sourceRoot":"","sources":["../../../../src/modules/skills/skill-controller.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAczD,MAAM,OAAO,eAAe;IACG;IAA7B,YAA6B,mBAAwC;QAAxC,wBAAmB,GAAnB,mBAAmB,CAAqB;IAAG,CAAC;IAEhE,WAAW,GAAG,KAAK,EAC1B,OAA4D,EAC5D,KAAmB,EACJ,EAAE;QACjB,aAAa,CAAC,OAAO,CAAC,CAAC;QACvB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,uBAAuB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC3F,CAAC,CAAC;IAEO,GAAG,GAAG,KAAK,EAClB,OAA0F,EAC1F,KAAmB,EACJ,EAAE;QACjB,aAAa,CAAC,OAAO,CAAC,CAAC;QACvB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QAE1B,IAAI,oBAAoB,CAAC,IAAI,CAAC,EAAE,CAAC;YAC/B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC,CAAC;YACvE,OAAO;QACT,CAAC;QAED,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,eAAe,CAAC,IAAI,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC;IAC9H,CAAC,CAAC;IAEO,MAAM,GAAG,KAAK,EACrB,OAA4D,EAC5D,KAAmB,EACJ,EAAE;QACjB,aAAa,CAAC,OAAO,CAAC,CAAC;QACvB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACvH,CAAC,CAAC;IAEO,IAAI,GAAG,KAAK,EACnB,OAAwD,EACxD,KAAmB,EACJ,EAAE;QACjB,aAAa,CAAC,OAAO,CAAC,CAAC;QACvB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACxG,CAAC,CAAC;CACH;AAED,SAAS,oBAAoB,CAC3B,KAA0E;IAE1E,OAAO,OAAO,CAAC,KAAK,IAAI,iBAAiB,IAAI,KAAK,IAAI,OAAO,KAAK,CAAC,eAAe,KAAK,QAAQ,CAAC,CAAC;AACnG,CAAC;AAED,SAAS,uBAAuB,CAAC,KAAqC;IACpE,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;QACtB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC;QAC9C,CAAC,CAAC,KAAK,CAAC,SAAS;QACjB,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAE1E,OAAO;QACL,SAAS,EAAE,SAA2C;KACvD,CAAC;AACJ,CAAC"}

package/dist/server/modules/skills/skill-manager-service.d.ts

@@ -1,4 +1,4 @@
-import type { ManagedSkillRecord, SkillSourceType, SkillScanResult, SkillTargetBindingRecord, SkillTargetCli, SkillTargetSyncStatus } from "../../types/domain.js";
+import type { ManagedSkillRecord, SkillScope, SkillSourceType, SkillScanResult, SkillTargetBindingRecord, SkillTargetCli, SkillTargetSyncStatus } from "../../types/domain.js";
 import type { ManagedSkillRepository } from "../../storage/repositories/managed-skill-repository.js";
 import type { SkillTargetBindingRepository } from "../../storage/repositories/skill-target-binding-repository.js";
 import { type SkillTargetAdapter } from "./skill-target-adapter.js";
@@ -11,6 +11,14 @@ export interface AddManagedSkillInput {
     sourcePath: string;
     targetCli: readonly SkillTargetCli[];
     sourceType: SkillSourceType;
+    scope?: SkillScope;
+}
+export interface AddManagedSkillFromMarkdownInput {
+    markdownContent: string;
+    targetCli: readonly SkillTargetCli[];
+    fileName?: string | null;
+    directoryName?: string | null;
+    scope?: SkillScope;
 }
 export interface SyncManagedSkillInput {
     skillId: string;
@@ -45,6 +53,18 @@ export interface ManagedSkillOverviewItem {
     bindings: SkillTargetBindingRecord[];
     ssotPath: string;
 }
+export interface AssistantRuntimeSkillOverviewItem {
+    name: string;
+    directoryName: string;
+    sourcePath: string;
+    usedByTargetCli: readonly SkillTargetCli[];
+}
+export interface AssistantRuntimeSkillSource {
+    name: string;
+    directoryName: string;
+    sourcePath: string;
+    usedByTargetCli: readonly SkillTargetCli[];
+}
 export interface SkillOverviewResult {
     summary: {
         managedSkillCount: number;
@@ -54,6 +74,7 @@ export interface SkillOverviewResult {
         diagnosticCount: number;
     };
     managedSkills: ManagedSkillOverviewItem[];
+    assistantRuntimeSkills: AssistantRuntimeSkillOverviewItem[];
     managedEntries: SkillScanResult["managed"];
     unmanagedEntries: SkillScanResult["unmanaged"];
     conflictedEntries: SkillScanResult["conflicted"];
@@ -76,7 +97,9 @@ export declare class SkillManagerService {
     scanSkills(options?: ScanSkillsOptions): SkillScanResult;
     getOverview(options?: ScanSkillsOptions): SkillOverviewResult;
     addManagedSkill(input: AddManagedSkillInput): ManagedSkillMutationResult;
+    addManagedSkillFromMarkdown(input: AddManagedSkillFromMarkdownInput): ManagedSkillMutationResult;
     syncManagedSkill(input: SyncManagedSkillInput): ManagedSkillMutationResult;
+    listAssistantRuntimeSkillSources(targetCli?: readonly SkillTargetCli[]): AssistantRuntimeSkillSource[];
     ensureBuiltinSkill(input: EnsureBuiltinSkillInput): ManagedSkillMutationResult;
     importUnmanagedSkill(input: ImportUnmanagedSkillInput): ManagedSkillMutationResult;
     private syncManagedSkillRecord;
@@ -87,6 +110,8 @@ export declare class SkillManagerService {
     private resolveSsotPath;
     private createManagedSkillId;
     private now;
+    private registerManagedSkillFromSource;
+    private upsertAssistantRuntimeBindings;
 }
 export declare function readSkillDirectorySnapshot(targetCli: SkillTargetCli, rootDir: string, directoryPath: string): DiscoveredSkillDirectory;
 export declare function computeSkillDirectoryHash(directoryPath: string): string;

package/dist/server/modules/skills/skill-manager-service.js

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { AppError } from "../../shared/errors/app-error.js";
 import { createId } from "../../shared/utils/id.js";
@@ -7,6 +8,10 @@ import { nowIso } from "../../shared/utils/time.js";
 import { resolveSkillTargetLocation } from "./skill-target-adapter.js";
 import { SkillReconciler } from "./skill-reconciler.js";
 import { SkillSyncPlanner } from "./skill-sync-planner.js";
+import { getReservedAssistantSkillErrorDetail, isReservedAssistantSkillDirectoryName } from "./skill-name-policy.js";
+import { listAssistantRuntimeSkills } from "./assistant-runtime-skill-catalog.js";
+const ASSISTANT_RUNTIME_TARGETS = ["codex", "claude-code"];
+const ASSISTANT_RUNTIME_SSOT_DIRNAME = ".assistant-runtime";
 export class SkillManagerService {
     managedSkillRepository;
     skillTargetBindingRepository;
@@ -31,24 +36,43 @@ export class SkillManagerService {
             discoveredDirectories.push(...scanResult.directories);
             diagnostics.push(...scanResult.diagnostics);
         }
-        const managedSkills = this.managedSkillRepository.list();
-        const bindings = managedSkills.flatMap((skill) => this.skillTargetBindingRepository.listBySkillId(skill.id));
-        return this.skillReconciler.reconcile({
+        const publicManagedSkills = this.managedSkillRepository
+            .list()
+            .filter((skill) => skill.scope === "workspace")
+            .filter((skill) => !isReservedAssistantSkillDirectoryName(skill.directoryName));
+        const bindings = publicManagedSkills.flatMap((skill) => this.skillTargetBindingRepository.listBySkillId(skill.id));
+        const reservedDirectories = discoveredDirectories.filter((directory) => isReservedAssistantSkillDirectoryName(directory.directoryName));
+        const publicDirectories = discoveredDirectories.filter((directory) => !isReservedAssistantSkillDirectoryName(directory.directoryName));
+        const result = this.skillReconciler.reconcile({
             targetLocations,
-            directories: discoveredDirectories,
-            managedSkills,
+            directories: publicDirectories,
+            managedSkills: publicManagedSkills,
             bindings,
             diagnostics,
             scannedAt: nowIso()
         });
+        const reservedDiagnostics = reservedDirectories.map((directory) => createReservedSkillDiagnostic(directory));
+        const reservedEntries = reservedDirectories.map((directory) => createReservedSkillScanEntry(directory));
+        return {
+            managed: result.managed,
+            unmanaged: result.unmanaged,
+            conflicted: sortSkillScanEntries([...result.conflicted, ...reservedEntries]),
+            diagnostics: sortSkillScanDiagnostics([...result.diagnostics, ...reservedDiagnostics]),
+            scannedAt: result.scannedAt
+        };
     }
     getOverview(options = {}) {
         const scanResult = this.scanSkills(options);
-        const managedSkills = this.managedSkillRepository.list().map((skill) => ({
+        const managedSkills = this.managedSkillRepository
+            .list()
+            .filter((skill) => skill.scope === "workspace")
+            .filter((skill) => !isReservedAssistantSkillDirectoryName(skill.directoryName))
+            .map((skill) => ({
             skill,
             bindings: this.skillTargetBindingRepository.listBySkillId(skill.id),
-            ssotPath: this.resolveSsotPath(skill.directoryName)
+            ssotPath: this.resolveSsotPath(skill.scope, skill.directoryName)
         }));
+        const assistantRuntimeSkills = this.listAssistantRuntimeSkillSources();
         return {
             summary: {
                 managedSkillCount: managedSkills.length,
@@ -58,6 +82,7 @@ export class SkillManagerService {
                 diagnosticCount: scanResult.diagnostics.length
             },
             managedSkills,
+            assistantRuntimeSkills,
             managedEntries: scanResult.managed,
             unmanagedEntries: scanResult.unmanaged,
             conflictedEntries: scanResult.conflicted,
@@ -68,52 +93,37 @@ export class SkillManagerService {
     addManagedSkill(input) {
         const sourcePath = resolveSourceDirectoryPath(input.sourcePath);
         const sourceSnapshot = readSkillDirectorySnapshot("codex", sourcePath, sourcePath);
-        const existingSkill = this.managedSkillRepository.findByDirectoryName(sourceSnapshot.directoryName);
-        const existingBindings = existingSkill
-            ? this.skillTargetBindingRepository.listBySkillId(existingSkill.id)
-            : [];
-        const plannedTargets = this.skillSyncPlanner.planRequestedTargets(input.targetCli, existingBindings);
-        const ssotRootDir = this.requireSsotRootDir();
-        const timestamp = this.now();
-        if (existingSkill && existingSkill.contentHash !== sourceSnapshot.contentHash) {
-            throw new AppError({
-                statusCode: 409,
-                errorCode: "SKILL_NAME_CONFLICT",
-                detail: "已存在同名受管 skill，且内容与当前来源目录不一致",
-                field: "sourcePath"
+        return this.registerManagedSkillFromSource({
+            scope: input.scope ?? "workspace",
+            sourceSnapshot,
+            copySourcePath: sourcePath,
+            sourceType: input.sourceType,
+            sourcePath,
+            targetCli: input.targetCli,
+            field: "sourcePath"
+        });
+    }
+    addManagedSkillFromMarkdown(input) {
+        const prepared = prepareUploadedSkillMarkdown(input);
+        const tempRootDir = fs.mkdtempSync(path.join(os.tmpdir(), "codingns-skill-upload-"));
+        const sourcePath = path.join(tempRootDir, prepared.directoryName);
+        fs.mkdirSync(sourcePath, { recursive: true });
+        fs.writeFileSync(path.join(sourcePath, "SKILL.md"), prepared.skillMarkdown, "utf8");
+        try {
+            const sourceSnapshot = readSkillDirectorySnapshot("codex", sourcePath, sourcePath);
+            return this.registerManagedSkillFromSource({
+                scope: input.scope ?? "workspace",
+                sourceSnapshot,
+                copySourcePath: sourcePath,
+                sourceType: "local-import",
+                sourcePath: null,
+                targetCli: input.targetCli,
+                field: "markdownContent"
             });
         }
-        const skill = existingSkill
-            ? {
-                ...existingSkill,
-                name: sourceSnapshot.name,
-                sourceType: input.sourceType,
-                sourcePath,
-                contentHash: sourceSnapshot.contentHash,
-                managedState: "active",
-                updatedAt: timestamp
-            }
-            : {
-                id: this.createManagedSkillId(),
-                name: sourceSnapshot.name,
-                directoryName: sourceSnapshot.directoryName,
-                sourceType: input.sourceType,
-                sourcePath,
-                contentHash: sourceSnapshot.contentHash,
-                managedState: "active",
-                createdAt: timestamp,
-                updatedAt: timestamp
-            };
-        const ssotPath = path.join(ssotRootDir, skill.directoryName);
-        copySkillDirectory(sourcePath, ssotPath);
-        this.managedSkillRepository.upsert(skill);
-        const targetResults = this.syncManagedSkillRecord(skill, plannedTargets.map((target) => target.targetCli));
-        return {
-            skill,
-            bindings: this.skillTargetBindingRepository.listBySkillId(skill.id),
-            targetResults,
-            ssotPath
-        };
+        finally {
+            fs.rmSync(tempRootDir, { recursive: true, force: true });
+        }
     }
     syncManagedSkill(input) {
         const skillId = input.skillId.trim();
@@ -134,6 +144,15 @@ export class SkillManagerService {
                 field: "skillId"
             });
         }
+        if (skill.scope !== "workspace") {
+            throw new AppError({
+                statusCode: 409,
+                errorCode: "SKILL_SCOPE_NOT_SYNCABLE",
+                detail: "助手专用 skill 不参与工作区同步",
+                field: "skillId"
+            });
+        }
+        assertSkillDirectoryNameAllowed(skill.scope, skill.directoryName, "skillId");
         const existingBindings = this.skillTargetBindingRepository.listBySkillId(skill.id);
         const plannedTargets = this.skillSyncPlanner.planRequestedTargets(input.targetCli, existingBindings);
         const targetResults = this.syncManagedSkillRecord(skill, plannedTargets.map((target) => target.targetCli));
@@ -141,46 +160,52 @@ export class SkillManagerService {
             skill: this.managedSkillRepository.findById(skill.id) ?? skill,
             bindings: this.skillTargetBindingRepository.listBySkillId(skill.id),
             targetResults,
-            ssotPath: this.resolveSsotPath(skill.directoryName)
+            ssotPath: this.resolveSsotPath(skill.scope, skill.directoryName)
         };
     }
+    listAssistantRuntimeSkillSources(targetCli) {
+        const requestedTargets = targetCli?.length ? new Set(targetCli) : null;
+        const builtinSkills = listAssistantRuntimeSkills()
+            .filter((item) => matchesRequestedTargets(item.usedByTargetCli, requestedTargets))
+            .map((item) => ({
+            name: item.name,
+            directoryName: item.directoryName,
+            sourcePath: item.sourcePath,
+            usedByTargetCli: [...item.usedByTargetCli]
+        }));
+        const managedSkills = this.managedSkillRepository
+            .list()
+            .filter((skill) => skill.scope === "assistant")
+            .map((skill) => ({
+            skill,
+            bindings: this.skillTargetBindingRepository
+                .listBySkillId(skill.id)
+                .filter((binding) => binding.enabled && isAssistantRuntimeTarget(binding.targetCli))
+        }))
+            .filter((item) => item.bindings.length > 0)
+            .map((item) => ({
+            name: item.skill.name,
+            directoryName: item.skill.directoryName,
+            sourcePath: this.resolveSsotPath(item.skill.scope, item.skill.directoryName),
+            usedByTargetCli: item.bindings.map((binding) => binding.targetCli)
+        }))
+            .filter((item) => matchesRequestedTargets(item.usedByTargetCli, requestedTargets))
+            .filter((item) => isValidSkillDirectory(item.sourcePath));
+        return [...builtinSkills, ...managedSkills].sort((left, right) => left.directoryName.localeCompare(right.directoryName));
+    }
     ensureBuiltinSkill(input) {
         const sourcePath = resolveSourceDirectoryPath(input.sourcePath);
         const sourceSnapshot = readSkillDirectorySnapshot("codex", sourcePath, sourcePath);
-        const existingSkill = this.managedSkillRepository.findByDirectoryName(sourceSnapshot.directoryName);
-        const ssotRootDir = this.requireSsotRootDir();
-        const timestamp = this.now();
-        const skill = existingSkill
-            ? {
-                ...existingSkill,
-                name: sourceSnapshot.name,
-                sourceType: "builtin",
-                sourcePath,
-                contentHash: sourceSnapshot.contentHash,
-                managedState: "active",
-                updatedAt: timestamp
-            }
-            : {
-                id: this.createManagedSkillId(),
-                name: sourceSnapshot.name,
-                directoryName: sourceSnapshot.directoryName,
-                sourceType: "builtin",
-                sourcePath,
-                contentHash: sourceSnapshot.contentHash,
-                managedState: "active",
-                createdAt: timestamp,
-                updatedAt: timestamp
-            };
-        const ssotPath = path.join(ssotRootDir, skill.directoryName);
-        copySkillDirectory(sourcePath, ssotPath);
-        this.managedSkillRepository.upsert(skill);
-        const targetResults = this.forceSyncManagedSkillRecord(skill, input.targetCli);
-        return {
-            skill: this.managedSkillRepository.findById(skill.id) ?? skill,
-            bindings: this.skillTargetBindingRepository.listBySkillId(skill.id),
-            targetResults,
-            ssotPath
-        };
+        return this.registerManagedSkillFromSource({
+            scope: "workspace",
+            sourceSnapshot,
+            copySourcePath: sourcePath,
+            sourceType: "builtin",
+            sourcePath,
+            targetCli: input.targetCli,
+            field: "sourcePath",
+            forceSync: true
+        });
     }
     importUnmanagedSkill(input) {
         const sourceLocation = resolveSingleTargetLocation(this.targetAdapters, input.targetCli);
@@ -202,6 +227,7 @@ export class SkillManagerService {
             });
         }
         const sourceSnapshot = readSkillDirectorySnapshot(input.targetCli, sourceLocation.rootDir, directoryPath);
+        assertSkillDirectoryNameAllowed("workspace", sourceSnapshot.directoryName, "directoryPath");
         if (input.expectedContentHash
             && input.expectedContentHash.trim()
             && input.expectedContentHash.trim() !== sourceSnapshot.contentHash) {
@@ -215,11 +241,12 @@ export class SkillManagerService {
         return this.addManagedSkill({
             sourcePath: directoryPath,
             targetCli: [input.targetCli, ...(input.additionalTargetCli ?? [])],
-            sourceType: "managed-copy"
+            sourceType: "managed-copy",
+            scope: "workspace"
         });
     }
     syncManagedSkillRecord(skill, targetCli) {
-        const ssotPath = this.resolveSsotPath(skill.directoryName);
+        const ssotPath = this.resolveSsotPath(skill.scope, skill.directoryName);
         const timestamp = this.now();
         if (!isValidSkillDirectory(ssotPath)) {
             this.managedSkillRepository.upsert({
@@ -237,7 +264,7 @@ export class SkillManagerService {
         return plannedTargets.map((target) => this.syncOneTarget(skill, ssotPath, target.targetCli, timestamp));
     }
     forceSyncManagedSkillRecord(skill, targetCli) {
-        const ssotPath = this.resolveSsotPath(skill.directoryName);
+        const ssotPath = this.resolveSsotPath(skill.scope, skill.directoryName);
         const timestamp = this.now();
         if (!isValidSkillDirectory(ssotPath)) {
             this.managedSkillRepository.upsert({
@@ -368,7 +395,10 @@ export class SkillManagerService {
         }
         return path.resolve(ssotRootDir);
     }
-    resolveSsotPath(directoryName) {
+    resolveSsotPath(scope, directoryName) {
+        if (scope === "assistant") {
+            return path.join(this.requireSsotRootDir(), ASSISTANT_RUNTIME_SSOT_DIRNAME, directoryName);
+        }
         return path.join(this.requireSsotRootDir(), directoryName);
     }
     createManagedSkillId() {
@@ -377,6 +407,232 @@ export class SkillManagerService {
     now() {
         return this.options.now?.() ?? nowIso();
     }
+    registerManagedSkillFromSource(input) {
+        assertSkillDirectoryNameAllowed(input.scope, input.sourceSnapshot.directoryName, input.field);
+        const existingSkill = this.managedSkillRepository.findByScopeAndDirectoryName(input.scope, input.sourceSnapshot.directoryName);
+        const existingBindings = existingSkill
+            ? this.skillTargetBindingRepository.listBySkillId(existingSkill.id)
+            : [];
+        const timestamp = this.now();
+        if (existingSkill && existingSkill.contentHash !== input.sourceSnapshot.contentHash) {
+            throw new AppError({
+                statusCode: 409,
+                errorCode: "SKILL_NAME_CONFLICT",
+                detail: "已存在同名受管 skill，且内容与当前来源目录不一致",
+                field: input.field
+            });
+        }
+        const skill = existingSkill
+            ? {
+                ...existingSkill,
+                name: input.sourceSnapshot.name,
+                scope: input.scope,
+                sourceType: input.sourceType,
+                sourcePath: input.sourcePath,
+                contentHash: input.sourceSnapshot.contentHash,
+                managedState: "active",
+                updatedAt: timestamp
+            }
+            : {
+                id: this.createManagedSkillId(),
+                name: input.sourceSnapshot.name,
+                scope: input.scope,
+                directoryName: input.sourceSnapshot.directoryName,
+                sourceType: input.sourceType,
+                sourcePath: input.sourcePath,
+                contentHash: input.sourceSnapshot.contentHash,
+                managedState: "active",
+                createdAt: timestamp,
+                updatedAt: timestamp
+            };
+        const ssotPath = this.resolveSsotPath(skill.scope, skill.directoryName);
+        copySkillDirectory(input.copySourcePath, ssotPath);
+        this.managedSkillRepository.upsert(skill);
+        const targetResults = skill.scope === "assistant"
+            ? this.upsertAssistantRuntimeBindings(skill, input.targetCli, existingBindings, timestamp, input.field)
+            : (() => {
+                const plannedTargets = this.skillSyncPlanner.planRequestedTargets(input.targetCli, existingBindings);
+                return input.forceSync
+                    ? this.forceSyncManagedSkillRecord(skill, plannedTargets.map((target) => target.targetCli))
+                    : this.syncManagedSkillRecord(skill, plannedTargets.map((target) => target.targetCli));
+            })();
+        return {
+            skill: this.managedSkillRepository.findById(skill.id) ?? skill,
+            bindings: this.skillTargetBindingRepository.listBySkillId(skill.id),
+            targetResults,
+            ssotPath
+        };
+    }
+    upsertAssistantRuntimeBindings(skill, targetCli, existingBindings, timestamp, field) {
+        const normalizedTargets = normalizeAssistantRuntimeTargets(targetCli, field);
+        const requestedTargets = new Set(normalizedTargets);
+        const knownTargets = new Set([
+            ...ASSISTANT_RUNTIME_TARGETS,
+            ...existingBindings
+                .map((binding) => binding.targetCli)
+                .filter((target) => isAssistantRuntimeTarget(target))
+        ]);
+        for (const target of knownTargets) {
+            const enabled = requestedTargets.has(target);
+            this.skillTargetBindingRepository.upsert(buildBindingRecord(skill.id, target, {
+                enabled,
+                syncStatus: enabled ? "synced" : "pending",
+                lastSyncedAt: enabled ? timestamp : null,
+                lastErrorCode: null,
+                lastErrorDetail: null
+            }));
+        }
+        return normalizedTargets.map((target) => ({
+            targetCli: target,
+            targetDir: buildAssistantRuntimeTargetRef(target, skill.directoryName),
+            syncStatus: "synced",
+            lastSyncedAt: timestamp,
+            errorCode: null,
+            errorDetail: null
+        }));
+    }
+}
+function assertSkillDirectoryNameAllowed(scope, directoryName, field) {
+    if (scope === "workspace" && !isReservedAssistantSkillDirectoryName(directoryName)) {
+        return;
+    }
+    if (scope === "assistant" && !isReservedAssistantSkillDirectoryName(directoryName)) {
+        return;
+    }
+    throw new AppError({
+        statusCode: 409,
+        errorCode: "SKILL_RESERVED_FOR_ASSISTANT_RUNTIME",
+        detail: getReservedAssistantSkillErrorDetail(directoryName),
+        field
+    });
+}
+function prepareUploadedSkillMarkdown(input) {
+    const normalizedContent = input.markdownContent.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n").trim();
+    if (!normalizedContent) {
+        throw new AppError({
+            statusCode: 400,
+            errorCode: "SKILL_SOURCE_INVALID",
+            detail: "上传内容不能为空",
+            field: "markdownContent"
+        });
+    }
+    const requestedDirectoryName = input.directoryName?.trim() ?? "";
+    const fallbackDirectoryName = requestedDirectoryName || input.fileName?.trim() || "";
+    const normalizedDirectoryName = normalizeUploadedSkillDirectoryName(fallbackDirectoryName);
+    const heading = normalizedContent.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? "";
+    if (!normalizedDirectoryName) {
+        throw new AppError({
+            statusCode: 400,
+            errorCode: "SKILL_SOURCE_INVALID",
+            detail: "上传的 skill 缺少合法目录名，请补一个只包含字母、数字、点、下划线和短横线的名称",
+            field: "directoryName"
+        });
+    }
+    const skillMarkdown = heading
+        ? `${normalizedContent}\n`
+        : `# ${formatSkillTitleFromDirectoryName(normalizedDirectoryName)}\n\n${normalizedContent}\n`;
+    return {
+        directoryName: normalizedDirectoryName,
+        skillMarkdown
+    };
+}
+function normalizeUploadedSkillDirectoryName(input) {
+    const basename = input.replace(/\\/g, "/").split("/").pop() ?? input;
+    const withoutExtension = basename.replace(/\.[A-Za-z0-9]+$/, "");
+    const normalized = withoutExtension
+        .trim()
+        .replace(/\s+/g, "-")
+        .replace(/[^A-Za-z0-9._-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^[-._]+|[-._]+$/g, "");
+    return normalized && isSafeSkillDirectoryName(normalized)
+        ? normalized
+        : null;
+}
+function formatSkillTitleFromDirectoryName(directoryName) {
+    const title = directoryName
+        .split(/[._-]+/)
+        .filter(Boolean)
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join(" ");
+    return title || directoryName;
+}
+function normalizeAssistantRuntimeTargets(targetCli, field) {
+    const normalizedTargets = Array.from(new Set(targetCli.map((item) => item.trim())));
+    if (normalizedTargets.length === 0) {
+        throw new AppError({
+            statusCode: 400,
+            errorCode: "SKILL_TARGET_NOT_SUPPORTED",
+            detail: "助手专用 skill 至少要选择一个运行时目标",
+            field
+        });
+    }
+    const invalidTarget = normalizedTargets.find((target) => !isAssistantRuntimeTarget(target));
+    if (invalidTarget) {
+        throw new AppError({
+            statusCode: 400,
+            errorCode: "SKILL_TARGET_NOT_SUPPORTED",
+            detail: "助手专用 skill 只支持 Codex 和 Claude Code",
+            field
+        });
+    }
+    return normalizedTargets;
+}
+function isAssistantRuntimeTarget(targetCli) {
+    return ASSISTANT_RUNTIME_TARGETS.includes(targetCli);
+}
+function matchesRequestedTargets(targetCli, requestedTargets) {
+    if (!requestedTargets || requestedTargets.size === 0) {
+        return true;
+    }
+    return targetCli.some((target) => requestedTargets.has(target));
+}
+function buildAssistantRuntimeTargetRef(targetCli, directoryName) {
+    return `assistant-runtime:${targetCli}/${directoryName}`;
+}
+function createReservedSkillDiagnostic(directory) {
+    return {
+        targetCli: directory.targetCli,
+        rootDir: directory.rootDir,
+        code: "SKILL_RESERVED_FOR_ASSISTANT_RUNTIME",
+        detail: getReservedAssistantSkillErrorDetail(directory.directoryName),
+        directoryName: directory.directoryName,
+        directoryPath: directory.directoryPath,
+        managedSkillId: null
+    };
+}
+function createReservedSkillScanEntry(directory) {
+    return {
+        targetCli: directory.targetCli,
+        directoryPath: directory.directoryPath,
+        directoryName: directory.directoryName,
+        name: directory.name,
+        contentHash: directory.contentHash,
+        managementState: "conflicted",
+        managedSkillId: null
+    };
+}
+function sortSkillScanEntries(entries) {
+    return entries.sort((left, right) => {
+        const targetOrder = left.targetCli.localeCompare(right.targetCli);
+        if (targetOrder !== 0) {
+            return targetOrder;
+        }
+        return left.directoryName.localeCompare(right.directoryName);
+    });
+}
+function sortSkillScanDiagnostics(diagnostics) {
+    return diagnostics.sort((left, right) => {
+        const targetOrder = left.targetCli.localeCompare(right.targetCli);
+        if (targetOrder !== 0) {
+            return targetOrder;
+        }
+        const codeOrder = left.code.localeCompare(right.code);
+        if (codeOrder !== 0) {
+            return codeOrder;
+        }
+        return (left.directoryName ?? "").localeCompare(right.directoryName ?? "");
+    });
 }
 export function readSkillDirectorySnapshot(targetCli, rootDir, directoryPath) {
     const directoryName = path.basename(directoryPath);