@iamk77/skill-checklist 0.2.0

package/dist/builtins/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBuiltin = getBuiltin;
+exports.listBuiltins = listBuiltins;
+const frontmatter_js_1 = require("./frontmatter.js");
+const name_format_js_1 = require("./name-format.js");
+const description_js_1 = require("./description.js");
+const no_secrets_js_1 = require("./no-secrets.js");
+const file_refs_js_1 = require("./file-refs.js");
+const has_checklist_js_1 = require("./has-checklist.js");
+const line_count_js_1 = require("./line-count.js");
+const BUILTINS = {
+    'frontmatter': frontmatter_js_1.frontmatterCheck,
+    'name-format': name_format_js_1.nameFormatCheck,
+    'description-present': description_js_1.descriptionPresentCheck,
+    'description-length': description_js_1.descriptionLengthCheck,
+    'no-secrets': no_secrets_js_1.noSecretsCheck,
+    'file-refs': file_refs_js_1.fileRefsCheck,
+    'has-checklist': has_checklist_js_1.hasChecklistCheck,
+    'line-count': line_count_js_1.lineCountCheck,
+};
+function getBuiltin(name) {
+    return BUILTINS[name];
+}
+function listBuiltins() {
+    return Object.keys(BUILTINS);
+}

package/dist/builtins/line-count.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lineCountCheck = lineCountCheck;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const MAX_LINES = 500;
+async function lineCountCheck(targetPath) {
+    const filePath = path.resolve(targetPath, 'SKILL.md');
+    if (!fs.existsSync(filePath)) {
+        return { status: 'fail', message: 'SKILL.md not found' };
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const count = content.split('\n').length;
+    if (count > MAX_LINES) {
+        return { status: 'fail', message: `${count} lines, exceeds ${MAX_LINES} limit` };
+    }
+    return { status: 'pass', message: `${count} lines` };
+}

package/dist/builtins/name-format.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nameFormatCheck = nameFormatCheck;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const gray_matter_1 = __importDefault(require("gray-matter"));
+const NAME_RE = /^[a-z0-9-]+$/;
+const MAX_LENGTH = 64;
+async function nameFormatCheck(targetPath) {
+    const filePath = path.resolve(targetPath, 'SKILL.md');
+    if (!fs.existsSync(filePath)) {
+        return { status: 'fail', message: 'SKILL.md not found' };
+    }
+    const { data } = (0, gray_matter_1.default)(fs.readFileSync(filePath, 'utf-8'));
+    const name = data.name;
+    if (name === undefined || name === null || name === '') {
+        return { status: 'pass', message: 'name field not set (will use directory name)' };
+    }
+    if (typeof name !== 'string') {
+        return { status: 'fail', message: 'name must be a string' };
+    }
+    if (!NAME_RE.test(name)) {
+        return { status: 'fail', message: `invalid characters: "${name}"` };
+    }
+    if (name.length > MAX_LENGTH) {
+        return { status: 'fail', message: `${name.length}/${MAX_LENGTH} chars` };
+    }
+    return { status: 'pass', message: `"${name}", ${name.length} chars` };
+}

package/dist/builtins/no-secrets.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noSecretsCheck = noSecretsCheck;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+// High-confidence standalone token shapes. These are always flagged when matched.
+const TOKEN_PATTERNS = [
+    { name: 'AWS Access Key', re: /AKIA[0-9A-Z]{16}/ },
+    { name: 'Private Key', re: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/ },
+    { name: 'GitHub Token', re: /gh[pousr]_[a-zA-Z0-9]{20,}/ },
+    { name: 'GitHub Fine-grained Token', re: /github_pat_[a-zA-Z0-9_]{20,}/ },
+    { name: 'npm Token', re: /npm_[a-zA-Z0-9]{20,}/ },
+    { name: 'Slack Token', re: /xox[baprs]-[a-zA-Z0-9-]{10,}/ },
+    { name: 'OpenAI Key', re: /sk-[a-zA-Z0-9]{20,}/ },
+    { name: 'Google API Key', re: /AIza[0-9A-Za-z_\-]{35}/ },
+];
+// Generic `key = value` assignments. Flagged only when the value does not look
+// like a documentation placeholder (e.g. YOUR_TOKEN, <api-key>, changeme).
+const ASSIGNMENT_PATTERNS = [
+    { name: 'API Key assignment', re: /(?:api[_-]?key|apikey)\s*[:=]\s*['"]?([^\s'"]{20,})/i },
+    { name: 'Token/Secret assignment', re: /(?:token|secret|password|passwd|pwd)\s*[:=]\s*['"]?([^\s'"]{8,})/i },
+];
+const PLACEHOLDER_RE = /^(?:[<{].*[>}]|\.{3,}|x{3,}|your[_-]|my[_-]|changeme|placeholder|replace|example|todo|\$\{|env\.|process\.env)/i;
+function isPlaceholder(value) {
+    return PLACEHOLDER_RE.test(value) || /^[A-Z][A-Z0-9_]+$/.test(value); // ALL_CAPS_PLACEHOLDER
+}
+async function noSecretsCheck(targetPath) {
+    const filePath = path.resolve(targetPath, 'SKILL.md');
+    if (!fs.existsSync(filePath)) {
+        return { status: 'fail', message: 'SKILL.md not found' };
+    }
+    const lines = fs.readFileSync(filePath, 'utf-8').split('\n');
+    const findings = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of TOKEN_PATTERNS) {
+            if (pattern.re.test(line)) {
+                findings.push(`L${i + 1}: ${pattern.name}`);
+            }
+        }
+        for (const pattern of ASSIGNMENT_PATTERNS) {
+            const m = pattern.re.exec(line);
+            if (m && !isPlaceholder(m[1])) {
+                findings.push(`L${i + 1}: ${pattern.name}`);
+            }
+        }
+    }
+    if (findings.length > 0) {
+        return { status: 'fail', message: findings.join(', ') };
+    }
+    return { status: 'pass', message: 'no secret patterns detected' };
+}

package/dist/commands/check.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCommand = checkCommand;
+const loader_js_1 = require("../loader.js");
+const state_js_1 = require("../state.js");
+const resolver_js_1 = require("../resolver.js");
+const formatter_js_1 = require("../formatter.js");
+function checkCommand(phaseArg, itemId, options) {
+    const cwd = (0, resolver_js_1.resolveDir)(options.dir);
+    try {
+        const config = (0, loader_js_1.loadChecklist)(cwd);
+        const state = (0, state_js_1.loadState)(cwd);
+        const phaseIndex = (0, resolver_js_1.findPhaseIndex)(config, phaseArg);
+        const gate = (0, resolver_js_1.gatePriorPhases)(config, phaseIndex, state);
+        if (!gate.passed) {
+            console.error((0, formatter_js_1.formatGateFailure)(gate.failedPhase, gate.failedPhaseIndex));
+            process.exit(1);
+        }
+        const phase = config.phases[phaseIndex];
+        const item = phase.checks.find(c => c.id === itemId);
+        if (!item) {
+            const available = phase.checks.map(c => c.id).join(', ');
+            console.error(`item "${itemId}" not found in phase "${phase.name}". available: ${available}`);
+            process.exit(1);
+        }
+        if (item.verify) {
+            console.error(`"${itemId}" has a verify rule — it is mechanical, not manual. run: checklist verify ${phaseArg}`);
+            process.exit(1);
+        }
+        (0, state_js_1.setItemResult)(state, phaseIndex, itemId, { status: 'pass', message: 'confirmed' });
+        (0, state_js_1.saveState)(cwd, state);
+        console.log((0, formatter_js_1.formatCheckConfirm)(phaseIndex, itemId));
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        process.exit(1);
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const loader_js_1 = require("../loader.js");
+const state_js_1 = require("../state.js");
+const formatter_js_1 = require("../formatter.js");
+const resolver_js_1 = require("../resolver.js");
+const STATE_FILE = '.checklist.state.json';
+function initCommand(dir, options) {
+    // init accepts the dir both positionally (`init <dir>`) and via the uniform
+    // --dir flag; reject a conflicting combination rather than silently using one.
+    if (dir && options?.dir && path.resolve(dir) !== path.resolve(options.dir)) {
+        console.error(`conflicting target dir: positional "${dir}" vs --dir "${options.dir}"`);
+        process.exit(1);
+    }
+    const targetDir = dir || (0, resolver_js_1.resolveDir)(options?.dir);
+    try {
+        const config = (0, loader_js_1.loadChecklist)(targetDir);
+        const stateExists = fs.existsSync(path.resolve(targetDir, STATE_FILE));
+        if (stateExists && !options?.force) {
+            console.error(`state file exists in ${targetDir}. use --force to clear and reinitialize`);
+            process.exit(1);
+        }
+        (0, state_js_1.clearState)(targetDir);
+        (0, resolver_js_1.writeActivePointer)(targetDir);
+        console.log((0, formatter_js_1.formatInit)(config, stateExists));
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        process.exit(1);
+    }
+}

package/dist/commands/phases.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.phasesCommand = phasesCommand;
+const loader_js_1 = require("../loader.js");
+const formatter_js_1 = require("../formatter.js");
+const resolver_js_1 = require("../resolver.js");
+function phasesCommand(options) {
+    const targetDir = (0, resolver_js_1.resolveDir)(options?.dir);
+    try {
+        const config = (0, loader_js_1.loadChecklist)(targetDir);
+        console.log((0, formatter_js_1.formatPhases)(config));
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        process.exit(1);
+    }
+}

package/dist/commands/reset.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetCommand = resetCommand;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const state_js_1 = require("../state.js");
+const resolver_js_1 = require("../resolver.js");
+const CONFIG_FILE = '.checklist.yml';
+// End-of-run cleanup. Symmetric with `init`: clears this skill's state file and
+// drops the global active pointer when it points here, so nothing is left
+// lingering after a checklist session completes.
+//
+// `reset` is destructive, so — unlike the read-only fall-through in resolveDir —
+// it must NOT act on a directory the user never named. Every other command is
+// implicitly guarded by loadChecklist (which throws on a missing .checklist.yml);
+// reset has no such call, so it guards explicitly here. Without this, a bare
+// `checklist reset`/`done` with no --dir/env/pointer would resolve to cwd and
+// delete an unrelated project's .checklist.state.json.
+function resetCommand(options) {
+    const targetDir = (0, resolver_js_1.resolveDir)(options?.dir);
+    if (!fs.existsSync(path.join(targetDir, CONFIG_FILE))) {
+        console.error(`no active checklist to reset in ${targetDir}. pass --dir <skill-dir>`);
+        process.exit(1);
+        return; // ensure the destructive ops below never run even if exit is stubbed
+    }
+    (0, state_js_1.clearState)(targetDir);
+    const pointerCleared = (0, resolver_js_1.clearActivePointer)(targetDir);
+    const pointerNote = pointerCleared ? ' and active pointer' : '';
+    console.log(`checklist reset: cleared state${pointerNote} for ${targetDir}`);
+}

package/dist/commands/show.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showCommand = showCommand;
+const loader_js_1 = require("../loader.js");
+const state_js_1 = require("../state.js");
+const resolver_js_1 = require("../resolver.js");
+const formatter_js_1 = require("../formatter.js");
+async function showCommand(phaseArg, options) {
+    const cwd = (0, resolver_js_1.resolveDir)(options?.dir);
+    const targetPath = options?.path || cwd;
+    try {
+        const config = (0, loader_js_1.loadChecklist)(cwd);
+        const state = (0, state_js_1.loadState)(cwd);
+        if (!phaseArg) {
+            console.log((0, formatter_js_1.formatOverview)(config, state));
+            return;
+        }
+        const phaseIndex = (0, resolver_js_1.findPhaseIndex)(config, phaseArg);
+        const gate = (0, resolver_js_1.gatePriorPhases)(config, phaseIndex, state);
+        if (!gate.passed) {
+            console.error((0, formatter_js_1.formatGateFailure)(gate.failedPhase, gate.failedPhaseIndex));
+            process.exit(1);
+        }
+        const result = await (0, resolver_js_1.runPhase)(config.phases[phaseIndex], phaseIndex, cwd, targetPath);
+        console.log((0, formatter_js_1.formatPhaseShow)(result, state, config.phases.length));
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        process.exit(1);
+    }
+}

package/dist/commands/verify.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyCommand = verifyCommand;
+const loader_js_1 = require("../loader.js");
+const state_js_1 = require("../state.js");
+const resolver_js_1 = require("../resolver.js");
+const formatter_js_1 = require("../formatter.js");
+async function verifyCommand(phaseArg, options) {
+    const cwd = (0, resolver_js_1.resolveDir)(options.dir);
+    const targetPath = options.path || cwd;
+    try {
+        const config = (0, loader_js_1.loadChecklist)(cwd);
+        const state = (0, state_js_1.loadState)(cwd);
+        const phaseIndex = (0, resolver_js_1.findPhaseIndex)(config, phaseArg);
+        const gate = (0, resolver_js_1.gatePriorPhases)(config, phaseIndex, state);
+        if (!gate.passed) {
+            console.error((0, formatter_js_1.formatGateFailure)(gate.failedPhase, gate.failedPhaseIndex));
+            process.exit(1);
+        }
+        const result = await (0, resolver_js_1.runPhase)(config.phases[phaseIndex], phaseIndex, cwd, targetPath);
+        for (const c of result.checks) {
+            if (c.kind === 'mechanical' && c.result) {
+                // Record the CURRENT result, pass or fail — so a check that was green on
+                // an earlier verify and has since regressed overwrites its stale pass and
+                // the gate (isItemChecked === 'pass') sees current reality, instead of a
+                // failing re-verify silently leaving the old pass (and the gate) standing.
+                (0, state_js_1.setItemResult)(state, phaseIndex, c.item.id, c.result);
+            }
+        }
+        (0, state_js_1.saveState)(cwd, state);
+        console.log((0, formatter_js_1.formatVerifyResult)(result, state, config.phases.length));
+        if (result.mechanicalPassed < result.mechanicalTotal) {
+            process.exit(1);
+        }
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        process.exit(1);
+    }
+}

package/dist/formatter.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatInit = formatInit;
+exports.formatOverview = formatOverview;
+exports.formatPhaseShow = formatPhaseShow;
+exports.formatVerifyResult = formatVerifyResult;
+exports.formatCheckConfirm = formatCheckConfirm;
+exports.formatGateFailure = formatGateFailure;
+exports.formatPhases = formatPhases;
+const state_js_1 = require("./state.js");
+function padDots(left, right, width = 50) {
+    const dotsCount = width - left.length - right.length;
+    if (dotsCount < 3)
+        return `${left} .. ${right}`;
+    return `${left} ${'.'.repeat(dotsCount)} ${right}`;
+}
+function formatInit(config, cleared) {
+    const total = config.phases.length;
+    const phaseList = config.phases
+        .map((p, i) => `  ${i}: ${p.name} (${p.checks.length} checks)`)
+        .join('\n');
+    const header = cleared
+        ? `checklist ready, ${total} phases (previous state cleared)`
+        : `checklist ready, ${total} phases`;
+    return `${header}\n${phaseList}`;
+}
+function formatOverview(config, state) {
+    let currentPhase = -1;
+    const lines = config.phases.map((phase, i) => {
+        const ids = phase.checks.map(c => c.id);
+        const complete = (0, state_js_1.isPhaseComplete)(state, i, ids);
+        const { done, total } = (0, state_js_1.phaseProgress)(state, i, ids);
+        let status;
+        if (complete) {
+            status = '[x] passed';
+        }
+        else if (done > 0) {
+            status = `[ ] ${done}/${total}`;
+            if (currentPhase === -1)
+                currentPhase = i;
+        }
+        else {
+            status = '[ ] pending';
+            if (currentPhase === -1)
+                currentPhase = i;
+        }
+        return `PHASE ${i}: ${phase.name.toUpperCase().padEnd(20)} ${status}`;
+    });
+    const allDone = config.phases.every((phase, i) => (0, state_js_1.isPhaseComplete)(state, i, phase.checks.map(c => c.id)));
+    if (allDone) {
+        lines.push('', 'all phases passed');
+    }
+    else {
+        lines.push('', `current phase: PHASE ${currentPhase}`);
+    }
+    return lines.join('\n');
+}
+function formatPhaseShow(result, state, totalPhases) {
+    const header = `PHASE ${result.phaseIndex}: ${result.phaseName.toUpperCase()}`;
+    const items = result.checks.map((c, i) => {
+        const checked = (0, state_js_1.isItemChecked)(state, result.phaseIndex, c.item.id);
+        const mark = checked ? '[x]' : '[ ]';
+        const num = `${i + 1}.`;
+        const line = `${num} ${mark} ${padDots(c.item.id, c.item.description)}`;
+        if (checked) {
+            return line;
+        }
+        if (c.kind === 'manual') {
+            return `${line}\n       -> [manual confirmation required]`;
+        }
+        if (c.result) {
+            const reading = c.result.status === 'error'
+                ? `[ERROR] ${c.result.message}`
+                : `[reading] ${c.result.message}`;
+            return `${line}\n       -> ${reading}`;
+        }
+        return line;
+    }).join('\n');
+    const ids = result.checks.map(c => c.item.id);
+    const { done, total } = (0, state_js_1.phaseProgress)(state, result.phaseIndex, ids);
+    const lines = [header, '', items, ''];
+    if (done === total) {
+        const isLast = totalPhases !== undefined && result.phaseIndex >= totalPhases - 1;
+        lines.push(isLast
+            ? `PHASE ${result.phaseIndex} passed — all phases complete, run \`checklist done\``
+            : `PHASE ${result.phaseIndex} passed, proceed to PHASE ${result.phaseIndex + 1}`);
+    }
+    else {
+        lines.push(`${done}/${total} completed`);
+    }
+    return lines.join('\n');
+}
+function formatVerifyResult(result, state, totalPhases) {
+    const header = `PHASE ${result.phaseIndex}: ${result.phaseName.toUpperCase()}`;
+    const items = result.checks.map((c, i) => {
+        const num = `${i + 1}.`;
+        if (c.kind === 'manual') {
+            const checked = (0, state_js_1.isItemChecked)(state, result.phaseIndex, c.item.id);
+            if (checked) {
+                return `${num} [x] ${padDots(c.item.id, 'confirmed')}`;
+            }
+            return `${num} [ ] ${padDots(c.item.id, c.item.description)}\n       -> run: checklist check ${result.phaseIndex} ${c.item.id}`;
+        }
+        const passed = c.result?.status === 'pass';
+        const mark = passed ? '[x]' : '[ ]';
+        const suffix = passed ? 'PASS' : `FAIL: ${c.result?.message || 'unknown'}`;
+        return `${num} ${mark} ${padDots(c.item.id, suffix)}`;
+    }).join('\n');
+    const lines = [header, '', items, ''];
+    if (result.mechanicalTotal > 0) {
+        lines.push(`mechanical: ${result.mechanicalPassed}/${result.mechanicalTotal} passed`);
+    }
+    if (result.manualCount > 0) {
+        const manualChecked = result.checks
+            .filter(c => c.kind === 'manual' && (0, state_js_1.isItemChecked)(state, result.phaseIndex, c.item.id))
+            .length;
+        const remaining = result.manualCount - manualChecked;
+        if (remaining > 0) {
+            lines.push(`manual: ${remaining} pending`);
+        }
+    }
+    // Explicit verdict so `verify` (the gate command) states pass/proceed itself,
+    // instead of requiring a follow-up `show`.
+    const ids = result.checks.map(c => c.item.id);
+    const { done, total } = (0, state_js_1.phaseProgress)(state, result.phaseIndex, ids);
+    // The verify verdict must reflect THIS run, not just stored progress: never
+    // announce "verified, proceed" when a mechanical check failed on this run,
+    // even if stored state still carries an earlier (now-stale) pass.
+    const mechanicalOk = result.mechanicalPassed === result.mechanicalTotal;
+    if (mechanicalOk && done === total) {
+        const isLast = totalPhases !== undefined && result.phaseIndex >= totalPhases - 1;
+        lines.push(isLast
+            ? `PHASE ${result.phaseIndex} verified — all phases complete, run \`checklist done\``
+            : `PHASE ${result.phaseIndex} verified, proceed to PHASE ${result.phaseIndex + 1}`);
+    }
+    return lines.join('\n');
+}
+function formatCheckConfirm(phaseIndex, itemId) {
+    return `[x] ${itemId} .. confirmed`;
+}
+function formatGateFailure(failedPhase, failedIndex) {
+    return `gate blocked: PHASE ${failedIndex} (${failedPhase}) incomplete`;
+}
+function formatPhases(config) {
+    return config.phases
+        .map((p, i) => `${i}: ${p.name} (${p.checks.length} checks)`)
+        .join('\n');
+}