@zhuan-ai/zhuanspec 2.15.7 → 2.16.2

package/dist/core/validation/strict-rules.d.ts

@@ -159,6 +159,34 @@ export declare function checkTaskIdFormat(tasksContent: string): StrictCheckResu
  * This ensures automated progress tracking (parseTasks, record-progress, review gate) works correctly.
  */
 export declare function checkTaskCheckboxFormat(tasksContent: string): StrictCheckResult;
+/**
+ * Rule: task-layer-tag (WARN level)
+ *
+ * Each task MUST carry an @layer:xxx annotation whose value is in VALID_LAYER_TAGS.
+ * Currently WARN-level rollout; will be upgraded to ERROR in a future release.
+ */
+export declare function checkTaskLayerTag(parsedTasks: ParsedTask[]): StrictCheckResult;
+/**
+ * Rule: task-layer-wave-consistency (WARN level)
+ *
+ * Wave 分层一致性：
+ *   Wave 1 仅允许 dao / assemble / ddl / config
+ *   Wave 2 仅允许 domain / application
+ *   Wave 3 仅允许 entry-* / fe
+ */
+export declare function checkTaskLayerWaveConsistency(parsedTasks: ParsedTask[]): StrictCheckResult;
+/**
+ * Rule: external-dependency-matrix-complete (WARN level)
+ *
+ * 校验 design.md 含 「外部依赖可用性矩阵」 或类似章节，且表格无 TBD / 空 / ⚠️ 未解。
+ */
+export declare function checkExternalDependencyMatrix(changeDir: string): StrictCheckResult;
+/**
+ * Rule: data-storage-strategy-required (WARN level)
+ *
+ * 当 tech-spec 含 CREATE TABLE / t_xxx 新增表关键词时，design.md 必须含「数据存储策略」章节且无 TBD。
+ */
+export declare function checkDataStorageStrategy(changeDir: string): StrictCheckResult;
 /**
  * Main entry: Run all strict validation rules
  */

package/dist/core/validation/strict-rules.js

@@ -33,6 +33,30 @@ const TABLE_DATA_ROW_PATTERN = /^\|(?![-:|\s]+\|$)[^\n]+\|/gm;
 const SKILL_TAG_PATTERN = /@skill:([^\s@]+)/g;
 // Wave header pattern
 const WAVE_HEADER_PATTERN = /^###\s+Wave\s+(\d+)/im;
+// @layer tag whitelist (WARN-level rollout; upgrade to ERROR in next release)
+const VALID_LAYER_TAGS = [
+    'dao', 'assemble', 'domain', 'application',
+    'entry-scf', 'entry-mq-producer', 'entry-mq-consumer', 'entry-job',
+    'fe', 'config', 'ddl',
+];
+// Wave-layer consistency: which @layer values are allowed in each wave
+const WAVE_ALLOWED_LAYERS = {
+    1: ['dao', 'assemble', 'ddl', 'config'],
+    2: ['domain', 'application'],
+    3: ['entry-scf', 'entry-mq-producer', 'entry-mq-consumer', 'entry-job', 'fe'],
+};
+// @layer:xxx extraction pattern
+const LAYER_TAG_PATTERN = /@layer:([a-z][a-z-]*)/i;
+const MIDDLEWARE_SKILL_RULES = [
+    { keyword: /\bzzmq\b|\bRocketMQ\b|@MessageConsumer|@MessageProducer|\bTopic\s*[:=\uff1a]/i, requiredSkill: 'java-middleware-usage-skill', description: 'ZZMQ / RocketMQ 消息中间件' },
+    { keyword: /\bxxl-?job\b|@XxlJob|@JobHandler/i, requiredSkill: 'java-middleware-usage-skill', description: 'XXL-Job 定时任务' },
+    { keyword: /\bRedisson\b|\bRedisTemplate\b|\bZZLock\b|@RedissonLock/i, requiredSkill: 'java-middleware-usage-skill', description: 'Redisson / ZZLock 分布式锁' },
+    { keyword: /@Cacheable\b|\bLettuce\b|\b缓存\b/i, requiredSkill: 'java-middleware-usage-skill', description: 'Redis 缓存' },
+    { keyword: /@ApolloJsonValue|\bApollo\s*(?:配置|config|配置中心)/i, requiredSkill: 'java-middleware-usage-skill', description: 'Apollo 配置中心' },
+    { keyword: /@ServiceContract|@SCFInterface|\bscf-client\b|\bSCF\s*(?:接口|服务|RPC)/i, requiredSkill: 'java-scf-rpc-usage-skill', description: 'SCF 远程调用' },
+    { keyword: /\bMapper\.xml\b|\bMyBatis\b|@MyBatis\b|\bselectBy[A-Z]\w*/i, requiredSkill: 'java-db-schema-standards', description: 'MyBatis DAO' },
+    { keyword: /\bElasticsearch\b|\bES\s*异构索引\b|\bES\s*索引\b/i, requiredSkill: 'es-integration', description: 'Elasticsearch / ES 异构索引' },
+];
 /**
  * Rule 0: test-case-inquiry-logged
  *
@@ -225,6 +249,20 @@ export function checkSkillTagsValid(tasksContent, parsedTasks, knownSkillNames)
                 result.errors.push(`任务 ${task.id}: @skill:${skill} 不是已知的 skill。可用 skills: ${availableSkills}`);
             }
         }
+        // f. Middleware keyword reverse lookup (WARN level)
+        //    If task description mentions middleware keywords (zzmq / @XxlJob / Redisson / Apollo / SCF / MyBatis),
+        //    then the corresponding skill MUST be declared in task.skills.
+        //    Skip rules whose requiredSkill is not registered in knownSkillNames, to avoid cascading
+        //    "unknown skill" errors when the user follows the WARN hint.
+        const taskSkillsLower = new Set(task.skills.map(s => s.toLowerCase()));
+        for (const rule of MIDDLEWARE_SKILL_RULES) {
+            if (knownSkillNames.length > 0 && !knownSkillSet.has(rule.requiredSkill.toLowerCase())) {
+                continue;
+            }
+            if (rule.keyword.test(task.description) && !taskSkillsLower.has(rule.requiredSkill.toLowerCase())) {
+                result.warnings.push(`任务 ${task.id}: 描述中出现中间件关键词（${rule.description}），但未引用 @skill:${rule.requiredSkill}`);
+            }
+        }
     }
     // Passed if no errors
     result.passed = result.errors.length === 0;
@@ -1339,6 +1377,245 @@ export function checkTaskCheckboxFormat(tasksContent) {
     result.passed = result.errors.length === 0;
     return result;
 }
+/**
+ * Rule: task-layer-tag (WARN level)
+ *
+ * Each task MUST carry an @layer:xxx annotation whose value is in VALID_LAYER_TAGS.
+ * Currently WARN-level rollout; will be upgraded to ERROR in a future release.
+ */
+export function checkTaskLayerTag(parsedTasks) {
+    const result = {
+        ruleId: 'task-layer-tag',
+        ruleName: '任务分层标签校验',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    if (parsedTasks.length === 0) {
+        result.passed = true;
+        return result;
+    }
+    const validLayerSet = new Set(VALID_LAYER_TAGS);
+    for (const task of parsedTasks) {
+        const match = task.description.match(LAYER_TAG_PATTERN);
+        if (!match) {
+            result.warnings.push(`任务 ${task.id}: 缺少 @layer 标签。白名单：${VALID_LAYER_TAGS.join(' / ')}`);
+            continue;
+        }
+        const layer = match[1].toLowerCase();
+        if (!validLayerSet.has(layer)) {
+            result.warnings.push(`任务 ${task.id}: @layer:${layer} 不在白名单内。可选值：${VALID_LAYER_TAGS.join(' / ')}`);
+        }
+    }
+    // WARN-level rule: always pass, surface issues via warnings only
+    result.passed = true;
+    return result;
+}
+/**
+ * Rule: task-layer-wave-consistency (WARN level)
+ *
+ * Wave 分层一致性：
+ *   Wave 1 仅允许 dao / assemble / ddl / config
+ *   Wave 2 仅允许 domain / application
+ *   Wave 3 仅允许 entry-* / fe
+ */
+export function checkTaskLayerWaveConsistency(parsedTasks) {
+    const result = {
+        ruleId: 'task-layer-wave-consistency',
+        ruleName: 'Wave 分层一致性',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    if (parsedTasks.length === 0) {
+        result.passed = true;
+        return result;
+    }
+    let executionPlan;
+    try {
+        executionPlan = generateExecutionPlan(parsedTasks);
+    }
+    catch {
+        result.passed = true;
+        return result;
+    }
+    if (executionPlan.hasCycle) {
+        result.passed = true;
+        return result;
+    }
+    for (const wave of executionPlan.waves) {
+        const allowed = WAVE_ALLOWED_LAYERS[wave.wave];
+        if (!allowed)
+            continue; // no rule for this wave
+        for (const task of wave.tasks) {
+            const match = task.description.match(LAYER_TAG_PATTERN);
+            if (!match)
+                continue; // missing @layer already warned by task-layer-tag
+            const layer = match[1].toLowerCase();
+            if (!allowed.includes(layer)) {
+                result.warnings.push(`任务 ${task.id}（Wave ${wave.wave}）@layer:${layer} 与 Wave 分层建议不一致。Wave ${wave.wave} 建议：${allowed.join(' / ')}`);
+            }
+        }
+    }
+    result.passed = true;
+    return result;
+}
+/**
+ * Rule: external-dependency-matrix-complete (WARN level)
+ *
+ * 校验 design.md 含 「外部依赖可用性矩阵」 或类似章节，且表格无 TBD / 空 / ⚠️ 未解。
+ */
+export function checkExternalDependencyMatrix(changeDir) {
+    const result = {
+        ruleId: 'external-dependency-matrix-complete',
+        ruleName: '外部依赖矩阵完整性',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    const designPath = join(changeDir, 'design.md');
+    if (!existsSync(designPath)) {
+        result.passed = true;
+        return result;
+    }
+    let designContent;
+    try {
+        designContent = readFileSync(designPath, 'utf-8');
+    }
+    catch {
+        result.passed = true;
+        return result;
+    }
+    const sectionRegex = /^##+\s+(?:外部依赖(?:可用性)?矩阵|External\s+Dependency\s+Matrix)[^\n]*$/im;
+    const sectionMatch = designContent.match(sectionRegex);
+    if (!sectionMatch) {
+        result.warnings.push('design.md 未找到「外部依赖可用性矩阵」章节——若本变更不涉及外部依赖可忽略；否则请按 6 列（依赖名称 / 类型 / 状态 / 版本环境 / 兜底阻塞策略 / 负责方）补齐');
+        result.passed = true;
+        return result;
+    }
+    const startIdx = sectionMatch.index + sectionMatch[0].length;
+    const rest = designContent.slice(startIdx);
+    const nextSectionMatch = rest.match(/^##+\s+/m);
+    const sectionBody = nextSectionMatch ? rest.slice(0, nextSectionMatch.index) : rest;
+    const tableRows = sectionBody.match(/^\|[^\n]+\|\s*$/gm) || [];
+    const dataRows = tableRows.filter(r => !/^\|[\s\-:|]+\|$/.test(r.trim()));
+    if (dataRows.length < 2) {
+        result.warnings.push('「外部依赖可用性矩阵」表格数据行 < 1，请至少填写一行或明确标注无外部依赖');
+    }
+    // Validate header has at least 6 columns
+    const headerRow = dataRows[0];
+    if (headerRow) {
+        const cols = headerRow.split('|').map(s => s.trim()).filter(s => s.length > 0);
+        if (cols.length < 6) {
+            result.warnings.push(`「外部依赖可用性矩阵」表头列数不足（当前 ${cols.length}，期望 6）：依赖名称 / 类型 / 状态 / 版本环境 / 兜底阻塞策略 / 负责方`);
+        }
+    }
+    // Scan data rows (skip header) for TBD / unresolved markers
+    for (let i = 1; i < dataRows.length; i++) {
+        const row = dataRows[i];
+        if (/\bTBD\b|\bTODO\b|\bPENDING\b|⚠️|待确认|待填/i.test(row)) {
+            result.warnings.push(`外部依赖矩阵第 ${i} 行含未解标记（TBD/TODO/⚠️）：${row.trim().substring(0, 80)}`);
+        }
+    }
+    result.passed = true;
+    return result;
+}
+/**
+ * Rule: data-storage-strategy-required (WARN level)
+ *
+ * 当 tech-spec 含 CREATE TABLE / t_xxx 新增表关键词时，design.md 必须含「数据存储策略」章节且无 TBD。
+ */
+export function checkDataStorageStrategy(changeDir) {
+    const result = {
+        ruleId: 'data-storage-strategy-required',
+        ruleName: '新增表数据存储策略',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    // 1. Scan tech-spec candidates to detect new-table keywords
+    const techSpecCandidates = [];
+    const techDesignDir = join(changeDir, 'techDesign');
+    if (existsSync(techDesignDir)) {
+        try {
+            for (const entry of readdirSync(techDesignDir)) {
+                if (entry.endsWith('.md'))
+                    techSpecCandidates.push(join(techDesignDir, entry));
+            }
+        }
+        catch { /* ignore */ }
+    }
+    try {
+        for (const entry of readdirSync(changeDir)) {
+            if (entry.endsWith('.md') && entry !== 'design.md' && entry !== 'tasks.md' && entry !== 'proposal.md') {
+                techSpecCandidates.push(join(changeDir, entry));
+            }
+        }
+    }
+    catch { /* ignore */ }
+    const NEW_TABLE_PATTERN = /CREATE\s+TABLE|\bt_[a-z][a-z0-9_]*\b|新增表|新建表/i;
+    let hasNewTable = false;
+    for (const p of techSpecCandidates) {
+        try {
+            const content = readFileSync(p, 'utf-8');
+            if (NEW_TABLE_PATTERN.test(content)) {
+                hasNewTable = true;
+                break;
+            }
+        }
+        catch { /* ignore */ }
+    }
+    if (!hasNewTable) {
+        result.passed = true;
+        return result;
+    }
+    // 2. Verify design.md has 「数据存储策略」 section
+    const designPath = join(changeDir, 'design.md');
+    if (!existsSync(designPath)) {
+        result.warnings.push('检测到新增表（CREATE TABLE / t_xxx），但 design.md 不存在，无法校验数据存储策略');
+        result.passed = true;
+        return result;
+    }
+    let designContent;
+    try {
+        designContent = readFileSync(designPath, 'utf-8');
+    }
+    catch {
+        result.passed = true;
+        return result;
+    }
+    const storageSectionRegex = /^##+\s+数据存储策略[^\n]*$/im;
+    const storageMatch = designContent.match(storageSectionRegex);
+    if (!storageMatch) {
+        result.warnings.push('检测到新增表关键词，但 design.md 缺少「## 数据存储策略」章节——请按 techDesign 步骤 6.5 补全（数量级 / 查询场景 / QPS / 时效性 / 推荐存储）');
+        result.passed = true;
+        return result;
+    }
+    const startIdx = storageMatch.index + storageMatch[0].length;
+    const rest = designContent.slice(startIdx);
+    const nextSectionMatch = rest.match(/^##+\s+/m);
+    const sectionBody = nextSectionMatch ? rest.slice(0, nextSectionMatch.index) : rest;
+    if (/\bTBD\b|\bTODO\b|\bPENDING\b|待确认|待填/i.test(sectionBody)) {
+        result.warnings.push('「数据存储策略」章节含未解标记（TBD / TODO / 待确认）');
+    }
+    const tableRows = sectionBody.match(/^\|[^\n]+\|\s*$/gm) || [];
+    const dataRows = tableRows.filter(r => !/^\|[\s\-:|]+\|$/.test(r.trim()));
+    if (dataRows.length < 2) {
+        result.warnings.push('「数据存储策略」表格数据行 < 1，请逐表填写（表名 / 数量级 / 查询场景 / QPS / 时效性 / 一致性 / 推荐存储 / 说明）');
+    }
+    // Column-count check: header row should carry 8 columns to include 一致性（含跨表事务）
+    //   表名 | 预估数量级 | 查询场景 | 读/写 QPS | 时效性 | 一致性（含跨表事务） | 存储策略 | 备注
+    // Keep WARN-level and backward-compatible: 7-column legacy tables only trigger a soft warn.
+    if (tableRows.length > 0) {
+        const headerRow = tableRows[0].trim();
+        const headerCols = headerRow.split('|').slice(1, -1).map(c => c.trim()).filter(c => c.length > 0);
+        if (headerCols.length > 0 && headerCols.length < 8) {
+            result.warnings.push(`「数据存储策略」表头只有 ${headerCols.length} 列，建议补齐到 8 列（增加 "一致性（含跨表事务）" 列，参见 techDesign 步骤 6.5）`);
+        }
+    }
+    result.passed = true;
+    return result;
+}
 /**
  * Main entry: Run all strict validation rules
  */
@@ -1367,6 +1644,8 @@ export async function runStrictValidation(tasksContent, parsedTasks, knownSkillN
         checkTestCaseCoverage(tasksContent, hasTestCase, testCasesContent),
         checkTaskIdFormat(tasksContent),
         checkTaskCheckboxFormat(tasksContent),
+        checkTaskLayerTag(parsedTasks),
+        checkTaskLayerWaveConsistency(parsedTasks),
     ];
     // Add new rules if parameters are provided
     if (options?.proposalContent) {
@@ -1400,6 +1679,11 @@ export async function runStrictValidation(tasksContent, parsedTasks, knownSkillN
             checks.push(checkTechSpecCoverage(options.changeDir, options.techSpecPath));
         }
     }
+    // design.md-based rules: only run if changeDir is provided
+    if (options?.changeDir) {
+        checks.push(checkExternalDependencyMatrix(options.changeDir));
+        checks.push(checkDataStorageStrategy(options.changeDir));
+    }
     // Detect current phase for spec-code consistency check
     if (options?.specsDir && options?.repoRoot) {
         const phase = options?.changeDir ? detectPhase(options.changeDir) : 'apply';

package/dist/utils/hook-merge.d.ts

@@ -10,6 +10,12 @@ export interface HookSyncSummary {
     totalAddedHooks: number;
     /** Number of hook groups skipped because an identical entry already existed. */
     duplicateHooksSkipped: number;
+    /**
+     * v2.15.16：被清理的 ZhuanSpec 管辖老 group 数量。
+     * 例如旧版本 settings.json 挂着 `deviation-check --trigger post-prompt`，
+     * Sprint 3 新模板不再挂同名条目，要在 merge 前先调手带掉。
+     */
+    stalehooksRemoved: number;
 }
 export interface HookSettings {
     hooks?: Record<string, unknown>;

package/dist/utils/hook-merge.js

@@ -5,6 +5,24 @@
  * Both hosts share the same `hooks.<Event>[].hooks[].type/command` schema, so
  * we can centralize the signature-based de-duplication logic here.
  */
+/**
+ * v2.15.16：判定一个 hook group 是否完全由 ZhuanSpec 管辖。
+ * 条件：group.hooks 里所有 entry 的 command 都以 `zhuanspec-hook` 开头。
+ * 任何一个非 ZhuanSpec 命令（用户自己挂的）都会让整组保留，避免误伤。
+ */
+function isZhuanspecManagedGroup(group) {
+    if (!group || typeof group !== 'object')
+        return false;
+    const hooks = group.hooks;
+    if (!Array.isArray(hooks) || hooks.length === 0)
+        return false;
+    return hooks.every((h) => {
+        if (!h || typeof h !== 'object')
+            return false;
+        const command = h.command;
+        return typeof command === 'string' && command.trim().startsWith('zhuanspec-hook');
+    });
+}
 /**
  * Merge ZhuanSpec-managed hook configuration into an existing settings object.
  *
@@ -15,6 +33,7 @@ export function mergeHookSettings(existing, zhuanspecConfig) {
     const summary = {
         totalAddedHooks: 0,
         duplicateHooksSkipped: 0,
+        stalehooksRemoved: 0,
     };
     if (!existing) {
         const zhuanspecHooks = (zhuanspecConfig.hooks ?? {});
@@ -31,7 +50,19 @@ export function mergeHookSettings(existing, zhuanspecConfig) {
             const existingValue = existingHooks[hookType];
             if (Array.isArray(existingValue)) {
                 const zhuanspecArray = zhuanspecHookConfig ?? [];
-                const existingSignatures = new Set(existingValue.map((item) => JSON.stringify(item)));
+                // v2.15.16：先剔除所有纯 ZhuanSpec 管辖的老 group，再 append 新模板。
+                // 这样新版本模板里删除的 entry（如 Sprint 3 下线的 deviation-check --trigger post-prompt）
+                // 不会因为老 settings.json 里残留而永久活下来；非 ZhuanSpec entry（用户自己加的）则全量保留。
+                const cleanedExisting = [];
+                for (const item of existingValue) {
+                    if (isZhuanspecManagedGroup(item)) {
+                        summary.stalehooksRemoved += 1;
+                    }
+                    else {
+                        cleanedExisting.push(item);
+                    }
+                }
+                const existingSignatures = new Set(cleanedExisting.map((item) => JSON.stringify(item)));
                 const uniqueToAppend = [];
                 for (const item of zhuanspecArray) {
                     const signature = JSON.stringify(item);
@@ -43,7 +74,7 @@ export function mergeHookSettings(existing, zhuanspecConfig) {
                     uniqueToAppend.push(item);
                 }
                 summary.totalAddedHooks += uniqueToAppend.length;
-                existingHooks[hookType] = [...existingValue, ...uniqueToAppend];
+                existingHooks[hookType] = [...cleanedExisting, ...uniqueToAppend];
             }
             else {
                 const zhuanspecArray = zhuanspecHookConfig;

package/dist/utils/phase-utils.js

@@ -79,6 +79,7 @@ export async function setPhase(changeDir, phase) {
                 phaseDurations: [{
                         phase,
                         startedAt: timestamp,
+                        lastUpdatedAt: timestamp,
                         durationMs: 0,
                         taskCount: 0,
                         completedTaskCount: 0,
@@ -114,6 +115,7 @@ export async function setPhase(changeDir, phase) {
             phaseDurations: [{
                     phase,
                     startedAt: timestamp,
+                    lastUpdatedAt: timestamp,
                     durationMs: 0,
                     taskCount: 0,
                     completedTaskCount: 0,
@@ -129,6 +131,7 @@ export async function setPhase(changeDir, phase) {
         progress.phaseDurations.push({
             phase,
             startedAt: timestamp,
+            lastUpdatedAt: timestamp,
             durationMs: 0,
             taskCount: 0,
             completedTaskCount: 0,
@@ -145,6 +148,7 @@ export async function setPhase(changeDir, phase) {
         const prevPhaseDuration = progress.phaseDurations.find(pd => pd.phase === previousPhase && !pd.endedAt);
         if (prevPhaseDuration) {
             prevPhaseDuration.endedAt = timestamp;
+            prevPhaseDuration.lastUpdatedAt = timestamp;
             const startTime = new Date(prevPhaseDuration.startedAt).getTime();
             const endTime = new Date(timestamp).getTime();
             prevPhaseDuration.durationMs = endTime > startTime ? endTime - startTime : 0;
@@ -153,6 +157,7 @@ export async function setPhase(changeDir, phase) {
         progress.phaseDurations.push({
             phase,
             startedAt: timestamp,
+            lastUpdatedAt: timestamp,
             durationMs: 0,
             taskCount: 0,
             completedTaskCount: 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhuan-ai/zhuanspec",
-  "version": "2.15.7",
+  "version": "2.16.2",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "zhuanspec",
@@ -39,6 +39,26 @@
     "!dist/**/__tests__",
     "!dist/**/*.map"
   ],
+  "scripts": {
+    "lint": "eslint src/",
+    "build": "node build.js",
+    "dev": "tsc --watch",
+    "dev:cli": "pnpm build && node bin/zhuanspec.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
+    "test:postinstall": "node scripts/postinstall.js",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/postinstall.js",
+    "check:pack-version": "node scripts/pack-version-check.mjs",
+    "diagnose:cursor": "node scripts/diagnose-cursor-commands.js",
+    "release": "pnpm run release:ci",
+    "release:ci": "pnpm run check:pack-version && pnpm exec changeset publish",
+    "release:local": "pnpm exec changeset version && pnpm run check:pack-version && pnpm exec changeset publish",
+    "changeset": "changeset"
+  },
   "engines": {
     "node": ">=20.19.0"
   },
@@ -60,23 +80,5 @@
     "ora": "^8.2.0",
     "yaml": "^2.8.2",
     "zod": "^4.0.17"
-  },
-  "scripts": {
-    "lint": "eslint src/",
-    "build": "node build.js",
-    "dev": "tsc --watch",
-    "dev:cli": "pnpm build && node bin/zhuanspec.js",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:ui": "vitest --ui",
-    "test:coverage": "vitest --coverage",
-    "test:postinstall": "node scripts/postinstall.js",
-    "postinstall": "node scripts/postinstall.js",
-    "check:pack-version": "node scripts/pack-version-check.mjs",
-    "diagnose:cursor": "node scripts/diagnose-cursor-commands.js",
-    "release": "pnpm run release:ci",
-    "release:ci": "pnpm run check:pack-version && pnpm exec changeset publish",
-    "release:local": "pnpm exec changeset version && pnpm run check:pack-version && pnpm exec changeset publish",
-    "changeset": "changeset"
   }
-}
+}