jioogen 0.2.3 → 0.2.5

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 stat5;
           try {
-            stat2 = self.fs.statSync(resolvedPath);
+            stat5 = 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 (stat5 && stat5.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 stat5 = self.fs.statSync(path);
+        if (stat5.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, stat5) {
+          if (exist && stat5 && stat5.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 stat5;
         try {
-          stat2 = self.fs.lstatSync(cur);
+          stat5 = self.fs.lstatSync(cur);
         } catch (e) {
           break;
         }
-        if (stat2.isSymbolicLink()) throw Errors.FILE_IN_THE_WAY(`"${cur}"`);
+        if (stat5.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 stat5 = self.fs.statSync(path2);
           if (!pattern || pattern.test(path2)) {
-            files.push(pth.normalize(path2) + (stat2.isDirectory() ? self.sep : ""));
+            files.push(pth.normalize(path2) + (stat5.isDirectory() ? self.sep : ""));
           }
-          if (stat2.isDirectory() && recursive) {
+          if (stat5.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, stat5) {
                 if (err3) return done(err3);
-                if (!stat2) {
+                if (!stat5) {
                   if (!--pending) done();
                   return;
                 }
-                results.push(pth.normalize(file) + (stat2.isDirectory() ? self.sep : ""));
-                if (!stat2.isDirectory()) {
+                results.push(pth.normalize(file) + (stat5.isDirectory() ? self.sep : ""));
+                if (!stat5.isDirectory()) {
                   if (!--pending) done();
                   return;
                 }
@@ -2124,8 +2124,8 @@ var require_adm_zip = __commonJS({
         return null;
       }
       function fixPath(zipPath) {
-        const { join: join7, normalize, sep: sep2 } = pth.posix;
-        return join7(pth.isAbsolute(zipPath) ? "/" : ".", normalize(sep2 + zipPath.split("\\").join(sep2) + sep2));
+        const { join: join8, normalize, sep: sep2 } = pth.posix;
+        return join8(pth.isAbsolute(zipPath) ? "/" : ".", normalize(sep2 + zipPath.split("\\").join(sep2) + sep2));
       }
       function filenameFilter(filterfn) {
         if (filterfn instanceof RegExp) {
@@ -2521,10 +2521,10 @@ var require_adm_zip = __commonJS({
          * @param {function|string} [props.namefix] - optional function to help fix filename
          */
         addLocalFolderPromise: function(localPath, props) {
-          return new Promise((resolve5, reject) => {
+          return new Promise((resolve6, reject) => {
             this.addLocalFolderAsync2(Object.assign({ localPath }, props), (err, done) => {
               if (err) return reject(err);
-              if (done) resolve5(this);
+              if (done) resolve6(this);
             });
           });
         },
@@ -2716,12 +2716,12 @@ var require_adm_zip = __commonJS({
           keepOriginalPermission = get_Bool(false, keepOriginalPermission);
           overwrite = get_Bool(false, overwrite);
           if (!callback) {
-            return new Promise((resolve5, reject) => {
+            return new Promise((resolve6, reject) => {
               this.extractAllToAsync(targetPath, overwrite, keepOriginalPermission, function(err) {
                 if (err) {
                   reject(err);
                 } else {
-                  resolve5(this);
+                  resolve6(this);
                 }
               });
             });
@@ -2836,11 +2836,11 @@ var require_adm_zip = __commonJS({
                  */
         writeZipPromise: function(targetFileName, props) {
           const { overwrite, perm } = Object.assign({ overwrite: true }, props);
-          return new Promise((resolve5, reject) => {
+          return new Promise((resolve6, reject) => {
             if (!targetFileName && opts.filename) targetFileName = opts.filename;
             if (!targetFileName) reject("ADM-ZIP: ZIP File Name Missing");
             this.toBufferPromise().then((zipData) => {
-              const ret = (done) => done ? resolve5(done) : reject("ADM-ZIP: Wasn't able to write zip file");
+              const ret = (done) => done ? resolve6(done) : reject("ADM-ZIP: Wasn't able to write zip file");
               filetools.writeFileToAsync(targetFileName, zipData, overwrite, perm, ret);
             }, reject);
           });
@@ -2849,8 +2849,8 @@ var require_adm_zip = __commonJS({
          * @returns {Promise<Buffer>} A promise to the Buffer.
          */
         toBufferPromise: function() {
-          return new Promise((resolve5, reject) => {
-            _zip.toAsyncBuffer(resolve5, reject);
+          return new Promise((resolve6, reject) => {
+            _zip.toAsyncBuffer(resolve6, reject);
           });
         },
         /**
@@ -2978,8 +2978,8 @@ var ApiClient = class {
 };
 
 // src/commands.ts
-import { readdir as readdir3, readFile as readFile6 } from "node:fs/promises";
-import { join as join6, resolve as resolve4 } from "node:path";
+import { readdir as readdir5, readFile as readFile7 } from "node:fs/promises";
+import { join as join7, resolve as resolve5 } from "node:path";
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -3472,15 +3472,15 @@ var makeIssue = (params) => {
       message: issueData.message
     };
   }
-  let errorMessage = "";
+  let errorMessage2 = "";
   const maps = errorMaps.filter((m) => !!m).slice().reverse();
   for (const map of maps) {
-    errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
+    errorMessage2 = map(fullIssue, { data, defaultError: errorMessage2 }).message;
   }
   return {
     ...issueData,
     path: fullPath,
-    message: errorMessage
+    message: errorMessage2
   };
 };
 var EMPTY_PATH = [];
@@ -8562,19 +8562,9 @@ function isMissingFile(error) {
   return isRecord(error) && error.code === "ENOENT";
 }
 
-// src/errors.ts
-var UsageError = class extends Error {
-};
-
-// src/output.ts
-function formatTable(headers, rows) {
-  const widths = headers.map(
-    (header, index) => Math.max(header.length, ...rows.map((row) => (row[index] ?? "").length))
-  );
-  const render = (cells) => cells.map((cell, index) => cell.padEnd(widths[index] ?? 0)).join("  ").trimEnd();
-  const divider = widths.map((width) => "-".repeat(width)).join("  ");
-  return [render(headers), divider, ...rows.map(render)].join("\n");
-}
+// src/doctor.ts
+import { readdir as readdir3, readFile as readFile5, rm as rm4, stat as stat3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
 
 // src/sidecar.ts
 import { randomUUID } from "node:crypto";
@@ -8762,19 +8752,32 @@ async function removeStaleLock(target) {
   }
 }
 function delay(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, 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}
@@ -8824,12 +8827,15 @@ var JIOOGEN_AGENTS_MD = `${MARKER}
 
 ## 5. Checkpoint
 Berhenti dan minta konfirmasi user bila task berikutnya berpindah layer, nomor
-\`phase\` naik, atau task bertanda \`checkpoint: true\`. Jangan lanjut sebelum user
-mengetik "lanjut".
+\`phase\` naik, task bertanda \`checkpoint: true\`, atau task tergolong berisiko
+(migrasi/schema/auth/permission/payment/webhook/secret/deploy/infra). Jangan lanjut
+sebelum user memutuskan. Setelah user memutuskan, jalankan salah satu:
+\`npx jioogen review --approve\`, \`npx jioogen review --request-changes "<teks>"\`,
+atau \`npx jioogen review --stop\`, lalu \`npx jioogen sync\`.
 
 ## 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 = `---
@@ -8903,10 +8909,13 @@ atas ide, refactor, perbaikan, atau fitur lain.
 Berhenti dan minta konfirmasi user bila:
 - task berikutnya berpindah \`layer\` (mis. \`frontend_mock\` \u2192 \`backend_api\`/\`database\`),
 - nomor \`phase\` naik,
-- task bertanda \`checkpoint: true\`.
+- task bertanda \`checkpoint: true\`,
+- task tergolong berisiko (migrasi/schema/auth/permission/payment/webhook/secret/deploy/infra).
 
-Jangan lanjut sebelum user mengetik "lanjut". Set \`current.awaitingCheckpoint = true\`
-di sidecar saat berhenti.
+Jangan lanjut sebelum user memutuskan. Set \`current.awaitingCheckpoint = true\` di
+sidecar saat berhenti, lalu setelah user memutuskan jalankan
+\`npx jioogen review --approve\` / \`--request-changes "<teks>"\` / \`--stop\`,
+diikuti \`npx jioogen sync\`.
 
 ## 6. Larangan ringkas
 
@@ -8929,10 +8938,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,12 +9194,591 @@ 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/doctor.ts
+var REQUIRED_NODE_MAJOR = 22;
+var LOCK_STALE_MS2 = 1e4;
+var AGENTS_MARKER = "<!-- jioogen-execution-skill:";
+var BUNDLE_SCAFFOLD_CHECKS = /* @__PURE__ */ new Set(["agents", "execution-skill", "skill-packs"]);
+function makeCheck(id, status, detail, fixable) {
+  return fixable === true ? { id, status, detail, fixable: true } : { id, status, detail };
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isMissingFile4(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function resolveDeps(deps) {
+  return {
+    readCredentials: deps?.readCredentials ?? readCredentials,
+    fetchMe: deps?.fetchMe ?? (async (apiUrl, cookie) => {
+      const client = new ApiClient(apiUrl, cookie);
+      return client.getJson(ENDPOINTS.me);
+    }),
+    fetchExecution: deps?.fetchExecution ?? (async (apiUrl, cookie, projectId) => {
+      const client = new ApiClient(apiUrl, cookie);
+      return client.getJson(projectPath(projectId, "/execution"));
+    }),
+    installSkills: deps?.installSkills ?? ((bundleDir) => installAgentSkills(bundleDir))
+  };
+}
+function checkNode() {
+  const raw = process.versions.node;
+  const major = Number.parseInt(raw.split(".")[0] ?? "0", 10);
+  if (Number.isFinite(major) && major >= REQUIRED_NODE_MAJOR) {
+    return makeCheck("node", "pass", `Node.js v${raw} memenuhi syarat >=${REQUIRED_NODE_MAJOR}.`);
+  }
+  return makeCheck(
+    "node",
+    "fail",
+    `Node.js v${raw} terlalu lama; butuh >=${REQUIRED_NODE_MAJOR}. Perbarui Node.js lalu ulangi.`
+  );
+}
+function checkCredentials(credentials, error) {
+  if (error !== null) {
+    return makeCheck(
+      "credentials",
+      "fail",
+      `Credential tidak bisa dibaca: ${error}. Periksa izin file credential.`
+    );
+  }
+  if (credentials === null) {
+    return makeCheck(
+      "credentials",
+      "fail",
+      "Belum ada credential. Jalankan `jioogen login --email ... --password-stdin`."
+    );
+  }
+  return makeCheck("credentials", "pass", `Credential tersimpan untuk ${credentials.apiUrl}.`);
+}
+function checkApi(credentials, email, error) {
+  if (credentials === null) {
+    return makeCheck(
+      "api",
+      "warn",
+      "Dilewati: credential belum ada. Jalankan `jioogen login` lalu ulangi."
+    );
+  }
+  if (error !== null) {
+    const message = errorMessage(error);
+    if (error instanceof ApiError && (error.status === 401 || error.status === 403)) {
+      return makeCheck(
+        "api",
+        "fail",
+        `Sesi ditolak (${error.status}). Jalankan \`jioogen login\` lagi.`
+      );
+    }
+    return makeCheck(
+      "api",
+      "warn",
+      `Tidak dapat menghubungi ${credentials.apiUrl}: ${message}. Cek koneksi lalu ulangi.`
+    );
+  }
+  return makeCheck(
+    "api",
+    "pass",
+    `API ${credentials.apiUrl} terjangkau; login sebagai ${email ?? "-"}.`
+  );
+}
+function checkBinding(requestedProjectId, link, error) {
+  if (error !== null) {
+    return makeCheck(
+      "binding",
+      "fail",
+      `Link project tidak valid: ${error}. Perbaiki atau hapus .jioogen/project.json.`
+    );
+  }
+  if (link === null) {
+    return makeCheck(
+      "binding",
+      "fail",
+      "Belum terikat ke project. Jalankan `jioogen pull <projectId>` di folder bundle."
+    );
+  }
+  if (requestedProjectId !== void 0 && link.projectId !== requestedProjectId) {
+    return makeCheck(
+      "binding",
+      "fail",
+      `Bundle terikat ke project ${link.projectId}, bukan ${requestedProjectId}. Jalankan \`jioogen pull ${requestedProjectId}\`.`
+    );
+  }
+  return makeCheck("binding", "pass", `Bundle terikat ke project ${link.projectId}.`);
+}
+async function checkProject(deps, credentials, projectId) {
+  if (credentials === null) {
+    return makeCheck("project", "warn", "Dilewati: credential belum ada.");
+  }
+  if (projectId === void 0 || projectId.length === 0) {
+    return makeCheck(
+      "project",
+      "warn",
+      "Dilewati: project belum diketahui. Jalankan `jioogen pull <projectId>`."
+    );
+  }
+  try {
+    await deps.fetchExecution(credentials.apiUrl, credentials.cookie, projectId);
+    return makeCheck("project", "pass", `Project ${projectId} dapat diakses akun ini.`);
+  } catch (error) {
+    if (error instanceof ApiError) {
+      if (error.status === 404) {
+        return makeCheck(
+          "project",
+          "fail",
+          `Project ${projectId} tidak ditemukan atau bukan milik akun ini.`
+        );
+      }
+      if (error.status === 401 || error.status === 403) {
+        return makeCheck(
+          "project",
+          "fail",
+          `Akses project ditolak (${error.status}). Jalankan \`jioogen login\` lagi.`
+        );
+      }
+    }
+    return makeCheck(
+      "project",
+      "warn",
+      `Gagal memeriksa project ${projectId}: ${errorMessage(error)}. Coba lagi saat API stabil.`
+    );
+  }
+}
+async function isFile2(path) {
+  try {
+    return (await stat3(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function isDirectory2(path) {
+  try {
+    return (await stat3(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function listMarkdownFiles(directory) {
+  try {
+    const entries = await readdir3(directory, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md")).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+async function checkBundle(bundleDir) {
+  const missing = [];
+  if (!await isFile2(join5(bundleDir, "PRD.md"))) missing.push("PRD.md");
+  const specsDir = join5(bundleDir, "specs");
+  if (!await isDirectory2(specsDir)) {
+    missing.push("specs/");
+  } else {
+    const content = (await listMarkdownFiles(specsDir)).filter(
+      (name) => name.toLowerCase() !== "readme.md"
+    );
+    if (content.length === 0) missing.push("specs/*.md (konten)");
+  }
+  const tasksDir = join5(bundleDir, "tasks");
+  if (!await isDirectory2(tasksDir)) {
+    missing.push("tasks/");
+  } else {
+    const content = (await listMarkdownFiles(tasksDir)).filter(
+      (name) => name.toLowerCase() !== "readme.md"
+    );
+    if (content.length === 0) missing.push("tasks/*.md (task)");
+  }
+  if (missing.length > 0) {
+    return makeCheck(
+      "bundle",
+      "fail",
+      `Bundle tidak lengkap: ${missing.join(", ")}. Jalankan \`jioogen pull <projectId>\`.`
+    );
+  }
+  try {
+    const report = await inspectBundle(bundleDir);
+    if (!report.ok) {
+      const codes = Object.entries(report.issueCounts).map(([code, count]) => `${code}\xD7${count}`).join(", ");
+      return makeCheck(
+        "bundle",
+        "fail",
+        `Bundle gagal gate (${report.issueCount} isu: ${codes}). Perbaiki PRD/specs/tasks.`
+      );
+    }
+    return makeCheck("bundle", "pass", `Bundle lengkap dan lulus gate (${report.files} file).`);
+  } catch (error) {
+    return makeCheck("bundle", "fail", `Gagal memeriksa bundle: ${errorMessage(error)}.`);
+  }
+}
+async function checkSidecar(bundleDir) {
+  try {
+    const state = await readState(bundleDir);
+    if (state === null) {
+      return makeCheck("sidecar", "warn", "Sidecar belum ada. Jalankan `jioogen task next`.");
+    }
+    return makeCheck("sidecar", "pass", `Sidecar valid dengan ${state.tasks.length} task.`);
+  } catch (error) {
+    return makeCheck(
+      "sidecar",
+      "fail",
+      `Sidecar tidak valid: ${errorMessage(error)}. Hapus tasks/.execution/state.json lalu jalankan \`jioogen task next\`.`
+    );
+  }
+}
+async function checkLock(bundleDir) {
+  const target = lockPath(bundleDir);
+  let info;
+  try {
+    info = await stat3(target);
+  } catch (error) {
+    if (isMissingFile4(error)) {
+      return makeCheck("lock", "pass", "Tidak ada lock; sidecar bebas ditulis.");
+    }
+    return makeCheck("lock", "warn", `Tidak bisa memeriksa lock: ${errorMessage(error)}.`);
+  }
+  const ageMs = Date.now() - info.mtimeMs;
+  const ageSeconds = Math.max(0, Math.round(ageMs / 1e3));
+  if (ageMs > LOCK_STALE_MS2) {
+    return makeCheck(
+      "lock",
+      "warn",
+      `Lock basi (${ageSeconds} detik) tertinggal. Jalankan \`jioogen doctor --fix\` untuk menghapus.`,
+      true
+    );
+  }
+  return makeCheck(
+    "lock",
+    "warn",
+    `Lock masih aktif (${ageSeconds} detik); proses lain mungkin menulis. Tunggu atau hapus bila proses sudah mati.`
+  );
+}
+async function checkAgents(bundleDir) {
+  let content;
+  try {
+    content = await readFile5(join5(bundleDir, "AGENTS.md"), "utf8");
+  } catch (error) {
+    if (isMissingFile4(error)) {
+      return makeCheck(
+        "agents",
+        "fail",
+        "AGENTS.md belum ada. Jalankan `jioogen doctor --fix` untuk memasang kontrak eksekusi.",
+        true
+      );
+    }
+    return makeCheck(
+      "agents",
+      "fail",
+      `AGENTS.md tidak bisa dibaca: ${errorMessage(error)}.`,
+      true
+    );
+  }
+  if (!content.includes(AGENTS_MARKER)) {
+    return makeCheck(
+      "agents",
+      "fail",
+      "AGENTS.md ada tetapi tanpa marker JiooGen. Jalankan `jioogen doctor --fix` untuk memasang ulang.",
+      true
+    );
+  }
+  return makeCheck("agents", "pass", "AGENTS.md terpasang dengan marker eksekusi JiooGen.");
+}
+async function checkExecutionSkill(bundleDir) {
+  const missing = [];
+  for (const dir of AGENT_SKILL_DIRS) {
+    const target = join5(bundleDir, dir, EXECUTION_SKILL_NAME, "SKILL.md");
+    if (!await isFile2(target)) missing.push(dir);
+  }
+  if (missing.length > 0) {
+    return makeCheck(
+      "execution-skill",
+      "fail",
+      `Skill ${EXECUTION_SKILL_NAME} hilang di: ${missing.join(", ")}. Jalankan \`jioogen doctor --fix\`.`,
+      true
+    );
+  }
+  return makeCheck(
+    "execution-skill",
+    "pass",
+    `Skill ${EXECUTION_SKILL_NAME} ada di ${AGENT_SKILL_DIRS.length} direktori harness.`
+  );
+}
+async function checkSkillPacks(bundleDir) {
+  let manifest;
+  try {
+    manifest = await readHarnessManifest(bundleDir);
+  } catch (error) {
+    return makeCheck(
+      "skill-packs",
+      "warn",
+      `harness.json tidak bisa dibaca: ${errorMessage(error)}. Jalankan \`jioogen doctor --fix\`.`,
+      true
+    );
+  }
+  if (manifest === null) {
+    return makeCheck(
+      "skill-packs",
+      "warn",
+      ".jioogen/harness.json belum ada atau tidak valid. Jalankan `jioogen doctor --fix` untuk menulis ulang.",
+      true
+    );
+  }
+  if (manifest.packs.length === 0) {
+    return makeCheck("skill-packs", "pass", "Tidak ada skill pack yang dikelola.");
+  }
+  const issues = [];
+  for (const pack of manifest.packs) {
+    for (const name of pack.missing) {
+      issues.push(`${pack.name}: ${name} tidak tersedia saat instalasi`);
+    }
+    for (const skill of pack.skills) {
+      let matched = false;
+      for (const dir of AGENT_SKILL_DIRS) {
+        const target = join5(bundleDir, dir, skill.name);
+        if (!await isFile2(join5(target, "SKILL.md"))) continue;
+        try {
+          if (await hashSkillDirectory(target) === skill.sha256) {
+            matched = true;
+            break;
+          }
+        } catch {
+        }
+      }
+      if (!matched) issues.push(`${pack.name}: ${skill.name} hilang atau hash tidak cocok`);
+    }
+  }
+  if (issues.length > 0) {
+    return makeCheck(
+      "skill-packs",
+      "warn",
+      `Skill pack bermasalah: ${issues.join("; ")}. Jalankan \`jioogen doctor --fix\`.`,
+      true
+    );
+  }
+  return makeCheck(
+    "skill-packs",
+    "pass",
+    `Semua skill pack cocok (${manifest.packs.length} pack).`
+  );
+}
+async function checkDuplicates(bundleDir) {
+  let manifest = null;
+  try {
+    manifest = await readHarnessManifest(bundleDir);
+  } catch {
+  }
+  const managed = /* @__PURE__ */ new Set([EXECUTION_SKILL_NAME]);
+  for (const pack of manifest?.packs ?? []) {
+    for (const skill of pack.skills) managed.add(skill.name);
+  }
+  const dirsByName = /* @__PURE__ */ new Map();
+  for (const dir of AGENT_SKILL_DIRS) {
+    const root = join5(bundleDir, dir);
+    if (!await isDirectory2(root)) continue;
+    let entries;
+    try {
+      entries = await readdir3(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (managed.has(entry.name)) continue;
+      if (!await isFile2(join5(root, entry.name, "SKILL.md"))) continue;
+      const owners = dirsByName.get(entry.name) ?? [];
+      owners.push(dir);
+      dirsByName.set(entry.name, owners);
+    }
+  }
+  const duplicates = [...dirsByName.entries()].filter(([, dirs]) => dirs.length > 1);
+  if (duplicates.length === 0) {
+    return makeCheck("duplicates", "pass", "Tidak ada skill duplikat antar-harness.");
+  }
+  const detail = duplicates.map(([name, dirs]) => `${name} (${dirs.join(", ")})`).join("; ");
+  return makeCheck(
+    "duplicates",
+    "warn",
+    `Skill yang sama ada di beberapa harness: ${detail}. Pastikan itu disengaja.`
+  );
+}
+async function checkHarness(bundleDir) {
+  const detected = [];
+  for (const dir of AGENT_SKILL_DIRS) {
+    if (await isDirectory2(join5(bundleDir, dir))) detected.push(dir);
+  }
+  if (detected.length === 0) {
+    return makeCheck("harness", "pass", "Tidak ada direktori harness terdeteksi.");
+  }
+  return makeCheck("harness", "pass", `Harness terdeteksi: ${detected.join(", ")}.`);
+}
+async function runChecks(options, deps) {
+  const checks = [checkNode()];
+  let credentials = null;
+  let credentialsError = null;
+  try {
+    credentials = await deps.readCredentials();
+  } catch (error) {
+    credentialsError = errorMessage(error);
+  }
+  checks.push(checkCredentials(credentials, credentialsError));
+  let email = null;
+  let apiError2 = null;
+  if (credentials !== null) {
+    try {
+      email = (await deps.fetchMe(credentials.apiUrl, credentials.cookie)).email;
+    } catch (error) {
+      apiError2 = error;
+    }
+  }
+  checks.push(checkApi(credentials, email, apiError2));
+  let link = null;
+  let linkError = null;
+  try {
+    link = await findProjectLink(options.bundleDir);
+  } catch (error) {
+    linkError = errorMessage(error);
+  }
+  checks.push(checkBinding(options.projectId, link, linkError));
+  const effectiveProjectId = options.projectId ?? link?.projectId;
+  checks.push(await checkProject(deps, credentials, effectiveProjectId));
+  checks.push(await checkBundle(options.bundleDir));
+  checks.push(await checkSidecar(options.bundleDir));
+  checks.push(await checkLock(options.bundleDir));
+  checks.push(await checkAgents(options.bundleDir));
+  checks.push(await checkExecutionSkill(options.bundleDir));
+  checks.push(await checkSkillPacks(options.bundleDir));
+  checks.push(await checkDuplicates(options.bundleDir));
+  checks.push(await checkHarness(options.bundleDir));
+  return checks;
+}
+async function applyFixes(options, deps, checks) {
+  let changed = false;
+  if (checks.some((check) => check.id === "lock" && check.fixable === true)) {
+    try {
+      await rm4(lockPath(options.bundleDir), { force: true });
+      changed = true;
+    } catch {
+    }
+  }
+  const needsScaffold = checks.some(
+    (check) => check.fixable === true && BUNDLE_SCAFFOLD_CHECKS.has(check.id)
+  );
+  if (needsScaffold) {
+    try {
+      await deps.installSkills(options.bundleDir);
+      changed = true;
+    } catch {
+    }
+  }
+  return changed;
+}
+async function runDoctor(options) {
+  const deps = resolveDeps(options.deps);
+  let checks = await runChecks(options, deps);
+  if (options.fix) {
+    const changed = await applyFixes(options, deps, checks);
+    if (changed) checks = await runChecks(options, deps);
+  }
+  return { ok: !checks.some((check) => check.status === "fail"), checks };
+}
+
+// src/errors.ts
+var UsageError = class extends Error {
+};
+
+// src/output.ts
+function formatTable(headers, rows) {
+  const widths = headers.map(
+    (header, index) => Math.max(header.length, ...rows.map((row) => (row[index] ?? "").length))
+  );
+  const render = (cells) => cells.map((cell, index) => cell.padEnd(widths[index] ?? 0)).join("  ").trimEnd();
+  const divider = widths.map((width) => "-".repeat(width)).join("  ");
+  return [render(headers), divider, ...rows.map(render)].join("\n");
 }
 
+// src/session.ts
+import { rm as rm5, stat as stat4 } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+
 // src/tasks.ts
-import { readdir as readdir2, readFile as readFile5 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { readdir as readdir4, readFile as readFile6 } from "node:fs/promises";
+import { join as join6 } from "node:path";
 var TASK_ID_RE2 = /\b(?:TASK|T)-\d{3,}\b/i;
 var HEADING_RE = /^#{1,4}\s+(.+)$/m;
 var LAYER_RANK = {
@@ -8964,13 +9789,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");
+  const tasksDir = join6(bundleDir, "tasks");
   let entries;
   try {
-    entries = await readdir2(tasksDir, { withFileTypes: true });
+    entries = await readdir4(tasksDir, { withFileTypes: true });
   } catch (error) {
-    if (isMissingFile3(error)) throw new Error(`Direktori tasks/ tidak ditemukan di ${bundleDir}`);
+    if (isMissingFile5(error)) throw new Error(`Direktori tasks/ tidak ditemukan di ${bundleDir}`);
     throw error;
   }
   const names = entries.filter(
@@ -8979,16 +9842,16 @@ async function loadTasks(bundleDir) {
   const tasks = [];
   if (names.length > 0) {
     for (const name of names) {
-      const content = await readFile5(join5(tasksDir, name), "utf8");
+      const content = await readFile6(join6(tasksDir, name), "utf8");
       tasks.push(parseSingleTask(name, content));
     }
   } else {
-    const singlePath = join5(tasksDir, "TASKS.md");
+    const singlePath = join6(tasksDir, "TASKS.md");
     let content;
     try {
-      content = await readFile5(singlePath, "utf8");
+      content = await readFile6(singlePath, "utf8");
     } catch (error) {
-      if (isMissingFile3(error)) throw new Error(`Tidak ada berkas task di ${tasksDir}`);
+      if (isMissingFile5(error)) throw new Error(`Tidak ada berkas task di ${tasksDir}`);
       throw error;
     }
     tasks.push(...parseSingleFile(content));
@@ -9041,7 +9904,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 +9921,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,16 +10021,194 @@ function isBoundary(previous, next) {
   }
   return previous.phase !== void 0 && next.phase !== previous.phase;
 }
-function isMissingFile3(error) {
+var RISKY_TASK_RE = /\b(migrat(?:e|ion|ions)?|migrasi|prisma|schema|rls|auth|permission|payment|checkout|webhook|secret|deploy|drop)\b/i;
+var TARGET_FILES_LABEL_RE = /^\s*(?:[-*]\s*)?\*{0,2}targetFiles\*{0,2}\s*:\s*(.*)$/i;
+function isRiskyTask(task) {
+  const targetFiles = task.targetFiles ?? targetFilesFromContent(task.content);
+  return RISKY_TASK_RE.test([task.id, task.title, ...targetFiles].join("\n"));
+}
+function targetFilesFromContent(content) {
+  const lines = content.split(/\r?\n/);
+  const index = lines.findIndex((line) => TARGET_FILES_LABEL_RE.test(line));
+  if (index === -1) return [];
+  const inline = (lines[index]?.match(TARGET_FILES_LABEL_RE)?.[1] ?? "").trim();
+  if (inline.length > 0) return splitTargetFiles(inline);
+  const items = [];
+  for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+    const line = lines[cursor] ?? "";
+    if (line.trim().length === 0) continue;
+    const item = /^\s*-\s+(.+?)\s*$/.exec(line);
+    if (item === null) break;
+    const cleaned = cleanTargetFile(item[1] ?? "");
+    if (cleaned.length > 0) items.push(cleaned);
+  }
+  return items;
+}
+function splitTargetFiles(value) {
+  return value.replace(/[[\]`]/g, "").split(",").map(cleanTargetFile).filter((part) => part.length > 0 && !/^(?:\(?none\)?|n\/a|-+)$/i.test(part));
+}
+function cleanTargetFile(value) {
+  return value.replace(/^[-*\s]+/, "").trim();
+}
+function isMissingFile5(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/session.ts
+var LOCK_STALE_MS3 = 1e4;
+var CHANGE_REQUEST_PREFIX = "Perubahan diminta:";
+async function resumeSession(options) {
+  const context = await resolveBundleContext(options);
+  await removeStaleLock2(context.bundleDir);
+  const initial = await readState(context.bundleDir);
+  if (initial === null) {
+    return {
+      projectId: context.projectId ?? "",
+      bundleDir: context.bundleDir,
+      hasState: false,
+      current: null,
+      nextRef: null,
+      awaitingCheckpoint: false
+    };
+  }
+  return withStateLock(context.bundleDir, async () => {
+    const state = await readState(context.bundleDir) ?? initial;
+    const definitions = await loadTasks(context.bundleDir);
+    const merged = mergeTasks(state, definitions);
+    const written = await writeState(context.bundleDir, merged);
+    const current = written.current ?? null;
+    const next = selectNext(definitions, written.tasks);
+    return {
+      projectId: written.projectId ?? context.projectId ?? "",
+      bundleDir: context.bundleDir,
+      hasState: true,
+      current,
+      nextRef: next?.task.id ?? null,
+      awaitingCheckpoint: current?.awaitingCheckpoint === true
+    };
+  });
+}
+async function reviewSession(options, review) {
+  const context = await resolveBundleContext(options);
+  return withStateLock(context.bundleDir, async () => {
+    const state = await readState(context.bundleDir);
+    if (state === null) return unchanged(review.action, null);
+    const current = state.current ?? null;
+    if (review.action === "stop") {
+      return stopReview(context.bundleDir, state, current, review.note);
+    }
+    if (current === null || current.awaitingCheckpoint !== true) {
+      return unchanged(review.action, current?.ref ?? null);
+    }
+    if (review.action === "approve") {
+      const cleared = { ...current, awaitingCheckpoint: false };
+      const written2 = await writeState(context.bundleDir, setCurrent(state, cleared));
+      const ref2 = written2.current?.ref ?? current.ref ?? null;
+      return { action: review.action, ref: ref2, clearedCheckpoint: true, nextRef: ref2 };
+    }
+    const ref = review.ref ?? latestDoneRef(state);
+    if (ref === null) {
+      return {
+        action: review.action,
+        ref: null,
+        clearedCheckpoint: false,
+        nextRef: current.ref ?? null
+      };
+    }
+    const target = findTask(state, ref);
+    if (target === void 0) {
+      throw new Error(
+        `Task ${ref} tidak ada di sidecar. Jalankan \`jioogen task next\` lebih dulu.`
+      );
+    }
+    const note = `${CHANGE_REQUEST_PREFIX} ${review.note ?? ""}`.trim();
+    const reopened = withStatus(state, target.ref, "in_progress", { note, awaitingCheckpoint: false });
+    const reopenedTarget = findTask(reopened, target.ref);
+    const nextCurrent = {
+      ref: reopenedTarget?.ref ?? target.ref,
+      ...reopenedTarget?.layer !== void 0 ? { layer: reopenedTarget.layer } : {},
+      ...reopenedTarget?.phase !== void 0 ? { phase: reopenedTarget.phase } : {},
+      awaitingCheckpoint: false
+    };
+    const written = await writeState(context.bundleDir, setCurrent(reopened, nextCurrent));
+    const finalRef = written.current?.ref ?? nextCurrent.ref ?? null;
+    return { action: review.action, ref: finalRef, clearedCheckpoint: true, nextRef: finalRef };
+  });
+}
+async function stopReview(bundleDir, state, current, note) {
+  const ref = current?.ref ?? null;
+  if (note === void 0 || note.length === 0 || current?.ref === void 0) {
+    return { action: "stop", ref, clearedCheckpoint: false, nextRef: ref };
+  }
+  const key = current.ref.toUpperCase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const tasks = state.tasks.map(
+    (task) => task.ref.toUpperCase() === key ? { ...task, note, updatedAt: now } : task
+  );
+  const written = await writeState(bundleDir, { ...state, tasks });
+  return {
+    action: "stop",
+    ref,
+    clearedCheckpoint: false,
+    nextRef: written.current?.ref ?? ref
+  };
+}
+function unchanged(action, ref) {
+  return { action, ref, clearedCheckpoint: false, nextRef: ref };
+}
+function findTask(state, ref) {
+  const key = ref.toUpperCase();
+  return state.tasks.find((task) => task.ref.toUpperCase() === key);
+}
+function latestDoneRef(state) {
+  let latest = null;
+  for (const task of state.tasks) {
+    if (task.status !== "done") continue;
+    if (latest === null || updatedAtMs(task) >= updatedAtMs(latest)) latest = task;
+  }
+  return latest?.ref ?? null;
+}
+function updatedAtMs(task) {
+  if (task.updatedAt === void 0) return Number.NEGATIVE_INFINITY;
+  const value = Date.parse(task.updatedAt);
+  return Number.isNaN(value) ? Number.NEGATIVE_INFINITY : value;
+}
+async function resolveBundleContext(options) {
+  const link = await findProjectLink(options.dir ?? process.cwd());
+  const projectId = options.project ?? envFirst("JIOOGEN_PROJECT", "JIOOCODE_PROJECT") ?? link?.projectId;
+  return {
+    projectId,
+    bundleDir: resolve3(link?.bundleDir ?? options.dir ?? process.cwd())
+  };
+}
+async function removeStaleLock2(bundleDir) {
+  const target = lockPath(bundleDir);
+  let info;
+  try {
+    info = await stat4(target);
+  } catch (error) {
+    if (isMissingFile6(error)) return;
+    throw error;
+  }
+  if (Date.now() - info.mtimeMs <= LOCK_STALE_MS3) return;
+  await rm5(target, { force: true });
+}
+function envFirst(primary, legacy) {
+  const value = process.env[primary]?.trim();
+  if (value !== void 0 && value.length > 0) return value;
+  const fallback = process.env[legacy]?.trim();
+  return fallback !== void 0 && fallback.length > 0 ? fallback : void 0;
+}
+function isMissingFile6(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/zip.ts
 var import_adm_zip = __toESM(require_adm_zip(), 1);
 import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname4, resolve as resolve3, sep } from "node:path";
+import { dirname as dirname4, resolve as resolve4, sep } from "node:path";
 async function extractBundle(bytes, targetDir) {
-  const root = resolve3(targetDir);
+  const root = resolve4(targetDir);
   const zip = new import_adm_zip.default(Buffer.from(bytes));
   const written = [];
   for (const entry of zip.getEntries()) {
@@ -9168,7 +10218,7 @@ async function extractBundle(bytes, targetDir) {
     if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
       throw new Error(`Path bundle tidak aman: ${entry.entryName}`);
     }
-    const destination = resolve3(root, relative2);
+    const destination = resolve4(root, relative2);
     if (!destination.startsWith(`${root}${sep}`)) {
       throw new Error(`Path bundle keluar dari direktori target: ${entry.entryName}`);
     }
@@ -9185,10 +10235,10 @@ function isValidProjectId(projectId) {
   return PROJECT_ID_RE.test(projectId.trim());
 }
 async function loginCommand(options) {
-  const token = options.token ?? envFirst("JIOOGEN_TOKEN", "JIOOCODE_TOKEN");
+  const token = options.token ?? envFirst2("JIOOGEN_TOKEN", "JIOOCODE_TOKEN");
   if (token !== void 0 && token.length > 0) {
     const apiUrl = normalizeBaseUrl(
-      options.api ?? envFirst("JIOOGEN_API", "JIOOCODE_API") ?? DEFAULT_API_URL
+      options.api ?? envFirst2("JIOOGEN_API", "JIOOCODE_API") ?? DEFAULT_API_URL
     );
     const client = new ApiClient(apiUrl, `${SESSION_COOKIE}=${token}`);
     const body = await client.getJson(ENDPOINTS.me);
@@ -9203,17 +10253,17 @@ async function loginCommand(options) {
     console.log(`Credential disimpan di ${credentialsPath()} (mode 0600).`);
     return;
   }
-  const email = options.email ?? envFirst("JIOOGEN_EMAIL", "JIOOCODE_EMAIL");
+  const email = options.email ?? envFirst2("JIOOGEN_EMAIL", "JIOOCODE_EMAIL");
   if (email === void 0 || email.length === 0) {
     throw new Error("--email wajib diisi (atau set JIOOGEN_EMAIL).");
   }
-  let password = options.password ?? envFirst("JIOOGEN_PASSWORD", "JIOOCODE_PASSWORD");
+  let password = options.password ?? envFirst2("JIOOGEN_PASSWORD", "JIOOCODE_PASSWORD");
   if (options.passwordStdin === true) password = (await readStdin()).trim();
   if (password === void 0 || password.length === 0) {
     throw new Error("--password atau --password-stdin wajib diisi.");
   }
   const result = await apiLogin(
-    options.api ?? envFirst("JIOOGEN_API", "JIOOCODE_API") ?? DEFAULT_API_URL,
+    options.api ?? envFirst2("JIOOGEN_API", "JIOOCODE_API") ?? DEFAULT_API_URL,
     email,
     password
   );
@@ -9271,11 +10321,11 @@ async function pullCommand(projectId, options) {
   }
   await assertPullDefaultDir(process.cwd(), options.dir);
   const { apiUrl, client } = await resolveApi(options);
-  const target = resolve4(options.dir ?? projectId);
+  const target = resolve5(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));
@@ -9283,36 +10333,29 @@ 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);
-  const target = resolve4(options.dir ?? process.cwd());
+  const target = resolve5(options.dir ?? process.cwd());
   await assertLinkTarget(target, projectId);
   await verifyProjectAccess(client, projectId);
   await writeProjectLink(target, { projectId, apiUrl });
-  const skills = await installAgentSkills(target);
-  const linkedFile = join6(target, ".jioogen", "project.json");
+  const skills = await installAgentSkills(target, { noSkills: skillsDisabled(options) });
+  const linkedFile = join7(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;
@@ -9320,10 +10363,94 @@ 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 resolve5(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());
-  const bundleDir = resolve4(link?.bundleDir ?? options.dir ?? process.cwd());
+  const bundleDir = resolve5(link?.bundleDir ?? options.dir ?? process.cwd());
   const result = await inspectBundle(bundleDir);
   if (options.json === true) {
     console.log(JSON.stringify(result, null, 2));
@@ -9332,6 +10459,90 @@ async function checkCommand(options) {
   }
   if (!result.ok) process.exitCode = 1;
 }
+async function doctorCommand(options) {
+  const link = await findProjectLink(options.dir ?? process.cwd());
+  const bundleDir = resolve5(link?.bundleDir ?? options.dir ?? process.cwd());
+  const projectId = options.project ?? link?.projectId;
+  const report = await runDoctor({
+    bundleDir,
+    ...projectId === void 0 ? {} : { projectId },
+    fix: options.fix === true
+  });
+  if (options.json === true) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    for (const check of report.checks) {
+      console.log(`${check.status.toUpperCase().padEnd(4)} ${check.id} \u2014 ${check.detail}`);
+    }
+    const fails = report.checks.filter((check) => check.status === "fail").length;
+    const warns = report.checks.filter((check) => check.status === "warn").length;
+    console.log(
+      `
+${report.ok ? "Doctor OK" : "Doctor GAGAL"} (${fails} fail, ${warns} warn).` + (options.fix === true ? "" : " Jalankan `jioogen doctor --fix` untuk perbaikan wiring.")
+    );
+  }
+  if (!report.ok) process.exitCode = 1;
+}
+async function resumeCommand(options) {
+  const result = await resumeSession(options);
+  if (options.json === true) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (!result.hasState) {
+    console.log("Belum ada eksekusi tersimpan. Mulai dengan `jioogen task next`.");
+    return;
+  }
+  const current = result.current?.ref ?? "-";
+  console.log(`Resume project ${result.projectId} di ${result.bundleDir}.`);
+  console.log(`Current: ${current}${result.awaitingCheckpoint ? " (checkpoint)" : ""}`);
+  console.log(`Task berikutnya: ${result.nextRef ?? "selesai"}.`);
+  if (result.awaitingCheckpoint) {
+    console.log(
+      'Putuskan: `jioogen review --approve`, `--request-changes "<teks>"`, atau `--stop`.'
+    );
+  }
+}
+async function reviewCommand(options) {
+  const actions = [
+    options.approve === true ? "approve" : void 0,
+    options.requestChanges !== void 0 ? "request-changes" : void 0,
+    options.stop === true ? "stop" : void 0
+  ].filter((action2) => action2 !== void 0);
+  if (actions.length !== 1) {
+    throw new UsageError(
+      '`jioogen review` butuh tepat satu: --approve, --request-changes "<teks>", atau --stop.'
+    );
+  }
+  const action = actions[0];
+  if (action === void 0) {
+    throw new UsageError("`jioogen review` butuh tepat satu aksi.");
+  }
+  const result = await reviewSession(options, {
+    action,
+    ...options.requestChanges === void 0 ? {} : { note: options.requestChanges },
+    ...options.ref === void 0 ? {} : { ref: options.ref }
+  });
+  if (options.json === true) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (action === "stop") {
+    console.log("Review: stop. Checkpoint dipertahankan; lanjutkan kapan saja dengan `resume`.");
+    return;
+  }
+  if (!result.clearedCheckpoint) {
+    console.log("Tidak ada checkpoint aktif. Jalankan `jioogen resume` untuk status.");
+    return;
+  }
+  if (action === "approve") {
+    console.log("Review: disetujui. Checkpoint dibuka.");
+  } else {
+    console.log(`Review: perubahan diminta untuk ${result.ref ?? "task terakhir"}.`);
+  }
+  if (result.nextRef !== null) console.log(`Task berikutnya: ${result.nextRef}.`);
+  console.log("Jalankan `jioogen sync` agar panel monitoring ikut diperbarui.");
+}
 async function handoffCommand(options) {
   const { client, projectId } = await resolveBundle(options);
   const payload = await client.postJson(
@@ -9348,15 +10559,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));
@@ -9373,7 +10588,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(
@@ -9427,11 +10647,17 @@ async function taskCompleteCommand(ref, options) {
       (entry) => entry.ref.toUpperCase() === ref.toUpperCase()
     );
     const next2 = selectNext(local.definitions, completed.tasks);
-    if (completedTask2 !== void 0 && next2 !== null && isBoundary(completedTask2, next2.task)) {
+    const definition = local.definitions.find(
+      (entry) => entry.id.toUpperCase() === ref.toUpperCase()
+    );
+    const risky = definition !== void 0 && isRiskyTask(definition);
+    const boundary = completedTask2 !== void 0 && (next2 !== null && isBoundary(completedTask2, next2.task) || risky);
+    if (boundary && completedTask2 !== void 0) {
+      const target = next2?.task;
       const withCheckpoint = setCurrent(completed, {
-        ref: next2.task.id,
-        ...next2.task.layer !== void 0 ? { layer: next2.task.layer } : {},
-        phase: next2.task.phase,
+        ref: target?.id ?? completedTask2.ref,
+        layer: target?.layer ?? completedTask2.layer,
+        phase: target?.phase ?? completedTask2.phase ?? 1,
         awaitingCheckpoint: true
       });
       await writeState(local.bundleDir, withCheckpoint);
@@ -9441,11 +10667,17 @@ async function taskCompleteCommand(ref, options) {
     return { completedTask: completedTask2, next: next2, checkpoint: false };
   });
   console.log(`Done ${completedTask?.ref ?? ref}.`);
-  if (checkpoint && next !== null) {
+  if (checkpoint) {
+    if (next === null) {
+      console.log("Semua task selesai; menunggu review terakhir.");
+    } else {
+      console.log(
+        `Checkpoint berikutnya: ${next.task.id} (${next.task.layer ?? "-"} / phase ${next.task.phase}).`
+      );
+    }
     console.log(
-      `Checkpoint berikutnya: ${next.task.id} (${next.task.layer ?? "-"} / phase ${next.task.phase}).`
+      'Berhenti. Setelah user memutuskan: `jioogen review --approve`, `--request-changes "<teks>"`, atau `--stop`; lalu `jioogen sync`.'
     );
-    console.log("Berhenti dan minta konfirmasi user sebelum task start berikutnya.");
     return;
   }
   if (next !== null) console.log(`Berikutnya: ${next.task.id} \u2014 ${next.task.title}`);
@@ -9547,7 +10779,7 @@ async function syncCommand(options) {
       assertBundleRelative(relative2);
       files.push({
         path: relative2,
-        content: await readFile6(join6(bundleDir, relative2), "utf8")
+        content: await readFile7(join7(bundleDir, relative2), "utf8")
       });
     }
   }
@@ -9569,9 +10801,9 @@ async function syncCommand(options) {
 async function resolveApi(options) {
   const stored = await readCredentials();
   const apiUrl = normalizeBaseUrl(
-    options.api ?? envFirst("JIOOGEN_API", "JIOOCODE_API") ?? stored?.apiUrl ?? DEFAULT_API_URL
+    options.api ?? envFirst2("JIOOGEN_API", "JIOOCODE_API") ?? stored?.apiUrl ?? DEFAULT_API_URL
   );
-  const explicitCookie = envFirst("JIOOGEN_COOKIE", "JIOOCODE_COOKIE");
+  const explicitCookie = envFirst2("JIOOGEN_COOKIE", "JIOOCODE_COOKIE");
   const storedCookie = stored !== null && normalizeBaseUrl(stored.apiUrl) === apiUrl ? stored.cookie : void 0;
   const cookie = explicitCookie || storedCookie;
   if (cookie === void 0 || cookie.length === 0) {
@@ -9586,7 +10818,7 @@ async function resolveApi(options) {
 }
 async function resolveLocalBundle(options) {
   const link = await findProjectLink(options.dir ?? process.cwd());
-  const projectId = options.project ?? envFirst("JIOOGEN_PROJECT", "JIOOCODE_PROJECT") ?? link?.projectId;
+  const projectId = options.project ?? envFirst2("JIOOGEN_PROJECT", "JIOOCODE_PROJECT") ?? link?.projectId;
   if (projectId === void 0 || projectId.length === 0) {
     throw new Error(
       "Project belum di-bind. Jalankan `jioogen pull <projectId>` atau pakai --project."
@@ -9594,7 +10826,7 @@ async function resolveLocalBundle(options) {
   }
   return {
     projectId,
-    bundleDir: resolve4(link?.bundleDir ?? options.dir ?? process.cwd()),
+    bundleDir: resolve5(link?.bundleDir ?? options.dir ?? process.cwd()),
     linkedApiUrl: link?.apiUrl
   };
 }
@@ -9647,9 +10879,9 @@ async function assertPullDefaultDir(cwd, dirOption) {
 async function assertPullTarget(target, projectId, force = false) {
   let entries;
   try {
-    entries = await readdir3(target);
+    entries = await readdir5(target);
   } catch (error) {
-    if (isMissingFile4(error)) return;
+    if (isMissingFile7(error)) return;
     throw error;
   }
   if (entries.length === 0) return;
@@ -9681,19 +10913,19 @@ async function assertLinkTarget(target, projectId) {
 }
 async function hasBundleMarkers(target) {
   try {
-    await readFile6(join6(target, "PRD.md"));
+    await readFile7(join7(target, "PRD.md"));
     return true;
   } catch (error) {
-    if (!isMissingFile4(error)) throw error;
+    if (!isMissingFile7(error)) throw error;
   }
-  return hasTaskMarkdown(join6(target, "tasks"));
+  return hasTaskMarkdown(join7(target, "tasks"));
 }
 async function hasTaskMarkdown(directory) {
   let names;
   try {
-    names = await readdir3(directory);
+    names = await readdir5(directory);
   } catch (error) {
-    if (isMissingFile4(error)) return false;
+    if (isMissingFile7(error)) return false;
     throw error;
   }
   return names.some((name) => name.toLowerCase().endsWith(".md"));
@@ -9749,18 +10981,18 @@ async function readStdin() {
   for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
   return Buffer.concat(chunks).toString("utf8");
 }
-function envFirst(primary, legacy) {
+function envFirst2(primary, legacy) {
   const value = process.env[primary]?.trim();
   if (value !== void 0 && value.length > 0) return value;
   const fallback = process.env[legacy]?.trim();
   return fallback !== void 0 && fallback.length > 0 ? fallback : void 0;
 }
-function isMissingFile4(error) {
+function isMissingFile7(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/index.ts
-var VERSION = "0.2.3";
+var VERSION = "0.2.5";
 var USAGE = `jioogen \u2014 CLI JiooGen (task selection lokal, server read-only)
 
 Usage:
@@ -9769,10 +11001,17 @@ 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 doctor [--fix] [--dir <dir>] [--json]
+  jioogen resume [--dir <dir>] [--json]
+  jioogen review (--approve | --request-changes <teks> | --stop) [--ref <TASK-XXX>] [--json]
   jioogen handoff [--project <id>] [--json]
   jioogen task next [--json]
   jioogen task start <ref>
@@ -9789,6 +11028,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
 `;
@@ -9809,8 +11049,14 @@ async function main() {
         dir: { type: "string" },
         remote: { type: "boolean" },
         force: { type: "boolean" },
+        "no-skills": { type: "boolean" },
         files: { type: "string" },
         note: { type: "string" },
+        fix: { type: "boolean" },
+        approve: { type: "boolean" },
+        stop: { type: "boolean" },
+        "request-changes": { type: "string" },
+        ref: { type: "string" },
         json: { type: "boolean" },
         help: { type: "boolean", short: "h" },
         version: { type: "boolean", short: "v" }
@@ -9835,8 +11081,14 @@ 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),
+    fix: flag(raw.fix),
+    approve: flag(raw.approve),
+    stop: flag(raw.stop),
+    requestChanges: text(raw["request-changes"]),
+    ref: text(raw.ref),
     json: flag(raw.json)
   };
   if (flag(raw.version)) {
@@ -9899,6 +11151,15 @@ async function dispatch(command, rest, options) {
     case "check":
       await checkCommand(options);
       return;
+    case "doctor":
+      await doctorCommand(options);
+      return;
+    case "resume":
+      await resumeCommand(options);
+      return;
+    case "review":
+      await reviewCommand(options);
+      return;
     case "handoff":
       await handoffCommand(options);
       return;
@@ -9925,8 +11186,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) {