aiakiv 0.3.1 → 0.3.3

package/dist/mcpProbe.js

@@ -56,6 +56,29 @@ export function saveTargetFromResult(result) {
     return null;
 }
 const str = (v) => (typeof v === "string" ? v : v == null ? undefined : String(v));
+const REDIRECTS = [301, 302, 303, 307, 308];
+const MAX_REDIRECTS = 5;
+/** 넘겨주기(redirect)는 같은 출처(방식, 호스트, 포트) 안의 307, 308 만 따라간다(서버의 `/` → `/mcp` 308 같은 것).
+ * 다른 출처로 넘기면 키를 싣지 않고 멈춘다. fetch 에 맡기면 Node 18 초기 판은 다른 호스트로 넘어갈 때도
+ * Authorization 을 그대로 실었다. 301, 302, 303 은 POST 를 GET 으로 바꾸는 응답이라 따라가지 않고 그대로 돌려준다. */
+async function fetchSameOrigin(fetchImpl, url, init) {
+    let current = url;
+    for (let hop = 0;; hop += 1) {
+        const res = await fetchImpl(current, { ...init, redirect: "manual" });
+        if (!REDIRECTS.includes(res.status))
+            return res;
+        const location = res.headers.get("location");
+        if (!location || hop >= MAX_REDIRECTS || (res.status !== 307 && res.status !== 308))
+            return res;
+        const next = new URL(location, current);
+        if (next.origin !== new URL(current).origin) {
+            await res.text().catch(() => "");
+            throw new Error(`서버가 다른 주소(${next.origin})로 넘기려 해서 키를 보내지 않고 멈췄습니다`);
+        }
+        await res.text().catch(() => "");
+        current = next.href;
+    }
+}
 export async function probeSaveTarget(fetchImpl, url, key, opts = {}) {
     const timeoutMs = opts.timeoutMs ?? 20_000;
     let session = null;
@@ -67,7 +90,7 @@ export async function probeSaveTarget(fetchImpl, url, key, opts = {}) {
         "MCP-Protocol-Version": protocol,
         ...(session ? { "Mcp-Session-Id": session } : {}),
     });
-    const post = async (msg) => fetchImpl(url, {
+    const post = async (msg) => fetchSameOrigin(fetchImpl, url, {
         method: "POST",
         headers: headers(),
         body: JSON.stringify(msg),
@@ -127,7 +150,7 @@ export async function probeSaveTarget(fetchImpl, url, key, opts = {}) {
     }
     finally {
         if (session) {
-            await fetchImpl(url, { method: "DELETE", headers: headers(), signal: AbortSignal.timeout(5_000) }).catch(() => undefined);
+            await fetchSameOrigin(fetchImpl, url, { method: "DELETE", headers: headers(), signal: AbortSignal.timeout(5_000) }).catch(() => undefined);
         }
     }
 }

package/dist/setup.js

@@ -8,7 +8,7 @@
 //      것 포함)가 폐기된다. 그래서 쓸 수 있는 키가 있으면 새로 받지 않는다.
 //   3. 아니면 브라우저 인계(kind=dynamic)로 키 하나를 받는다.
 //   4. 고른 클라이언트 모두의 전역 설정 파일에 같은 키를 쓴다(다른 항목은 보존, 원자적 쓰기).
-//   5. 전역 스킬(`--no-skills` 면 건너뜀). 실패해도 설정 쓰기는 성공으로 두고 칠 명령을 보여 준다.
+//   5. 전역 스킬(이 CLI 의 npm 묶음에 든 것, `--no-skills` 면 건너뜀). 실패해도 설정 쓰기는 성공으로 두고 칠 명령을 보여 준다.
 //   6. 사람이 할 일을 안내한다.
 //
 // 키 평문은 화면, 오류 문구 어디에도 내지 않는다(키 id 만). get_save_target 은 키 id 를 돌려주지 않으므로,
@@ -23,7 +23,7 @@ import { classifyEntry } from "./doctor.js";
 import { readTextIfExists, writeFileAtomic } from "./fsutil.js";
 import { exchangeCode, handoffUrl, HANDOFF_TIMEOUT_MS, newState, oldKeysKeptNotice, scopeList, startLoopback, supersededNotice, } from "./handoff.js";
 import { probeSaveTarget } from "./mcpProbe.js";
-import { downloadSkillPack, SKILL_NAMES, SKILLS_REPO, skillsGlobalManualCommand, writeSkillsTo } from "./skills.js";
+import { BUNDLED_SKILLS_DIR, loadBundledSkills, SKILL_NAMES, SKILLS_REPO, skillsGlobalManualCommand, writeSkillsTo, } from "./skills.js";
 import { canonicalMcpUrl, controlBase } from "./urls.js";
 import { VERSION } from "./version.js";
 const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -246,15 +246,16 @@ function manualSkillsLine(t) {
         ? `직접 실행하세요: ${skillsGlobalManualCommand(t.skillsAgent)}`
         : `https://github.com/${SKILLS_REPO} 의 aiakiv/skills/ 아래 스킬 폴더들을 ${t.dir} 에 폴더째 복사하세요.`;
 }
-/** 전역 스킬 단계. 실패하면 false 와 함께 사람이 할 일을 보여 준다(예외를 내지 않는다). */
-export async function installGlobalSkills(ctx, clients) {
+/** 전역 스킬 단계. 이 CLI 에 든 스킬을 쓴다(네트워크를 쓰지 않는다). 실패하면 false 와 함께 사람이 할 일을
+ * 보여 준다(예외를 내지 않는다). `root` 는 시험용이다. */
+export async function installGlobalSkills(ctx, clients, root = BUNDLED_SKILLS_DIR) {
     const targets = clients.flatMap((c) => globalSkillsTargets(ctx, c).map((t) => ({ client: c, ...t })));
     let pack;
     try {
-        pack = await downloadSkillPack(ctx);
+        pack = loadBundledSkills(root);
     }
     catch (e) {
-        ctx.err(`전역 스킬을 받지 못했습니다(${e.message}). 연결 설정은 이미 썼습니다.`);
+        ctx.err(`전역 스킬을 쓰지 못했습니다(${e.message}). 연결 설정은 이미 썼습니다.`);
         for (const t of targets)
             ctx.err(`  ${GLOBAL_CLIENT_LABEL[t.client]}(${t.dir}): ${manualSkillsLine(t)}`);
         return false;
@@ -263,10 +264,10 @@ export async function installGlobalSkills(ctx, clients) {
     for (const t of targets) {
         try {
             const names = writeSkillsTo(t.dir, pack);
-            ctx.out(`전역 스킬 ${names.length}개: ${t.dir} (${GLOBAL_CLIENT_LABEL[t.client]}, 판 ${pack.version ?? "모름"})`);
+            ctx.out(`전역 스킬 ${names.length}개: ${t.dir} (${GLOBAL_CLIENT_LABEL[t.client]}, 스킬 버전 ${pack.version ?? "모름"})`);
             const missing = SKILL_NAMES.filter((n) => !names.includes(n));
             if (missing.length)
-                ctx.err(`  참고: 받은 스킬에 ${missing.join(", ")} 이 없습니다.`);
+                ctx.err(`  참고: 이 CLI 에 든 스킬에 ${missing.join(", ")} 이 없습니다.`);
         }
         catch (e) {
             ok = false;

package/dist/skills.js

@@ -1,9 +1,12 @@
-// 폴더 스킬. 웹 콘솔 "폴더 ZIP 받기" 와 같은 자리에 스킬 여덟 개를 넣는다
+// 폴더 스킬. 웹 콘솔 "폴더 ZIP 받기" 와 같은 자리에 스킬 여섯 개를 넣는다
 // (정본은 k2g-console-web `src/lib/folderBundle.ts` 의 SKILL_DIR 와 assertSkillPath).
 //
-// 받는 곳은 공개 저장소 AiAkiv/aiakiv-plugins 의 tar.gz(GitHub codeload). 새 의존성 없이 Node 내장
-// zlib 로 풀고 tar.ts 로 읽어, 플러그인 매니페스트(`.claude-plugin/plugin.json`)의 `skills` 자리 아래만
-// 꺼낸다. 판 번호도 그 매니페스트에서 읽는다.
+// 스킬은 이 CLI 의 npm 묶음 안 `skills/` 에 들어 있고, 네트워크에서 받지 않는다(2026-11-10 대표 결정 7).
+// 예전에는 공개 저장소 AiAkiv/aiakiv-plugins 의 가지 끝(main)을 그때그때 받아, 그 저장소가 바뀌면 확인 없이
+// 사용자 PC 에 새 내용이 깔렸다. 이제 받는 곳은 npm 하나이고, 묶음이 바뀌지 않았는지는 npm 이 확인한다.
+// 정본은 K2G `packaging/plugins/aiakiv/skills/` 이고, `scripts/sync-skills.mjs` 가 그것을 `skills/` 로 옮겨
+// 적으며 파일 목록과 sha256 을 `skills/bundle.json` 에 쓴다. 설치할 때는 그 목록에 적힌 파일만 읽고, 크기나
+// sha256 이 다르면 하나도 쓰지 않는다. 스킬 버전은 그 목록의 plugin_version(플러그인 매니페스트의 version)이다.
 //
 // 자리(클라이언트별, 폴더 기준):
 //   - Claude Code: `.claude/skills/<이름>/`
@@ -11,25 +14,30 @@
 //   - Cursor: `.agents/skills/<이름>/`. Skills CLI 1.5.18 의 cursor 설정(skillsDir)과 Cursor 문서
 //     (cursor.com/docs/context/skills 의 "Project-level") 둘 다 이 자리다(2026-10-14 확인).
 //
-// 안전: 압축 파일 안의 경로가 절대 경로이거나 `..` 를 품으면 통째로 거부한다. 스킬 자리 안의 심볼릭
-// 링크, 하드 링크, 특수 파일도 거부한다. 받기나 풀기에 실패해도 bind 는 멈추지 않는다(설정은 이미 썼다).
-import { existsSync, lstatSync, mkdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname, relative, resolve, sep } from "node:path";
-import { gunzipSync } from "node:zlib";
-import { readTar, TarError } from "./tar.js";
+// 안전: 목록의 경로가 절대 경로이거나 `..` 를 품거나 Windows 에서 쓸 수 없는 이름이면 통째로 거부한다.
+// 목록의 파일이 심볼릭 링크나 보통 파일이 아니어도 거부한다. 읽기나 쓰기에 실패해도 bind 는 멈추지 않는다
+// (설정은 이미 썼다).
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+/** 사람이 손으로 칠 Skills CLI 명령이 받는 공개 저장소. CLI 자신은 여기서 받지 않는다. */
 export const SKILLS_REPO = "AiAkiv/aiakiv-plugins";
-export const DEFAULT_SKILLS_TARBALL_URL = "https://codeload.github.com/AiAkiv/aiakiv-plugins/tar.gz/refs/heads/main";
+/** npm 묶음 안의 스킬 폴더(`dist/skills.js` 기준 `../skills/`). */
+export const BUNDLED_SKILLS_DIR = fileURLToPath(new URL("../skills/", import.meta.url));
+/** 묶음 안 스킬의 파일 목록(경로, 크기, sha256)과 스킬 버전. */
+export const SKILLS_BUNDLE_FILE = "bundle.json";
 export const SKILL_NAMES = [
     "aiakiv-onboarding",
     "aiakiv-save-and-recall",
     "aiakiv-graph-query",
     "aiakiv-links",
     "aiakiv-cards",
-    "aiakiv-console",
-    "aiakiv-contents",
-    // BP-171 P3 가 만들고 P5 가 함께 발행한다. 그 전의 설치본에는 없어 "받은 스킬에 … 이 없습니다" 가 나온다.
+    // BP-171 P3 가 만들고 P5 가 함께 발행한다.
     "aiakiv-dashboard",
 ];
+// 새 스킬을 더할 때는 여기에 이름을 넣고 scripts/sync-skills.mjs 를 다시 돌린다. 이 목록과 정본의 스킬 폴더가
+// 다르면 그 스크립트가 멈춘다.
 /** 클라이언트별 폴더 스킬 자리(폴더 기준 상대 경로). */
 export const FOLDER_SKILLS_DIR = {
     claude: ".claude/skills",
@@ -44,143 +52,94 @@ export const SKILLS_AGENT = {
     gemini: "gemini-cli",
     cursor: "cursor",
 };
-/** 받기에 실패했을 때 사람이 그 폴더에서 칠 명령. `--all` 과 `-g` 는 쓰지 않는다
+/** 스킬을 쓰지 못했을 때 사람이 그 폴더에서 칠 명령(Skills CLI 가 GitHub 저장소에서 받는다, 사람이 고를 때만). `--all` 과 `-g` 는 쓰지 않는다
  * (`--all` 은 모든 에이전트 폴더에 퍼지고, `-g` 는 폴더가 아니라 전역에 넣는다). */
 export function skillsManualCommand(agent) {
     return `npx -y skills add ${SKILLS_REPO} -a ${agent} -s '*' -y`;
 }
-/** setup(전역 설치)에서 받기에 실패했을 때 칠 명령. 전역이라 `-g` 를 붙인다. `agent` 는 Skills CLI 의
+/** setup(전역 설치)에서 스킬을 쓰지 못했을 때 칠 명령. 전역이라 `-g` 를 붙인다. `agent` 는 Skills CLI 의
  * 에이전트 이름(Skills CLI 1.5.18 에서 gemini-cli 의 전역 자리는 `~/.gemini/skills`, antigravity-cli 는
  * `~/.gemini/antigravity-cli/skills` 로 setup 이 쓰는 자리와 같다). */
 export function skillsGlobalManualCommand(agent) {
     return `npx -y skills add ${SKILLS_REPO} -a ${agent} -s '*' -g -y`;
 }
-// 내려받는 크기 한도(지금 저장소는 압축 50KB 안팎).
-const MAX_GZ_BYTES = 20 * 1024 * 1024;
-const MAX_TAR_BYTES = 64 * 1024 * 1024;
-const DOWNLOAD_TIMEOUT_MS = 60_000;
-/** 받는 주소. `AIAKIV_SKILLS_TARBALL_URL` 로 바꿀 수 있다(시험은 로컬 http 서버). */
-export function skillsTarballUrl(env) {
-    const raw = (env.AIAKIV_SKILLS_TARBALL_URL ?? "").trim() || DEFAULT_SKILLS_TARBALL_URL;
-    let u;
-    try {
-        u = new URL(raw);
-    }
-    catch {
-        throw new Error(`AIAKIV_SKILLS_TARBALL_URL 이 주소가 아닙니다: ${raw}`);
-    }
-    if (u.protocol !== "https:" && u.protocol !== "http:") {
-        throw new Error(`AIAKIV_SKILLS_TARBALL_URL 은 http 나 https 주소여야 합니다: ${raw}`);
-    }
-    return raw;
-}
-/** 압축 파일 안 경로의 기본 검사(콘솔 zip.ts 의 isSafeZipPath 와 같은 수준). 디렉터리의 끝 `/` 는 뗀 뒤 본다. */
-export function isSafeArchivePath(path) {
+/** 스킬 파일 경로(`<스킬>/<파일>`)의 검사. 절대 경로, 드라이브 문자, 역슬래시, 제어 문자, 빈 칸이나 `.`, `..`
+ * 를 거부하고, Windows 에서 쓸 수 없는 이름도 거부한다(콘솔 folderBundle.ts 의 assertSkillPath 와 같은 수준).
+ * 이름을 고치지 않는 까닭: 고치면 스킬 안의 상대 링크가 깨진다. scripts/sync-skills.mjs 도 이 검사를 쓴다. */
+export function isSafeSkillPath(path) {
     if (!path || path.startsWith("/") || path.includes("\\"))
         return false;
     if (/[\u0000-\u001f\u007f]/.test(path))
         return false;
     if (/^[A-Za-z]:/.test(path))
         return false;
-    return path.split("/").every((seg) => seg !== "" && seg !== "." && seg !== "..");
-}
-// 스킬 파일 경로 — 위 검사에 더해 Windows 에서 풀리지 않는 이름도 거부한다(folderBundle.ts 의 assertSkillPath).
-// 이름을 고치지 않는 까닭: 고치면 스킬 안의 상대 링크가 깨진다.
-function assertSkillPath(path) {
-    const ok = isSafeArchivePath(path) && path.split("/").every((seg) => !/[<>:"|?*]/.test(seg) && !/[. ]$/.test(seg));
-    if (!ok)
-        throw new TarError(`안전하지 않은 스킬 경로를 거부했습니다: ${path}`);
-}
-// 매니페스트의 skills 값(`./skills/`)을 압축 파일 안의 접두어로.
-function skillsPrefix(pluginRoot, field) {
-    const rel = (typeof field === "string" ? field : "skills").replace(/^\.\//, "").replace(/\/+$/, "");
-    if (!isSafeArchivePath(rel))
-        throw new TarError(`플러그인 매니페스트의 skills 경로가 안전하지 않습니다: ${String(field)}`);
-    return `${pluginRoot}${rel}/`;
+    return path
+        .split("/")
+        .every((seg) => seg !== "" && seg !== "." && seg !== ".." && !/[<>:"|?*]/.test(seg) && !/[. ]$/.test(seg));
 }
-/** tar.gz 바이트에서 스킬을 꺼낸다. 위험한 경로가 하나라도 있으면 TarError. */
-export function readSkillPack(gz) {
-    let tar;
+const bundleError = (msg) => new Error(`이 CLI 에 든 스킬 묶음이 맞지 않습니다: ${msg}`);
+/** npm 묶음 안의 스킬을 읽는다. 네트워크를 쓰지 않는다.
+ *
+ * `bundle.json` 에 적힌 파일만 읽고, 하나라도 경로가 안전하지 않거나, 이름이 SKILL_NAMES 밖이거나, 보통 파일이
+ * 아니거나, 크기나 sha256 이 목록과 다르면 아무것도 돌려주지 않고 오류를 낸다. 이름을 SKILL_NAMES 로 좁히는 것은
+ * 사용자가 손으로 만든 같은 이름의 스킬 폴더를 지키려는 것이다(2026-11-10 보안 점검 낮음 6). */
+export function loadBundledSkills(root = BUNDLED_SKILLS_DIR) {
+    const listFile = join(root, SKILLS_BUNDLE_FILE);
+    let manifest;
     try {
-        tar = gunzipSync(gz, { maxOutputLength: MAX_TAR_BYTES });
+        manifest = JSON.parse(readFileSync(listFile, "utf8"));
     }
     catch (e) {
-        throw new TarError(`압축을 풀 수 없습니다(${e.message}).`);
-    }
-    const entries = readTar(tar).map((e) => ({ ...e, name: e.type === "dir" ? e.name.replace(/\/+$/, "") : e.name }));
-    for (const e of entries) {
-        if (!isSafeArchivePath(e.name))
-            throw new TarError(`압축 파일에 안전하지 않은 경로가 있어 거부했습니다: ${e.name}`);
-    }
-    // 플러그인 매니페스트 후보(저장소 맨 위의 marketplace.json 이 아니라 plugin.json).
-    const candidates = [];
-    for (const e of entries) {
-        const m = /^(.*\/)?\.claude-plugin\/plugin\.json$/.exec(e.name);
-        if (!m || e.type !== "file")
-            continue;
-        let manifest;
+        throw bundleError(`${listFile} 을 읽지 못했습니다(${e.message})`);
+    }
+    if (!manifest || !Array.isArray(manifest.files) || !manifest.files.length) {
+        throw bundleError(`${listFile} 에 파일 목록이 없습니다`);
+    }
+    const skills = new Map();
+    for (const f of manifest.files) {
+        const path = typeof f?.path === "string" ? f.path : "";
+        if (!isSafeSkillPath(path))
+            throw bundleError(`안전하지 않은 스킬 경로를 거부했습니다: ${String(f?.path)}`);
+        const [name, ...rest] = path.split("/");
+        if (!rest.length)
+            throw bundleError(`스킬 폴더 밖의 파일입니다: ${path}`);
+        if (!SKILL_NAMES.includes(name))
+            throw bundleError(`목록 밖의 스킬 이름입니다: ${name}`);
+        const abs = join(root, ...path.split("/"));
+        let st;
         try {
-            manifest = JSON.parse(e.data.toString("utf8"));
+            st = lstatSync(abs);
         }
         catch {
-            continue;
-        }
-        candidates.push({
-            prefix: skillsPrefix(m[1] ?? "", manifest.skills),
-            version: typeof manifest.version === "string" ? manifest.version : undefined,
-        });
-    }
-    // 매니페스트가 없으면 저장소 맨 위의 skills/(GitHub tar 는 `<저장소>-<가지>/` 아래에 모두 둔다).
-    if (!candidates.length) {
-        const tops = new Set(entries.map((e) => (e.name.includes("/") ? e.name.split("/")[0] : "")));
-        const top = tops.size === 1 && !tops.has("") ? `${[...tops][0]}/` : "";
-        candidates.push({ prefix: `${top}skills/` });
-    }
-    for (const c of candidates) {
-        const skills = new Map();
-        for (const e of entries) {
-            if (!e.name.startsWith(c.prefix))
-                continue;
-            const rel = e.name.slice(c.prefix.length);
-            if (e.type === "dir")
-                continue;
-            if (e.type !== "file")
-                throw new TarError(`스킬 자리에 링크나 특수 파일이 있어 거부했습니다: ${e.name}`);
-            assertSkillPath(rel);
-            const [name, ...rest] = rel.split("/");
-            if (!rest.length)
-                continue; // skills/ 바로 아래 파일(스킬이 아니다)
-            const files = skills.get(name) ?? [];
-            files.push({ path: rest.join("/"), data: e.data });
-            skills.set(name, files);
-        }
-        for (const [name, files] of skills) {
-            if (!files.some((f) => f.path === "SKILL.md"))
-                skills.delete(name);
+            throw bundleError(`${path} 이 없습니다`);
         }
-        if (skills.size) {
-            const sorted = new Map([...skills].sort(([a], [b]) => a.localeCompare(b)));
-            return { version: c.version, skills: sorted };
-        }
-    }
-    throw new TarError("압축 파일에서 스킬(SKILL.md 가 든 폴더)을 찾지 못했습니다.");
+        if (!st.isFile())
+            throw bundleError(`${path} 이 보통 파일이 아닙니다(링크나 폴더)`);
+        const data = readFileSync(abs);
+        const sha256 = createHash("sha256").update(data).digest("hex");
+        if (data.length !== f.bytes || sha256 !== f.sha256)
+            throw bundleError(`${path} 의 내용이 목록과 다릅니다`);
+        const files = skills.get(name) ?? [];
+        files.push({ path: rest.join("/"), data });
+        skills.set(name, files);
+    }
+    for (const [name, files] of skills) {
+        if (!files.some((f) => f.path === "SKILL.md"))
+            throw bundleError(`${name} 에 SKILL.md 가 없습니다`);
+    }
+    const sorted = new Map([...skills].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+    const version = typeof manifest.plugin_version === "string" ? manifest.plugin_version : undefined;
+    return { version, skills: sorted };
 }
-export async function downloadSkillPack(ctx) {
-    const url = skillsTarballUrl(ctx.env);
-    let r;
+/** doctor 가 적는 한 줄: 이 CLI 에 든 스킬의 버전과 개수. 읽지 못하면 그 까닭. */
+export function bundledSkillsLine(root = BUNDLED_SKILLS_DIR) {
     try {
-        r = await ctx.fetch(url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) });
+        const pack = loadBundledSkills(root);
+        return `이 CLI 에 든 스킬: ${pack.skills.size}개, 스킬 버전 ${pack.version ?? "모름"}`;
     }
     catch (e) {
-        const cause = e.cause?.message;
-        throw new Error(`${url} 에 연결하지 못했습니다(${e.message}${cause ? `: ${cause}` : ""})`);
+        return `이 CLI 에 든 스킬: 읽지 못함(${e.message})`;
     }
-    if (!r.ok)
-        throw new Error(`${url} 이 ${r.status} 로 답했습니다`);
-    const gz = Buffer.from(await r.arrayBuffer());
-    if (gz.length > MAX_GZ_BYTES)
-        throw new Error(`${url} 의 크기가 한도(${MAX_GZ_BYTES} 바이트)를 넘습니다`);
-    return readSkillPack(gz);
 }
 function isInside(root, p) {
     const rel = relative(root, p);
@@ -215,13 +174,13 @@ export function writeSkillsTo(rootDir, pack) {
         const final = resolve(root, name);
         const tmp = resolve(root, `.${name}.aiakiv-tmp-${process.pid}`);
         if (!isInside(root, final) || !isInside(root, tmp))
-            throw new TarError(`안전하지 않은 스킬 이름입니다: ${name}`);
+            throw new Error(`안전하지 않은 스킬 이름입니다: ${name}`);
         rmSync(tmp, { recursive: true, force: true });
         try {
             for (const f of files) {
                 const p = resolve(tmp, ...f.path.split("/"));
                 if (!isInside(tmp, p))
-                    throw new TarError(`안전하지 않은 스킬 경로입니다: ${name}/${f.path}`);
+                    throw new Error(`안전하지 않은 스킬 경로입니다: ${name}/${f.path}`);
                 mkdirSync(dirname(p), { recursive: true });
                 writeFileSync(p, f.data);
             }
@@ -236,20 +195,21 @@ export function writeSkillsTo(rootDir, pack) {
     }
     return written;
 }
-/** bind 의 폴더 스킬 단계. 실패하면 false 와 함께 사람이 칠 명령을 보여 준다(예외를 내지 않는다). */
-export async function installFolderSkills(ctx, client, dir) {
+/** bind 의 폴더 스킬 단계. 이 CLI 에 든 스킬을 쓴다(네트워크를 쓰지 않는다). 실패하면 false 와 함께 사람이 칠
+ * 명령을 보여 준다(예외를 내지 않는다). `root` 는 시험용이다. */
+export async function installFolderSkills(ctx, client, dir, root = BUNDLED_SKILLS_DIR) {
     const rel = FOLDER_SKILLS_DIR[client];
     try {
-        const pack = await downloadSkillPack(ctx);
+        const pack = loadBundledSkills(root);
         const names = writeFolderSkills(dir, rel, pack);
-        ctx.out(`폴더 스킬 ${names.length}개: ${rel} (판 ${pack.version ?? "모름"})`);
+        ctx.out(`폴더 스킬 ${names.length}개: ${rel} (이 CLI 에 든 스킬, 스킬 버전 ${pack.version ?? "모름"})`);
         const missing = SKILL_NAMES.filter((n) => !names.includes(n));
         if (missing.length)
-            ctx.err(`  참고: 받은 스킬에 ${missing.join(", ")} 이 없습니다.`);
+            ctx.err(`  참고: 이 CLI 에 든 스킬에 ${missing.join(", ")} 이 없습니다.`);
         return true;
     }
     catch (e) {
-        ctx.err(`폴더 스킬을 받지 못했습니다(${e.message}). 연결 설정은 이미 썼습니다.`);
+        ctx.err(`폴더 스킬을 쓰지 못했습니다(${e.message}). 연결 설정은 이미 썼습니다.`);
         ctx.err(`  그 폴더(${dir})에서 직접 실행하세요: ${skillsManualCommand(SKILLS_AGENT[client])}`);
         return false;
     }

package/dist/version.js

@@ -1,5 +1,5 @@
 // package.json 의 version 과 같아야 한다(tests/cli.test.mjs 가 확인).
-export const VERSION = "0.3.1";
+export const VERSION = "0.3.3";
 // 이 CLI 판이 `aiakiv enterprise precheck` 에서 쓰는 유료 기업판 엔진 이미지 판(aiakiv/engine-enterprise:<판>).
 // K2G packaging/selfhost/build.sh 가 `<이미지>:<판>` 으로 태그를 붙이고(앞에 v 없음), 엔진 판은 K2G
 // pyproject.toml 의 version(이미지의 AIAKIV_ENGINE_VERSION)이다. 엔진 판을 올리면 이 값도 같이 올린다.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiakiv",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "AiAkiv CLI: pin a folder to an AiAkiv project (connection, folder skills, settings), check it, and run console actions and a dashboard from the shell.",
   "license": "MIT",
   "type": "module",
@@ -8,7 +8,8 @@
     "aiakiv": "dist/cli.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "skills"
   ],
   "engines": {
     "node": ">=18.3"

package/skills/aiakiv-cards/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: aiakiv-cards
+description: >-
+  Create a public AiAkiv card from the user's memory with create_aiakiv_card.
+  Use when the user asks to make a card, share a memory as a link or page,
+  publish a summary card, or asks what AiAkiv cards are or how to fix or delete
+  one. A card is a one-page public site (card.aiakiv.com) written by YOU from
+  memory search results and baked by the card service. It is live on the open
+  web the moment it is created.
+---
+
+# AiAkiv cards
+
+<!-- shared-create-section: begin. This block is identical in every edition of the aiakiv-cards skill. -->
+A **card** is a one-page public summary of the user's AiAkiv memory: a title,
+3 to 5 bullets, a one-line conclusion and an optional longer body, plus two
+share images (a square one and a wide 1200x630 one) with the short address
+stamped in. Anyone with the address can view it, no login. You create it with
+`create_aiakiv_card`. The server never calls a model: **you write the
+content**.
+
+## The one fact that governs everything
+
+**Creating IS publishing.** The card page and both images are live on the open
+web the instant `create_aiakiv_card` returns. The card is unlisted (nobody
+finds it without the address) but NOT private. There is no draft state, no
+editing and no undo except deleting the card (see "Managing cards" below). So
+filter before you create, and relay the response's `notice` to the user first,
+verbatim.
+
+## Procedure
+
+1. **Search memory first** (`search_memory`, then `get_memory_content` when a
+   summary is not enough). The card summarizes what is actually stored; do not
+   invent content. Set `source_count` to the number of memories you actually
+   used.
+2. **Filter for sensitivity**: personal names, emails, internal addresses,
+   decisions not yet public.
+3. **Get consent to publish.** A request to make a card is consent to publish
+   that card. If the content touches anything sensitive, or you had to choose
+   what to leave out, show the user the draft and wait for an explicit yes
+   before creating.
+4. **Write to fit the images, not just the limits** (see "Fitting the images").
+   Aim to fit on the first try: creating again makes a NEW card at a new
+   address and leaves the first one published, and counted against the user's
+   card quota, until the user deletes it.
+5. **Create** with `create_aiakiv_card`, passing the fields below directly.
+   There is no format lookup step before it.
+
+## Fields and limits
+
+The card service checks these after it trims whitespace and drops empty items.
+
+- `title`: one line, up to 80 characters. Required.
+- `bullets`: 3 to 5 key points, one line each, up to 120 characters each. Required.
+- `conclusion`: one line, up to 200 characters. Required.
+- `source_count`: how many memories the card was written from, an integer of 0 or more. Defaults to 0.
+- `tags`: up to 3 search terms for card.aiakiv.com, up to 20 characters each. They are drawn into the images and **cannot be changed later**. Defaults to none.
+- `body`: optional longer text shown on the page but not in the images, up to 30,000 characters of restricted markdown: paragraphs, `##` headings, `-` and `1.` lists, `>` quotes, inline and fenced code, bold, italic, http(s) links and `---`. Anything else shows as plain text.
+
+Title, bullets, conclusion and tags are single lines: line breaks in them
+collapse to spaces.
+
+## Fitting the images
+
+Bullets share one fixed block of vertical space, so their count and length
+trade against each other. A line holds about 31 Korean characters (Latin
+letters and spaces fit more) and each bullet gets up to 3 lines, but when the
+total does not fit, every bullet is cut to fewer lines and shortened with an
+ellipsis. Staying under 120 characters is not enough.
+
+What fits both images: a title of up to about 20 Korean characters, a
+conclusion of up to about 30 Korean characters, and 3 or 4 bullets of up to
+about 40 Korean characters each. With 5 bullets the last one is left out of
+the wide image. The page always shows the full text; only the images crop.
+
+## Handling the response
+
+- **`notice` comes first.** Show it to the user before the link and before any
+  summary, uncompressed. It states what just became public and how to take it
+  down.
+- **`url`** is the card page: show it verbatim as a clickable link. `og_url`
+  (wide) and `square_url` (square) are the share images.
+- **`fit`** is present only when an image cut something. Report it as is:
+  `bullets_truncated` and `bullets_dropped` are original bullet numbers,
+  `title_truncated` or `conclusion_truncated` may also appear, and `hint` says
+  how much to shorten. Let the user decide whether to shorten and create again,
+  and if they do, remind them the first card stays up until they delete it.
+- **Errors** come as `{error, message or hint, field}`. On any error no card was
+  made; never say it was.
+  - `invalid_card`: fix the named `field` and try again.
+  - `payload_too_large` or `request_too_large`: shorten the body.
+  - `quota_exceeded`: the response carries `window`, `limit` and `used`. Tell
+    the user which limit was reached; do not retry.
+  - Anything else: relay it and stop.
+
+## What you must not do
+
+- Create a card the user did not ask for ("summarize this" is not a card request).
+- Fill a card with content that is not in memory.
+- Quietly create again after a `fit` warning; that leaves two public cards.
+- Say a card was made when the response was an error.
+- Paste the card's address anywhere on the user's behalf; sharing is their call.
+
+## Sharing, for the user
+
+- KakaoTalk, Slack, Discord, Notion and blogs unfurl the bare address into a
+  card. Instagram and some board sites do not: upload the square or wide image
+  instead; the address is stamped inside it.
+- Deleting removes the page immediately, but other sites' preview caches can
+  linger. Deleting the account does NOT delete cards, so delete them first.
+<!-- shared-create-section: end -->
+
+## Managing cards
+
+`create_aiakiv_card` only creates. Editing a card's text is not possible
+anywhere; create a new card instead (the old one stays up until deleted).
+
+Creating a card works on every AiAkiv connection. No tool in the conversation
+manages cards the user already made. Listing, deleting, search visibility and
+filing tags are done by the user by hand in the AiAkiv web console
+(app.aiakiv.com, Data, Cards). In a client with a shell, `npx aiakiv console`
+does the same with the actions `list_cards`, `set_card_searchable`,
+`set_card_tags` and `delete_card` (the `aiakiv-dashboard` skill covers the
+command). Each of those needs the matching console AI permission the user
+turned on. In a client without a shell, tell the user where in the web console
+to do it.
+
+- Claim you deleted a card or changed its search visibility only when the
+  console command actually returned `ok: true`. A `delete_card` error means the
+  card is still public.
+- Search visibility is OFF by default. Turning it on lists the card in
+  card.aiakiv.com search by title and tags; turning it off later un-lists it,
+  but the card stays public to anyone with the address.
+- Filing tags (`set_card_tags`) are not the `tags` field. Filing tags show on
+  the card page and group cards in search; they never change the image.
+- The public nickname and the tag palette are set by the user in the web
+  console, not by you. A nickname is optional; without one nothing
+  identifying the user is published. Their email is never published.
+- card.aiakiv.com search narrows three ways (text, author nickname, filing
+  tag), and the address bar tracks whatever is narrowed, so any view can be
+  shared as a link.