jioogen 0.2.2 → 0.2.4

package/dist/index.js

@@ -363,9 +363,9 @@ var require_utils = __commonJS({
         fpath.split(self.sep).forEach(function(name) {
           if (!name || name.substr(-1, 1) === ":") return;
           resolvedPath += self.sep + name;
-          var stat2;
+          var stat3;
           try {
-            stat2 = self.fs.statSync(resolvedPath);
+            stat3 = self.fs.statSync(resolvedPath);
           } catch (e) {
             if (e.message && e.message.startsWith("ENOENT")) {
               self.fs.mkdirSync(resolvedPath);
@@ -373,7 +373,7 @@ var require_utils = __commonJS({
               throw e;
             }
           }
-          if (stat2 && stat2.isFile()) throw Errors.FILE_IN_THE_WAY(`"${resolvedPath}"`);
+          if (stat3 && stat3.isFile()) throw Errors.FILE_IN_THE_WAY(`"${resolvedPath}"`);
         });
       }
       mkdirSync(folder);
@@ -382,8 +382,8 @@ var require_utils = __commonJS({
       const self = this;
       if (self.fs.existsSync(path)) {
         if (!overwrite) return false;
-        var stat2 = self.fs.statSync(path);
-        if (stat2.isDirectory()) {
+        var stat3 = self.fs.statSync(path);
+        if (stat3.isDirectory()) {
           return false;
         }
       }
@@ -416,8 +416,8 @@ var require_utils = __commonJS({
       const self = this;
       self.fs.exists(path, function(exist) {
         if (exist && !overwrite) return callback(false);
-        self.fs.stat(path, function(err, stat2) {
-          if (exist && stat2 && stat2.isDirectory()) {
+        self.fs.stat(path, function(err, stat3) {
+          if (exist && stat3 && stat3.isDirectory()) {
             return callback(false);
           }
           var folder = pth.dirname(path);
@@ -469,13 +469,13 @@ var require_utils = __commonJS({
       for (const part of rel.split(pth.sep)) {
         if (!part || part === ".") continue;
         cur = pth.join(cur, part);
-        let stat2;
+        let stat3;
         try {
-          stat2 = self.fs.lstatSync(cur);
+          stat3 = self.fs.lstatSync(cur);
         } catch (e) {
           break;
         }
-        if (stat2.isSymbolicLink()) throw Errors.FILE_IN_THE_WAY(`"${cur}"`);
+        if (stat3.isSymbolicLink()) throw Errors.FILE_IN_THE_WAY(`"${cur}"`);
       }
     };
     Utils.prototype.findFiles = function(path) {
@@ -502,11 +502,11 @@ var require_utils = __commonJS({
         self.fs.readdirSync(dir).forEach(function(file) {
           const path2 = pth.join(dir, file);
           if (escapesRoot(path2)) return;
-          const stat2 = self.fs.statSync(path2);
+          const stat3 = self.fs.statSync(path2);
           if (!pattern || pattern.test(path2)) {
-            files.push(pth.normalize(path2) + (stat2.isDirectory() ? self.sep : ""));
+            files.push(pth.normalize(path2) + (stat3.isDirectory() ? self.sep : ""));
           }
-          if (stat2.isDirectory() && recursive) {
+          if (stat3.isDirectory() && recursive) {
             const realDir = self.fs.realpathSync(path2);
             if (!visited.has(realDir)) {
               visited.add(realDir);
@@ -553,14 +553,14 @@ var require_utils = __commonJS({
                 if (!--pending) done();
                 return;
               }
-              self.fs.stat(file, function(err3, stat2) {
+              self.fs.stat(file, function(err3, stat3) {
                 if (err3) return done(err3);
-                if (!stat2) {
+                if (!stat3) {
                   if (!--pending) done();
                   return;
                 }
-                results.push(pth.normalize(file) + (stat2.isDirectory() ? self.sep : ""));
-                if (!stat2.isDirectory()) {
+                results.push(pth.normalize(file) + (stat3.isDirectory() ? self.sep : ""));
+                if (!stat3.isDirectory()) {
                   if (!--pending) done();
                   return;
                 }
@@ -2978,7 +2978,7 @@ var ApiClient = class {
 };
 
 // src/commands.ts
-import { readdir as readdir3, readFile as readFile6 } from "node:fs/promises";
+import { readdir as readdir4, readFile as readFile6 } from "node:fs/promises";
 import { join as join6, resolve as resolve4 } from "node:path";
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
@@ -8766,15 +8766,28 @@ function delay(ms) {
 }
 
 // src/skills.ts
-import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { cp, mkdir as mkdir3, readdir as readdir2, readFile as readFile4, rm as rm3, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
 import { dirname as dirname3, join as join4, resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
 var EXECUTION_SKILL_NAME = "jioogen-execution";
 var AGENT_SKILL_DIRS = [
   ".claude/skills",
+  ".opencode/skills",
   ".agent/skills",
   ".codex/skills",
   ".cursor/skills"
 ];
+var SKILL_PACK_NAMES = ["baseline", "ui-quality", "backend-rules"];
+var SKILL_PACKS = {
+  baseline: ["karpathy-guidelines"],
+  "ui-quality": ["ui-ux-pro-max", "impeccable"],
+  "backend-rules": []
+};
+var HARNESS_MANIFEST_PATH = ".jioogen/harness.json";
+var HARNESS_SCHEMA_VERSION = 1;
+var FRONTEND_MOCK_LAYER_RE = /^[ \t]*(?:[-*][ \t]+)?layer[ \t]*[:=][ \t]*[`"']?frontend_mock\b/im;
 var MARKER_PREFIX = "<!-- jioogen-execution-skill:";
 var MARKER = `${MARKER_PREFIX} v1 -->`;
 var JIOOGEN_AGENTS_MD = `${MARKER}
@@ -8829,7 +8842,7 @@ mengetik "lanjut".
 
 ## 6. Skill eksekusi
 Baca skill \`${EXECUTION_SKILL_NAME}\` di awal prompt
-(\`.claude/skills\`, \`.agent/skills\`, \`.codex/skills\`, atau \`.cursor/skills\`).
+(\`.claude/skills\`, \`.opencode/skills\`, \`.agent/skills\`, \`.codex/skills\`, atau \`.cursor/skills\`).
 Skill itu memuat kontrak lengkap; file ini adalah ringkasan yang mengikat.
 `;
 var JIOOGEN_EXECUTION_SKILL = `---
@@ -8929,10 +8942,247 @@ async function readFileSafe(path) {
     return void 0;
   }
 }
-async function installAgentSkills(bundleDir) {
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isMissingFile3(error) {
+  return isRecord2(error) && error.code === "ENOENT";
+}
+async function isFile(path) {
+  try {
+    return (await stat2(path)).isFile();
+  } catch (error) {
+    if (isMissingFile3(error)) return false;
+    throw error;
+  }
+}
+async function isDirectory(path) {
+  try {
+    return (await stat2(path)).isDirectory();
+  } catch (error) {
+    if (isMissingFile3(error)) return false;
+    throw error;
+  }
+}
+function isSkillPackName(value) {
+  return typeof value === "string" && SKILL_PACK_NAMES.includes(value);
+}
+function isProductKind(value) {
+  return value === "ui" || value === "non-ui";
+}
+function parseSkillEntry(value) {
+  if (!isRecord2(value)) return null;
+  const { name, source, sha256 } = value;
+  if (typeof name !== "string" || name.length === 0) return null;
+  if (typeof source !== "string" || source.length === 0) return null;
+  if (typeof sha256 !== "string" || sha256.length === 0) return null;
+  return { name, source, sha256 };
+}
+function parsePack(value) {
+  if (!isRecord2(value)) return null;
+  const { name, skills, missing } = value;
+  if (!isSkillPackName(name)) return null;
+  if (!Array.isArray(skills) || !Array.isArray(missing)) return null;
+  const parsedSkills = [];
+  for (const entry of skills) {
+    const parsed = parseSkillEntry(entry);
+    if (parsed === null) return null;
+    parsedSkills.push(parsed);
+  }
+  const parsedMissing = [];
+  for (const entry of missing) {
+    if (typeof entry !== "string") return null;
+    parsedMissing.push(entry);
+  }
+  return { name, skills: parsedSkills, missing: parsedMissing };
+}
+function parseHarnessManifest(value) {
+  if (!isRecord2(value)) return null;
+  const { schemaVersion, productKind, packs, updatedAt } = value;
+  if (schemaVersion !== HARNESS_SCHEMA_VERSION) return null;
+  if (!isProductKind(productKind)) return null;
+  if (!Array.isArray(packs)) return null;
+  const parsedPacks = [];
+  for (const entry of packs) {
+    const parsed = parsePack(entry);
+    if (parsed === null) return null;
+    parsedPacks.push(parsed);
+  }
+  if (typeof updatedAt !== "string" || updatedAt.length === 0) return null;
+  return { schemaVersion: HARNESS_SCHEMA_VERSION, productKind, packs: parsedPacks, updatedAt };
+}
+async function readHarnessManifest(bundleDir) {
+  const path = join4(resolve2(bundleDir), HARNESS_MANIFEST_PATH);
+  let raw;
+  try {
+    raw = await readFile4(path, "utf8");
+  } catch (error) {
+    if (isMissingFile3(error)) return null;
+    throw error;
+  }
+  try {
+    return parseHarnessManifest(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+async function writeHarnessManifest(bundleDir, manifest) {
+  const path = join4(resolve2(bundleDir), HARNESS_MANIFEST_PATH);
+  await mkdir3(dirname3(path), { recursive: true });
+  await writeFile3(path, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  return path;
+}
+async function detectProductKind(bundleDir) {
+  const tasksDir = join4(resolve2(bundleDir), "tasks");
+  let entries;
+  try {
+    entries = await readdir2(tasksDir, { withFileTypes: true });
+  } catch (error) {
+    if (isMissingFile3(error)) return "non-ui";
+    throw error;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.toLowerCase().endsWith(".md")) continue;
+    const content = await readFileSafe(join4(tasksDir, entry.name));
+    if (content !== void 0 && FRONTEND_MOCK_LAYER_RE.test(content)) return "ui";
+  }
+  return "non-ui";
+}
+function packsForProduct(productKind) {
+  return productKind === "ui" ? ["baseline", "ui-quality", "backend-rules"] : ["baseline", "backend-rules"];
+}
+function cliPackageRoot() {
+  return resolve2(dirname3(fileURLToPath(import.meta.url)), "..");
+}
+function skillSourceCandidates(pack, name) {
+  const candidates = [];
+  const override = process.env.JIOOGEN_SKILLS_DIR?.trim();
+  if (override !== void 0 && override.length > 0) candidates.push(join4(override, name));
+  candidates.push(join4(configDir(), "skill-cache", name));
+  candidates.push(join4(cliPackageRoot(), "skills-pack", pack, name));
+  const home = homedir2();
+  candidates.push(join4(home, ".agents", "skills", name));
+  candidates.push(join4(home, ".config", "opencode", "skills", name));
+  candidates.push(join4(home, ".claude", "skills", name));
+  return candidates;
+}
+async function resolveSkillSource(pack, name) {
+  for (const candidate of skillSourceCandidates(pack, name)) {
+    if (await isDirectory(candidate) && await isFile(join4(candidate, "SKILL.md"))) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function collectRelativeFiles(root, prefix) {
+  const entries = await readdir2(join4(root, prefix), { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const relative2 = prefix.length === 0 ? entry.name : `${prefix}/${entry.name}`;
+    if (entry.isDirectory()) {
+      files.push(...await collectRelativeFiles(root, relative2));
+    } else if (entry.isFile()) {
+      files.push(relative2);
+    }
+  }
+  return files;
+}
+async function hashSkillDirectory(directory) {
+  const root = resolve2(directory);
+  const files = (await collectRelativeFiles(root, "")).sort();
+  const hash = createHash("sha256");
+  for (const relative2 of files) {
+    hash.update(relative2);
+    hash.update("\0");
+    hash.update(await readFile4(join4(root, ...relative2.split("/"))));
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+async function replaceDirectory(source, target) {
+  await rm3(target, { recursive: true, force: true });
+  await mkdir3(dirname3(target), { recursive: true });
+  await cp(source, target, { recursive: true });
+}
+function packNamesInCanonicalOrder(names) {
+  const wanted = new Set(names);
+  return SKILL_PACK_NAMES.filter((name) => wanted.has(name));
+}
+async function provisionPack(root, pack, prior, written, preserved) {
+  const skills = [];
+  const missing = [];
+  for (const name of SKILL_PACKS[pack]) {
+    const source = await resolveSkillSource(pack, name);
+    if (source === null) {
+      missing.push(name);
+      continue;
+    }
+    const sha256 = await hashSkillDirectory(source);
+    const previous = prior?.skills.find((entry) => entry.name === name);
+    let owned = previous !== void 0;
+    for (const dir of AGENT_SKILL_DIRS) {
+      const targetDir = join4(root, dir, name);
+      const skillMd = join4(targetDir, "SKILL.md");
+      if (await isFile(skillMd)) {
+        const targetHash = await hashSkillDirectory(targetDir);
+        if (previous === void 0) {
+          preserved.push(`${dir}/${name}/SKILL.md`);
+          continue;
+        }
+        if (targetHash === sha256) {
+          owned = true;
+          continue;
+        }
+        await replaceDirectory(source, targetDir);
+        written.push(`${dir}/${name}/SKILL.md`);
+        owned = true;
+        continue;
+      }
+      await replaceDirectory(source, targetDir);
+      written.push(`${dir}/${name}/SKILL.md`);
+      owned = true;
+    }
+    if (owned) skills.push({ name, source, sha256 });
+  }
+  return { name: pack, skills, missing };
+}
+function sameManifestBody(manifest, productKind, packs) {
+  return manifest.productKind === productKind && JSON.stringify(manifest.packs) === JSON.stringify(packs);
+}
+async function provisionSkillPacks(bundleDir, packNames, productKind) {
   const root = resolve2(bundleDir);
+  const existing = await readHarnessManifest(root);
   const written = [];
   const preserved = [];
+  const packs = [];
+  for (const pack of packNamesInCanonicalOrder(packNames)) {
+    const prior = existing?.packs.find((entry) => entry.name === pack);
+    packs.push(await provisionPack(root, pack, prior, written, preserved));
+  }
+  const changed = existing === null || !sameManifestBody(existing, productKind, packs);
+  const manifest = {
+    schemaVersion: HARNESS_SCHEMA_VERSION,
+    productKind,
+    packs,
+    updatedAt: changed ? (/* @__PURE__ */ new Date()).toISOString() : existing?.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const harnessPath = await writeHarnessManifest(root, manifest);
+  return {
+    written,
+    preserved,
+    productKind,
+    packs,
+    missing: packs.flatMap((pack) => pack.missing),
+    harnessPath
+  };
+}
+async function installAgentSkills(bundleDir, options = {}) {
+  const root = resolve2(bundleDir);
+  const written = [];
+  const preserved = [];
+  const productKind = options.productKind ?? await detectProductKind(root);
+  const harnessPath = join4(root, HARNESS_MANIFEST_PATH);
   const agentsPath = join4(root, "AGENTS.md");
   const existing = await readFileSafe(agentsPath);
   if (existing === void 0 || existing.includes(MARKER_PREFIX)) {
@@ -8948,11 +9198,88 @@ async function installAgentSkills(bundleDir) {
     await writeFile3(target, JIOOGEN_EXECUTION_SKILL, "utf8");
     written.push(relative2);
   }
-  return { written, preserved };
+  if (options.noSkills === true) {
+    return { written, preserved, productKind, packs: [], missing: [], harnessPath };
+  }
+  const current = await readHarnessManifest(root);
+  const requested = options.packs ?? packNamesInCanonicalOrder([
+    ...packsForProduct(productKind),
+    ...current?.packs.map((pack) => pack.name) ?? []
+  ]);
+  const provision = await provisionSkillPacks(root, requested, productKind);
+  return {
+    written: [...written, ...provision.written],
+    preserved: [...preserved, ...provision.preserved],
+    productKind,
+    packs: provision.packs,
+    missing: provision.missing,
+    harnessPath: provision.harnessPath
+  };
+}
+function parseSkillPackArgument(value) {
+  if (value === "all") return [...SKILL_PACK_NAMES];
+  return isSkillPackName(value) ? [value] : null;
+}
+async function addSkillPacks(bundleDir, packNames, options = {}) {
+  const root = resolve2(bundleDir);
+  const existing = await readHarnessManifest(root);
+  const productKind = options.productKind ?? existing?.productKind ?? await detectProductKind(root);
+  const requested = packNamesInCanonicalOrder([
+    ...existing?.packs.map((pack) => pack.name) ?? [],
+    ...packNames
+  ]);
+  const provision = await provisionSkillPacks(root, requested, productKind);
+  return { ...provision, added: packNamesInCanonicalOrder(packNames) };
+}
+async function updateSkillPacks(bundleDir) {
+  const root = resolve2(bundleDir);
+  const existing = await readHarnessManifest(root);
+  if (existing === null) return null;
+  return provisionSkillPacks(
+    root,
+    existing.packs.map((pack) => pack.name),
+    existing.productKind
+  );
+}
+async function removeSkillPack(bundleDir, pack) {
+  const root = resolve2(bundleDir);
+  const existing = await readHarnessManifest(root);
+  const removed = [];
+  const preserved = [];
+  if (existing === null) return { removed, preserved, packs: [] };
+  const entry = existing.packs.find((candidate) => candidate.name === pack);
+  if (entry !== void 0) {
+    for (const skill of entry.skills) {
+      for (const dir of AGENT_SKILL_DIRS) {
+        const targetDir = join4(root, dir, skill.name);
+        const skillMd = join4(targetDir, "SKILL.md");
+        if (!await isFile(skillMd)) continue;
+        const targetHash = await hashSkillDirectory(targetDir);
+        if (targetHash !== skill.sha256) {
+          preserved.push(`${dir}/${skill.name}/SKILL.md`);
+          continue;
+        }
+        await rm3(targetDir, { recursive: true, force: true });
+        removed.push(`${dir}/${skill.name}/SKILL.md`);
+      }
+    }
+  }
+  const packs = existing.packs.filter((candidate) => candidate.name !== pack);
+  await writeHarnessManifest(root, {
+    ...existing,
+    packs,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return { removed, preserved, packs };
+}
+function skillsDisabled(options) {
+  if (options.noSkills === true) return true;
+  const value = process.env.JIOOGEN_NO_SKILLS?.trim().toLowerCase();
+  return value === "1" || value === "true" || value === "yes";
 }
 
 // src/tasks.ts
-import { readdir as readdir2, readFile as readFile5 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile5 } from "node:fs/promises";
 import { join as join5 } from "node:path";
 var TASK_ID_RE2 = /\b(?:TASK|T)-\d{3,}\b/i;
 var HEADING_RE = /^#{1,4}\s+(.+)$/m;
@@ -8964,13 +9291,51 @@ var LAYER_RANK = {
   verification: 4
 };
 var IN_PROGRESS = ["in_progress", "verifying"];
+var QUALITY_HEADING = "## KUALITAS WAJIB (ringkas; detail di skill bila tersedia)";
+var MAX_CHECKLIST_LINES = 12;
+var UI_SKILLS = ["ui-ux-pro-max", "impeccable"];
+var LAYER_CHECKLISTS = {
+  frontend_mock: [
+    "- Reuse token desain yang ada; jangan hardcode warna/spacing bila token tersedia.",
+    "- Tangani semua state UI: loading, empty, error, success.",
+    "- Responsive untuk mobile dan desktop.",
+    "- Aksesibilitas dasar: label, aria, focus, keyboard.",
+    "- Microcopy jelas dan konsisten dengan konteks."
+  ],
+  database: [
+    "- Migrasi eksplisit dan aman (reversible, tanpa mengubah migrasi lama).",
+    "- Constraint dan index sesuai pola query.",
+    "- Relasi dan isolation sesuai specs (tenant/owner).",
+    "- Seed idempotent (bisa dijalankan ulang tanpa duplikasi).",
+    "- Tanpa query lintas pemilik."
+  ],
+  backend_api: [
+    "- Validasi input di boundary.",
+    "- Error contract konsisten (status + bentuk response).",
+    "- Auth/permission dicek sebelum mutasi.",
+    "- Idempotensi untuk operasi tulis/retry.",
+    "- Logging tanpa secret/PII."
+  ],
+  integration: [
+    "- Mock dihapus dari jalur utama.",
+    "- Kontrak CONTRACT-XXX sama dengan implementasi.",
+    "- E2E memakai data nyata.",
+    "- Error path diuji."
+  ],
+  verification: [
+    "- Jalankan semua verificationCommand sampai exit 0.",
+    "- Smoke route/navigasi utama.",
+    "- UI states dan responsive dicek.",
+    "- Bukti Acceptance Criteria \xA711."
+  ]
+};
 async function loadTasks(bundleDir) {
   const tasksDir = join5(bundleDir, "tasks");
   let entries;
   try {
-    entries = await readdir2(tasksDir, { withFileTypes: true });
+    entries = await readdir3(tasksDir, { withFileTypes: true });
   } catch (error) {
-    if (isMissingFile3(error)) throw new Error(`Direktori tasks/ tidak ditemukan di ${bundleDir}`);
+    if (isMissingFile4(error)) throw new Error(`Direktori tasks/ tidak ditemukan di ${bundleDir}`);
     throw error;
   }
   const names = entries.filter(
@@ -8988,7 +9353,7 @@ async function loadTasks(bundleDir) {
     try {
       content = await readFile5(singlePath, "utf8");
     } catch (error) {
-      if (isMissingFile3(error)) throw new Error(`Tidak ada berkas task di ${tasksDir}`);
+      if (isMissingFile4(error)) throw new Error(`Tidak ada berkas task di ${tasksDir}`);
       throw error;
     }
     tasks.push(...parseSingleFile(content));
@@ -9041,7 +9406,7 @@ function buildTask(id, heading, file, content) {
     dependsOn: context.dependsOn
   };
 }
-function renderActiveTask(task) {
+function renderActiveTask(task, context) {
   const lines = [
     "## TASK AKTIF \u2014 PRIORITASKAN INI (satu task per giliran)",
     `ref: ${task.id}`,
@@ -9058,14 +9423,23 @@ function renderActiveTask(task) {
     "- Jangan mengarang fitur/endpoint/kolom di luar PRD.md/specs/.",
     "- Detail implementasi (pola, struktur file dalam scope, library yang sudah ada) milikmu; ikuti konvensi proyek.",
     "- Jangan mengubah PRD.md/specs/kontrak. Butuh perubahan kontrak? STOP dan laporkan.",
-    "- Selesai: `npx jioogen task complete <ref>`, lalu `npx jioogen sync`.",
-    "",
-    "--- ISI TASK (otoritas scope) ---",
-    task.content,
-    "--- AKHIR ISI TASK ---"
+    "- Selesai: `npx jioogen task complete <ref>`, lalu `npx jioogen sync`."
   );
+  const checklist = renderQualityChecklist(task.layer, context);
+  if (checklist.length > 0) lines.push("", ...checklist);
+  lines.push("", "--- ISI TASK (otoritas scope) ---", task.content, "--- AKHIR ISI TASK ---");
   return lines.join("\n");
 }
+function renderQualityChecklist(layer, context) {
+  if (context === void 0 || layer === void 0) return [];
+  const items = [...LAYER_CHECKLISTS[layer] ?? []];
+  if (layer === "frontend_mock") {
+    const references = UI_SKILLS.filter((skill) => context.skills?.includes(skill) === true);
+    if (references.length > 0) items.push(`- Referensi skill: ${references.join(", ")}`);
+  }
+  if (items.length === 0) return [];
+  return [QUALITY_HEADING, ...items.slice(0, MAX_CHECKLIST_LINES)];
+}
 function resolveLayer(value) {
   if (value === void 0) return void 0;
   const token = value.trim().replace(/[`*]/g, "").split(/[\s,(]/)[0];
@@ -9149,7 +9523,7 @@ function isBoundary(previous, next) {
   }
   return previous.phase !== void 0 && next.phase !== previous.phase;
 }
-function isMissingFile3(error) {
+function isMissingFile4(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -9269,12 +9643,13 @@ async function pullCommand(projectId, options) {
       `Project id tidak valid: ${projectId}. Gunakan UUID dari \`jioogen projects\`.`
     );
   }
+  await assertPullDefaultDir(process.cwd(), options.dir);
   const { apiUrl, client } = await resolveApi(options);
   const target = resolve4(options.dir ?? projectId);
   await assertPullTarget(target, projectId, options.force === true);
   const bytes = await client.getBytes(projectPath(projectId, "/bundle"));
   const written = await extractBundle(bytes, target);
-  const skills = await installAgentSkills(target);
+  const skills = await installAgentSkills(target, { noSkills: skillsDisabled(options) });
   await writeProjectLink(target, { projectId, apiUrl });
   if (options.json === true) {
     console.log(JSON.stringify({ projectId, target, files: written, skills }, null, 2));
@@ -9282,9 +9657,8 @@ async function pullCommand(projectId, options) {
   }
   console.log(`Pulled ${written.length} file ke ${target}`);
   console.log("Project ter-bind lewat .jioogen/project.json.");
-  console.log(
-    `Skills eksekusi terpasang: ${skills.written.length} file (AGENTS.md + 4 harness skill).`
-  );
+  console.log(`Skills eksekusi terpasang: ${skills.written.length} file.`);
+  printSkillPacks(skills.packs, skills.missing);
 }
 async function linkCommand(projectId, options) {
   const { apiUrl, client } = await resolveApi(options);
@@ -9292,26 +9666,20 @@ async function linkCommand(projectId, options) {
   await assertLinkTarget(target, projectId);
   await verifyProjectAccess(client, projectId);
   await writeProjectLink(target, { projectId, apiUrl });
-  const skills = await installAgentSkills(target);
+  const skills = await installAgentSkills(target, { noSkills: skillsDisabled(options) });
   const linkedFile = join6(target, ".jioogen", "project.json");
   if (options.json === true) {
-    console.log(
-      JSON.stringify(
-        { projectId, target, apiUrl, linkedFile, skills: skills.written.length },
-        null,
-        2
-      )
-    );
+    console.log(JSON.stringify({ projectId, target, apiUrl, linkedFile, skills }, null, 2));
     return;
   }
   console.log(`Project ${projectId} ter-bind ke ${target}.`);
   console.log(`File link: ${linkedFile} (API ${apiUrl}).`);
   console.log(`Skills eksekusi terpasang: ${skills.written.length} file.`);
+  printSkillPacks(skills.packs, skills.missing);
 }
 async function skillsInstallCommand(options) {
-  const link = await findProjectLink(options.dir ?? process.cwd());
-  const bundleDir = resolve4(link?.bundleDir ?? options.dir ?? process.cwd());
-  const skills = await installAgentSkills(bundleDir);
+  const bundleDir = await resolveSkillsBundleDir(options);
+  const skills = await installAgentSkills(bundleDir, { noSkills: skillsDisabled(options) });
   if (options.json === true) {
     console.log(JSON.stringify({ bundleDir, ...skills }, null, 2));
     return;
@@ -9319,6 +9687,90 @@ async function skillsInstallCommand(options) {
   console.log(`Skills eksekusi terpasang di ${bundleDir}:`);
   for (const file of skills.written) console.log(`- ${file}`);
   for (const file of skills.preserved) console.log(`- ${file} (dilewati: milik user)`);
+  printSkillPacks(skills.packs, skills.missing);
+}
+async function skillsListCommand(options) {
+  const bundleDir = await resolveSkillsBundleDir(options);
+  const manifest = await readHarnessManifest(bundleDir);
+  if (options.json === true) {
+    console.log(JSON.stringify({ bundleDir, harness: manifest }, null, 2));
+    return;
+  }
+  if (manifest === null) {
+    console.log(`Belum ada skill pack terpasang di ${bundleDir}.`);
+    return;
+  }
+  console.log(`Bundle: ${bundleDir}`);
+  console.log(`Product: ${manifest.productKind} | updated: ${manifest.updatedAt}`);
+  for (const pack of manifest.packs) {
+    console.log(`${pack.name}:`);
+    for (const skill of pack.skills) {
+      console.log(`- ${skill.name} (installed, ${skill.sha256.slice(0, 12)})`);
+    }
+    for (const name of pack.missing) console.log(`- ${name} (missing)`);
+    if (pack.skills.length === 0 && pack.missing.length === 0) console.log("- (tidak ada skill)");
+  }
+}
+async function skillsAddCommand(packArgument, options) {
+  const packNames = parseSkillPackArgument(packArgument);
+  if (packNames === null) {
+    throw new UsageError("Pack tidak dikenal. Pilih: baseline | ui-quality | backend-rules | all.");
+  }
+  const bundleDir = await resolveSkillsBundleDir(options);
+  const result = await addSkillPacks(bundleDir, packNames);
+  if (options.json === true) {
+    console.log(JSON.stringify({ bundleDir, ...result }, null, 2));
+    return;
+  }
+  console.log(`Skill pack ditambahkan ke ${bundleDir}: ${result.added.join(", ")}`);
+  printSkillPacks(result.packs, result.missing);
+}
+async function skillsUpdateCommand(options) {
+  const bundleDir = await resolveSkillsBundleDir(options);
+  const result = await updateSkillPacks(bundleDir);
+  if (result === null) {
+    if (options.json === true) {
+      console.log(JSON.stringify({ bundleDir, harness: null }, null, 2));
+      return;
+    }
+    console.log(`Belum ada skill pack tercatat di ${bundleDir}.`);
+    return;
+  }
+  if (options.json === true) {
+    console.log(JSON.stringify({ bundleDir, ...result }, null, 2));
+    return;
+  }
+  console.log(`Skill pack diperbarui di ${bundleDir}.`);
+  printSkillPacks(result.packs, result.missing);
+}
+async function skillsRemoveCommand(packArgument, options) {
+  const packNames = parseSkillPackArgument(packArgument);
+  if (packNames === null || packNames.length !== 1) {
+    throw new UsageError("Pack tidak dikenal. Pilih: baseline | ui-quality | backend-rules.");
+  }
+  const pack = packNames[0];
+  const bundleDir = await resolveSkillsBundleDir(options);
+  const result = await removeSkillPack(bundleDir, pack);
+  if (options.json === true) {
+    console.log(JSON.stringify({ bundleDir, pack, ...result }, null, 2));
+    return;
+  }
+  console.log(`Skill pack ${pack} dihapus dari ${bundleDir}: ${result.removed.length} file.`);
+  for (const file of result.preserved) {
+    console.log(`- ${file} (dilewati: milik user / sudah berubah)`);
+  }
+}
+async function resolveSkillsBundleDir(options) {
+  const link = await findProjectLink(options.dir ?? process.cwd());
+  return resolve4(link?.bundleDir ?? options.dir ?? process.cwd());
+}
+function printSkillPacks(packs, missing) {
+  if (packs.length === 0 && missing.length === 0) return;
+  const installed = packs.filter((pack) => pack.skills.length > 0).map((pack) => `${pack.name} (${pack.skills.map((skill) => skill.name).join(", ")})`);
+  if (installed.length > 0) console.log(`Skill pack: ${installed.join("; ")}.`);
+  if (missing.length > 0) {
+    console.warn(`Peringatan: skill tidak ditemukan (dilewati): ${missing.join(", ")}.`);
+  }
 }
 async function checkCommand(options) {
   const link = await findProjectLink(options.dir ?? process.cwd());
@@ -9347,15 +9799,19 @@ async function handoffCommand(options) {
   }
 }
 async function taskNextCommand(options) {
-  const { projectId, definitions, written, next } = await withLocalState(options, async (local) => {
-    const written2 = await writeState(local.bundleDir, local.state);
-    return {
-      projectId: local.projectId,
-      definitions: local.definitions,
-      written: written2,
-      next: selectNext(local.definitions, written2.tasks)
-    };
-  });
+  const { projectId, bundleDir, definitions, written, next } = await withLocalState(
+    options,
+    async (local) => {
+      const written2 = await writeState(local.bundleDir, local.state);
+      return {
+        projectId: local.projectId,
+        bundleDir: local.bundleDir,
+        definitions: local.definitions,
+        written: written2,
+        next: selectNext(local.definitions, written2.tasks)
+      };
+    }
+  );
   if (next === null) {
     if (options.json === true) {
       console.log(JSON.stringify({ done: true, projectId }, null, 2));
@@ -9372,7 +9828,12 @@ async function taskNextCommand(options) {
     return;
   }
   const awaitingCheckpoint = written.current?.awaitingCheckpoint === true;
-  const instruction = renderActiveTask(next.task);
+  const manifest = await readHarnessManifest(bundleDir);
+  const context = manifest === null ? void 0 : {
+    productKind: manifest.productKind,
+    skills: manifest.packs.flatMap((pack) => pack.skills.map((skill) => skill.name))
+  };
+  const instruction = renderActiveTask(next.task, context);
   if (options.json === true) {
     console.log(
       JSON.stringify(
@@ -9635,12 +10096,20 @@ function assertCompleteDependencies(ref, definitions, states, force) {
     `Tidak bisa menyelesaikan ${ref}: dependency belum selesai (${missing.join(", ")}). Selesaikan dependency itu lebih dulu, atau tambahkan --force bila memang disengaja.`
   );
 }
+async function assertPullDefaultDir(cwd, dirOption) {
+  if (dirOption) return;
+  if (await hasBundleMarkers(cwd)) {
+    throw new Error(
+      `Direktori ${cwd} adalah bundle JiooGen. Gunakan \`jioogen link <projectId>\` untuk mengikat folder ini, atau \`--dir <dir>\` eksplisit untuk mengunduh ke folder lain.`
+    );
+  }
+}
 async function assertPullTarget(target, projectId, force = false) {
   let entries;
   try {
-    entries = await readdir3(target);
+    entries = await readdir4(target);
   } catch (error) {
-    if (isMissingFile4(error)) return;
+    if (isMissingFile5(error)) return;
     throw error;
   }
   if (entries.length === 0) return;
@@ -9675,16 +10144,16 @@ async function hasBundleMarkers(target) {
     await readFile6(join6(target, "PRD.md"));
     return true;
   } catch (error) {
-    if (!isMissingFile4(error)) throw error;
+    if (!isMissingFile5(error)) throw error;
   }
   return hasTaskMarkdown(join6(target, "tasks"));
 }
 async function hasTaskMarkdown(directory) {
   let names;
   try {
-    names = await readdir3(directory);
+    names = await readdir4(directory);
   } catch (error) {
-    if (isMissingFile4(error)) return false;
+    if (isMissingFile5(error)) return false;
     throw error;
   }
   return names.some((name) => name.toLowerCase().endsWith(".md"));
@@ -9746,12 +10215,12 @@ function envFirst(primary, legacy) {
   const fallback = process.env[legacy]?.trim();
   return fallback !== void 0 && fallback.length > 0 ? fallback : void 0;
 }
-function isMissingFile4(error) {
+function isMissingFile5(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/index.ts
-var VERSION = "0.2.2";
+var VERSION = "0.2.4";
 var USAGE = `jioogen \u2014 CLI JiooGen (task selection lokal, server read-only)
 
 Usage:
@@ -9760,9 +10229,13 @@ Usage:
   jioogen logout
   jioogen whoami
   jioogen projects
-  jioogen pull <projectId> [--dir <dir>] [--force]
-  jioogen link <projectId> [--dir <dir>]
-  jioogen skills install [--dir <dir>]
+  jioogen pull <projectId> [--dir <dir>] [--force] [--no-skills]
+  jioogen link <projectId> [--dir <dir>] [--no-skills]
+  jioogen skills install [--dir <dir>] [--no-skills]
+  jioogen skills list [--dir <dir>] [--json]
+  jioogen skills add <baseline|ui-quality|backend-rules|all> [--dir <dir>]
+  jioogen skills update [--dir <dir>]
+  jioogen skills remove <baseline|ui-quality|backend-rules> [--dir <dir>]
   jioogen check [--dir <dir>] [--json]
   jioogen handoff [--project <id>] [--json]
   jioogen task next [--json]
@@ -9780,6 +10253,7 @@ Global options:
   --api <url>       Base URL JiooGen (env JIOOGEN_API / JIOOCODE_API / tersimpan)
   --project <id>    Override binding project
   --dir <dir>       Override direktori bundle
+  --no-skills       Jangan pasang skill pack (atau env JIOOGEN_NO_SKILLS=1)
   -h, --help        Tampilkan bantuan
   -v, --version     Tampilkan versi
 `;
@@ -9800,6 +10274,7 @@ async function main() {
         dir: { type: "string" },
         remote: { type: "boolean" },
         force: { type: "boolean" },
+        "no-skills": { type: "boolean" },
         files: { type: "string" },
         note: { type: "string" },
         json: { type: "boolean" },
@@ -9826,6 +10301,7 @@ async function main() {
     dir: text(raw.dir),
     remote: flag(raw.remote),
     force: flag(raw.force),
+    noSkills: flag(raw["no-skills"]),
     files: text(raw.files),
     note: text(raw.note),
     json: flag(raw.json)
@@ -9916,8 +10392,30 @@ async function dispatchSkills(rest, options) {
     case "install":
       await skillsInstallCommand(options);
       return;
+    case "list":
+      await skillsListCommand(options);
+      return;
+    case "add": {
+      const pack = rest[1];
+      if (pack === void 0) {
+        throw new UsageError("`jioogen skills add` butuh <baseline|ui-quality|backend-rules|all>.");
+      }
+      await skillsAddCommand(pack, options);
+      return;
+    }
+    case "update":
+      await skillsUpdateCommand(options);
+      return;
+    case "remove": {
+      const pack = rest[1];
+      if (pack === void 0) {
+        throw new UsageError("`jioogen skills remove` butuh <baseline|ui-quality|backend-rules>.");
+      }
+      await skillsRemoveCommand(pack, options);
+      return;
+    }
     default:
-      throw new UsageError("Subcommand skills: install");
+      throw new UsageError("Subcommand skills: install | list | add | update | remove");
   }
 }
 async function dispatchTask(rest, options) {