@zhuan-ai/zhuanspec 2.2.0 → 2.2.1

package/dist/cli/index.js

@@ -189,6 +189,7 @@ program
     .option('-y, --yes', 'Skip confirmation prompts')
     .option('--skip-specs', 'Skip spec update operations (useful for infrastructure, tooling, or doc-only changes)')
     .option('--no-validate', 'Skip validation (not recommended, requires confirmation)')
+    .option('--business-direction <direction>', 'Business direction used for template refresh and remote sync (e.g., oms)')
     .action(async (changeName, options) => {
     try {
         const archiveCommand = new ArchiveCommand();
@@ -206,6 +207,7 @@ program
     .option('-y, --yes', 'Skip confirmation prompts and archive all active changes')
     .option('--skip-specs', 'Skip spec update operations')
     .option('--no-validate', 'Skip validation (not recommended)')
+    .option('--business-direction <direction>', 'Business direction used for template refresh and remote sync (e.g., oms)')
     .action(async (options) => {
     try {
         const archiveCommand = new ArchiveCommand();

package/dist/core/archive.d.ts

@@ -1,10 +1,12 @@
+type ArchiveOptions = {
+    yes?: boolean;
+    skipSpecs?: boolean;
+    noValidate?: boolean;
+    validate?: boolean;
+    businessDirection?: string;
+};
 export declare class ArchiveCommand {
-    execute(changeName?: string, options?: {
-        yes?: boolean;
-        skipSpecs?: boolean;
-        noValidate?: boolean;
-        validate?: boolean;
-    }): Promise<void>;
+    execute(changeName?: string, options?: ArchiveOptions): Promise<void>;
     /**
      * Move a directory, falling back to copy+remove when rename fails
      * (e.g., across devices, network drives, or permission issues).
@@ -20,11 +22,19 @@ export declare class ArchiveCommand {
      * Bulk archive multiple completed changes at once.
      * Lists all active changes, lets user select multiple, then archives them sequentially.
      */
-    bulkArchive(options?: {
-        yes?: boolean;
-        skipSpecs?: boolean;
-        noValidate?: boolean;
-        validate?: boolean;
-    }): Promise<void>;
+    bulkArchive(options?: ArchiveOptions): Promise<void>;
+    private resolveBusinessDirection;
+    private refreshBusinessTemplateFromRemote;
+    private pushArchiveResultToRemote;
+    private cloneRemoteRepoToTemp;
+    private git;
+    private hasGitChanges;
+    private copyDirectoryContentsIfExists;
+    private mirrorDirectory;
+    private findFirstDirectoryByName;
+    private resolveBusinessTemplateRoot;
+    private resolveRemoteBusinessRoot;
+    private toErrorMessage;
 }
+export {};
 //# sourceMappingURL=archive.d.ts.map

package/dist/core/archive.js

@@ -1,15 +1,21 @@
-import { promises as fs } from 'fs';
+import { promises as fs, existsSync, readdirSync } from 'fs';
 import path from 'path';
+import os from 'os';
+import { mkdtempSync, rmSync } from 'fs';
+import { execSync } from 'child_process';
 import { getTaskProgressForChange, formatTaskStatus } from '../utils/task-progress.js';
 import { Validator } from './validation/validator.js';
 import chalk from 'chalk';
 import { findSpecUpdates, buildUpdatedSpec, writeUpdatedSpec, } from './specs-apply.js';
+const ARCH_REPO_URL = 'http://gitlab.zhuanspirit.com/zz-kf/spec_repo.git';
+const ARCH_REPO_BRANCH = 'spec_repo-feature-6612-2';
 export class ArchiveCommand {
     async execute(changeName, options = {}) {
         const targetPath = '.';
         const changesDir = path.join(targetPath, 'zhuanspec', 'changes');
         const archiveDir = path.join(changesDir, 'archive');
         const mainSpecsDir = path.join(targetPath, 'zhuanspec', 'specs');
+        const zhuanspecDir = path.join(targetPath, 'zhuanspec');
         // Check if changes directory exists
         try {
             await fs.access(changesDir);
@@ -17,6 +23,11 @@ export class ArchiveCommand {
         catch {
             throw new Error("未找到 ZhuanSpec 变更目录。请先运行 'zhuanspec init'。");
         }
+        const businessDirection = await this.resolveBusinessDirection(zhuanspecDir, options.businessDirection);
+        if (!businessDirection) {
+            throw new Error('未解析到业务方向，无法执行归档前拉取与归档后回推。请使用 --business-direction 或在 zhuanspec/.business-direction、zhuanspec/project.md 中配置。');
+        }
+        await this.refreshBusinessTemplateFromRemote(zhuanspecDir, businessDirection);
         // Get change name interactively if not provided
         if (!changeName) {
             const selectedChange = await this.selectChange(changesDir);
@@ -214,20 +225,27 @@ export class ArchiveCommand {
         const archiveName = `${this.getArchiveDate()}-${changeName}`;
         const archivePath = path.join(archiveDir, archiveName);
         // Check if archive already exists
+        let archiveExists = false;
         try {
             await fs.access(archivePath);
-            throw new Error(`归档 '${archiveName}' 已存在。`);
+            archiveExists = true;
         }
         catch (error) {
             if (error.code !== 'ENOENT') {
                 throw error;
             }
         }
-        // Create archive directory if needed
-        await fs.mkdir(archiveDir, { recursive: true });
-        // Move change to archive (with cross-device fallback)
-        await this.moveDirectory(changeDir, archivePath);
-        console.log(`变更 '${changeName}' 已归档为 '${archiveName}'。`);
+        if (archiveExists) {
+            console.log(chalk.yellow(`归档 '${archiveName}' 已存在，跳过归档移动。`));
+        }
+        else {
+            // Create archive directory if needed
+            await fs.mkdir(archiveDir, { recursive: true });
+            // Move change to archive (with cross-device fallback)
+            await this.moveDirectory(changeDir, archivePath);
+            console.log(`变更 '${changeName}' 已归档为 '${archiveName}'。`);
+        }
+        await this.pushArchiveResultToRemote(zhuanspecDir, businessDirection);
     }
     /**
      * Move a directory, falling back to copy+remove when rename fails
@@ -434,5 +452,221 @@ export class ArchiveCommand {
         console.log(chalk.cyan(`\n━━━ 批量归档完成 ━━━`));
         console.log(`成功: ${successCount}, 失败: ${failCount}, 总计: ${selectedChanges.length}`);
     }
+    async resolveBusinessDirection(zhuanspecDir, explicitDirection) {
+        if (explicitDirection && explicitDirection.trim()) {
+            return explicitDirection.trim().toLowerCase();
+        }
+        const directionFilePath = path.join(zhuanspecDir, '.business-direction');
+        try {
+            const fromFile = (await fs.readFile(directionFilePath, 'utf-8')).trim();
+            if (fromFile) {
+                return fromFile.toLowerCase();
+            }
+        }
+        catch {
+            // Continue to project.md fallback.
+        }
+        const projectPath = path.join(zhuanspecDir, 'project.md');
+        try {
+            const content = await fs.readFile(projectPath, 'utf-8');
+            const patterns = [
+                /业务方向\s*[:：]\s*([A-Za-z0-9_-]+)/i,
+                /business\s*direction\s*[:：]\s*([A-Za-z0-9_-]+)/i,
+            ];
+            for (const pattern of patterns) {
+                const match = content.match(pattern);
+                if (match?.[1]) {
+                    return match[1].trim().toLowerCase();
+                }
+            }
+        }
+        catch {
+            // Ignore parsing errors and fall back to null.
+        }
+        return null;
+    }
+    async refreshBusinessTemplateFromRemote(zhuanspecDir, businessDirection) {
+        const tempRepo = this.cloneRemoteRepoToTemp();
+        try {
+            const remoteBusiness = this.resolveRemoteBusinessRoot(tempRepo, businessDirection);
+            if (!remoteBusiness) {
+                throw new Error(`未在远端 specs 目录中找到业务方向 '${businessDirection}'，归档已中止。`);
+            }
+            const { businessRoot } = remoteBusiness;
+            const templateRoot = this.resolveBusinessTemplateRoot(businessRoot);
+            if (!templateRoot) {
+                throw new Error(`未在业务方向 '${businessDirection}' 目录下递归找到可用的 zhuanspec 目录，归档已中止。`);
+            }
+            await this.copyDirectoryContentsIfExists(path.join(templateRoot, 'specs'), path.join(zhuanspecDir, 'specs'));
+            await this.copyDirectoryContentsIfExists(path.join(templateRoot, 'changes'), path.join(zhuanspecDir, 'changes'));
+            console.log(chalk.gray(`已拉取 ${businessDirection} 业务模板（specs/changes）。`));
+        }
+        finally {
+            rmSync(tempRepo, { recursive: true, force: true });
+        }
+    }
+    async pushArchiveResultToRemote(zhuanspecDir, businessDirection) {
+        const tempRepo = this.cloneRemoteRepoToTemp();
+        try {
+            const remoteBusiness = this.resolveRemoteBusinessRoot(tempRepo, businessDirection);
+            if (!remoteBusiness) {
+                throw new Error(`未在远端 specs 目录中找到业务方向 '${businessDirection}'，归档结果回推已中止。`);
+            }
+            const { businessRoot } = remoteBusiness;
+            const templateRoot = this.resolveBusinessTemplateRoot(businessRoot);
+            if (!templateRoot) {
+                throw new Error(`未在业务方向 '${businessDirection}' 目录下递归找到可用的 zhuanspec 目录，归档结果回推已中止。`);
+            }
+            const remoteBase = templateRoot;
+            const remoteSpecsPath = path.join(remoteBase, 'specs');
+            const remoteArchivePath = path.join(remoteBase, 'changes', 'archive');
+            const localSpecsPath = path.join(zhuanspecDir, 'specs');
+            const localArchivePath = path.join(zhuanspecDir, 'changes', 'archive');
+            await this.mirrorDirectory(localSpecsPath, remoteSpecsPath);
+            await this.mirrorDirectory(localArchivePath, remoteArchivePath);
+            const changed = this.hasGitChanges(tempRepo);
+            if (!changed) {
+                console.log(chalk.gray('远端模板仓库无变更，跳过 push。'));
+                return;
+            }
+            this.git(tempRepo, 'git add .');
+            const commitMsg = `chore: sync archive outputs for ${businessDirection}`;
+            this.git(tempRepo, `git commit -m "${commitMsg}"`);
+            this.git(tempRepo, `git push origin ${ARCH_REPO_BRANCH}`);
+            console.log(chalk.green(`已推送归档结果到远端 ${ARCH_REPO_BRANCH}（${businessDirection}）。`));
+        }
+        finally {
+            rmSync(tempRepo, { recursive: true, force: true });
+        }
+    }
+    cloneRemoteRepoToTemp() {
+        const tempDir = mkdtempSync(path.join(os.tmpdir(), 'zhuanspec-archive-'));
+        try {
+            this.git(process.cwd(), `git clone --depth 1 --single-branch --branch ${ARCH_REPO_BRANCH} ${ARCH_REPO_URL} "${tempDir}"`);
+            return tempDir;
+        }
+        catch (error) {
+            rmSync(tempDir, { recursive: true, force: true });
+            throw new Error(`拉取远端模板仓库失败：${this.toErrorMessage(error)}`);
+        }
+    }
+    git(cwd, command) {
+        return execSync(command, {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    hasGitChanges(repoDir) {
+        try {
+            const output = this.git(repoDir, 'git status --porcelain');
+            return output.trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    async copyDirectoryContentsIfExists(sourceDir, targetDir) {
+        try {
+            const stat = await fs.stat(sourceDir);
+            if (!stat.isDirectory()) {
+                return false;
+            }
+        }
+        catch {
+            return false;
+        }
+        await fs.mkdir(targetDir, { recursive: true });
+        const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const src = path.join(sourceDir, entry.name);
+            const dest = path.join(targetDir, entry.name);
+            if (entry.isDirectory()) {
+                await this.copyDirectoryRecursive(src, dest);
+            }
+            else {
+                await fs.copyFile(src, dest);
+            }
+        }
+        return true;
+    }
+    async mirrorDirectory(sourceDir, targetDir) {
+        const sourceStat = await fs.stat(sourceDir);
+        if (!sourceStat.isDirectory()) {
+            throw new Error(`源目录不是目录：${sourceDir}`);
+        }
+        await fs.rm(targetDir, { recursive: true, force: true });
+        await fs.mkdir(path.dirname(targetDir), { recursive: true });
+        await fs.cp(sourceDir, targetDir, { recursive: true, force: true });
+    }
+    findFirstDirectoryByName(searchRoot, targetName) {
+        if (!existsSync(searchRoot)) {
+            return null;
+        }
+        const queue = [searchRoot];
+        const targetLower = targetName.toLowerCase();
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current) {
+                continue;
+            }
+            try {
+                const children = readdirSync(current, { withFileTypes: true })
+                    .filter((entry) => entry.isDirectory())
+                    .map((entry) => entry.name)
+                    .sort((a, b) => a.localeCompare(b));
+                for (const child of children) {
+                    const childPath = path.join(current, child);
+                    if (child.toLowerCase() === targetLower) {
+                        return childPath;
+                    }
+                    queue.push(childPath);
+                }
+            }
+            catch {
+                // Continue searching.
+            }
+        }
+        return null;
+    }
+    resolveBusinessTemplateRoot(businessRoot) {
+        if (!existsSync(businessRoot)) {
+            return null;
+        }
+        // Business directory selection is recursive (first match).
+        // Once selected, template root must be its direct child: <business>/zhuanspec.
+        const zhuanspecRoot = path.join(businessRoot, 'zhuanspec');
+        if (!existsSync(zhuanspecRoot)) {
+            return null;
+        }
+        const specsDir = path.join(zhuanspecRoot, 'specs');
+        const changesDir = path.join(zhuanspecRoot, 'changes');
+        if (!existsSync(specsDir) || !existsSync(changesDir)) {
+            return null;
+        }
+        return zhuanspecRoot;
+    }
+    resolveRemoteBusinessRoot(tempRepo, businessDirection) {
+        const candidates = Array.from(new Set([
+            path.join(tempRepo, 'spec_repo', 'specs'),
+            path.join(tempRepo, 'specs'),
+        ]));
+        for (const specsRoot of candidates) {
+            if (!existsSync(specsRoot)) {
+                continue;
+            }
+            const businessRoot = this.findFirstDirectoryByName(specsRoot, businessDirection);
+            if (businessRoot) {
+                return { specsRoot, businessRoot };
+            }
+        }
+        return null;
+    }
+    toErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        return String(error);
+    }
 }
 //# sourceMappingURL=archive.js.map

package/dist/core/init.d.ts

@@ -48,6 +48,11 @@ export declare class InitCommand {
     private fetchArchitectureFile;
     private fetchRemoteArchitectureFiles;
     private fetchRemoteArchitectureContent;
+    private cloneRemoteArchitectureRepoToTemp;
+    private syncBusinessSpecTemplate;
+    private findFirstDirectoryByName;
+    private findFirstTemplateSourceRoot;
+    private copyDirectoryContentsIfExists;
     private writeTemplateFiles;
     private configureAITools;
     private configureRootAgentsStub;

package/dist/core/init.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import os from 'os';
-import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync } from 'fs';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, } from 'fs';
 import { createPrompt, isBackspaceKey, isDownKey, isEnterKey, isSpaceKey, isUpKey, useKeypress, usePagination, useState, } from '@inquirer/core';
 import chalk from 'chalk';
 import ora from 'ora';
@@ -297,6 +297,8 @@ export class InitCommand {
         // Step 3: Select business direction and apply architecture file
         await this.promptForBusinessDirection();
         if (this.businessDirection) {
+            const directionMetaPath = path.join(zhuanspecPath, '.business-direction');
+            await FileSystemUtils.writeFile(directionMetaPath, `${this.businessDirection.toLowerCase()}\n`);
             const archSpinner = this.startSpinner(`正在获取 ${this.businessDirection} 业务架构文档...`);
             const architectureContent = await this.fetchArchitectureFile();
             if (architectureContent) {
@@ -316,6 +318,27 @@ export class InitCommand {
                     text: PALETTE.midGray(`未找到 ${this.businessDirection} 业务架构文档，使用默认模板`),
                 });
             }
+            const specTemplateSpinner = this.startSpinner(`正在同步 ${this.businessDirection} 业务规范模板...`);
+            const syncResult = this.syncBusinessSpecTemplate(zhuanspecPath);
+            if (syncResult.syncedSpecs || syncResult.syncedChanges) {
+                const syncedParts = [];
+                if (syncResult.syncedSpecs) {
+                    syncedParts.push('specs');
+                }
+                if (syncResult.syncedChanges) {
+                    syncedParts.push('changes');
+                }
+                specTemplateSpinner.stopAndPersist({
+                    symbol: PALETTE.white('▌'),
+                    text: PALETTE.white(`已从远端模板同步 ${syncedParts.join('、')} 目录`),
+                });
+            }
+            else {
+                specTemplateSpinner.stopAndPersist({
+                    symbol: PALETTE.midGray('▌'),
+                    text: PALETTE.midGray(`未找到 ${this.businessDirection} 业务规范模板目录，保留默认模板`),
+                });
+            }
         }
         // Success message
         this.displaySuccessMessage(selectedTools, created, refreshed, skippedExisting, skipped, extendMode, rootStubStatus);
@@ -679,9 +702,11 @@ export class InitCommand {
         return null;
     }
     fetchRemoteArchitectureFiles() {
-        const tempDir = mkdtempSync(path.join(os.tmpdir(), 'zhuanspec-arch-'));
+        const tempDir = this.cloneRemoteArchitectureRepoToTemp();
+        if (!tempDir) {
+            return [];
+        }
         try {
-            execSync(`git clone --depth 1 --single-branch --branch ${ARCH_REPO_BRANCH} ${ARCH_REPO_URL} "${tempDir}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] });
             const commonDir = path.join(tempDir, 'specs', 'common');
             if (!existsSync(commonDir)) {
                 return [];
@@ -696,9 +721,11 @@ export class InitCommand {
         }
     }
     fetchRemoteArchitectureContent(fileName) {
-        const tempDir = mkdtempSync(path.join(os.tmpdir(), 'zhuanspec-arch-'));
+        const tempDir = this.cloneRemoteArchitectureRepoToTemp();
+        if (!tempDir) {
+            return null;
+        }
         try {
-            execSync(`git clone --depth 1 --single-branch --branch ${ARCH_REPO_BRANCH} ${ARCH_REPO_URL} "${tempDir}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] });
             const fullPath = path.join(tempDir, 'specs', 'common', fileName);
             if (!existsSync(fullPath)) {
                 return null;
@@ -712,6 +739,117 @@ export class InitCommand {
             rmSync(tempDir, { recursive: true, force: true });
         }
     }
+    cloneRemoteArchitectureRepoToTemp() {
+        const tempDir = mkdtempSync(path.join(os.tmpdir(), 'zhuanspec-arch-'));
+        try {
+            execSync(`git clone --depth 1 --single-branch --branch ${ARCH_REPO_BRANCH} ${ARCH_REPO_URL} "${tempDir}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] });
+            return tempDir;
+        }
+        catch {
+            rmSync(tempDir, { recursive: true, force: true });
+            return null;
+        }
+    }
+    syncBusinessSpecTemplate(zhuanspecPath) {
+        if (!this.businessDirection) {
+            return { syncedSpecs: false, syncedChanges: false };
+        }
+        const tempDir = this.cloneRemoteArchitectureRepoToTemp();
+        if (!tempDir) {
+            return { syncedSpecs: false, syncedChanges: false };
+        }
+        try {
+            const specsRoot = path.join(tempDir, 'specs');
+            const businessRoot = this.findFirstDirectoryByName(specsRoot, this.businessDirection);
+            if (!businessRoot) {
+                return { syncedSpecs: false, syncedChanges: false };
+            }
+            const templateRoot = this.findFirstTemplateSourceRoot(businessRoot);
+            if (!templateRoot) {
+                return { syncedSpecs: false, syncedChanges: false };
+            }
+            const syncedSpecs = this.copyDirectoryContentsIfExists(path.join(templateRoot, 'specs'), path.join(zhuanspecPath, 'specs'));
+            const syncedChanges = this.copyDirectoryContentsIfExists(path.join(templateRoot, 'changes'), path.join(zhuanspecPath, 'changes'));
+            return { syncedSpecs, syncedChanges };
+        }
+        catch {
+            return { syncedSpecs: false, syncedChanges: false };
+        }
+        finally {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+    }
+    findFirstDirectoryByName(searchRoot, targetName) {
+        if (!existsSync(searchRoot)) {
+            return null;
+        }
+        const queue = [searchRoot];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current) {
+                continue;
+            }
+            try {
+                const children = readdirSync(current, { withFileTypes: true })
+                    .filter((entry) => entry.isDirectory())
+                    .map((entry) => entry.name)
+                    .sort((a, b) => a.localeCompare(b));
+                for (const child of children) {
+                    const childPath = path.join(current, child);
+                    if (child === targetName) {
+                        return childPath;
+                    }
+                    queue.push(childPath);
+                }
+            }
+            catch {
+                // Continue searching other branches when a directory cannot be read.
+            }
+        }
+        return null;
+    }
+    findFirstTemplateSourceRoot(searchRoot) {
+        if (!existsSync(searchRoot)) {
+            return null;
+        }
+        const queue = [searchRoot];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current) {
+                continue;
+            }
+            const specsDir = path.join(current, 'specs');
+            const changesDir = path.join(current, 'changes');
+            if (existsSync(specsDir) && existsSync(changesDir)) {
+                return current;
+            }
+            try {
+                const children = readdirSync(current, { withFileTypes: true })
+                    .filter((entry) => entry.isDirectory())
+                    .map((entry) => entry.name)
+                    .sort((a, b) => a.localeCompare(b));
+                children.forEach((child) => queue.push(path.join(current, child)));
+            }
+            catch {
+                // Continue searching other branches when a directory cannot be read.
+            }
+        }
+        return null;
+    }
+    copyDirectoryContentsIfExists(sourceDir, targetDir) {
+        if (!existsSync(sourceDir)) {
+            return false;
+        }
+        mkdirSync(targetDir, { recursive: true });
+        const entries = readdirSync(sourceDir);
+        for (const entry of entries) {
+            cpSync(path.join(sourceDir, entry), path.join(targetDir, entry), {
+                recursive: true,
+                force: true,
+            });
+        }
+        return true;
+    }
     async writeTemplateFiles(zhuanspecPath, config, skipExisting) {
         const context = {};
         const templates = TemplateManager.getTemplates(context);

package/dist/core/specs-apply.js

@@ -141,14 +141,19 @@ export async function buildUpdatedSpec(update, changeName) {
         targetContent = await fs.readFile(update.target, 'utf-8');
     }
     catch {
-        // Target spec does not exist; MODIFIED and RENAMED are not allowed for new specs
-        // REMOVED will be ignored with a warning since there's nothing to remove
-        if (plan.modified.length > 0 || plan.renamed.length > 0) {
-            throw new Error(`${specName}: target spec does not exist; only ADDED requirements are allowed for new specs. MODIFIED and RENAMED operations require an existing spec.`);
+        // Target spec does not exist: process as new spec creation.
+        // Only ADDED operations are applied; other operations are ignored.
+        if (plan.modified.length > 0) {
+            console.log(chalk.yellow(`⚠️  Warning: ${specName} - ${plan.modified.length} MODIFIED requirement(s) ignored for new spec (only ADDED is applied).`));
+            plan.modified.length = 0;
+        }
+        if (plan.renamed.length > 0) {
+            console.log(chalk.yellow(`⚠️  Warning: ${specName} - ${plan.renamed.length} RENAMED operation(s) ignored for new spec (only ADDED is applied).`));
+            plan.renamed.length = 0;
         }
-        // Warn about REMOVED requirements being ignored for new specs
         if (plan.removed.length > 0) {
             console.log(chalk.yellow(`⚠️  Warning: ${specName} - ${plan.removed.length} REMOVED requirement(s) ignored for new spec (nothing to remove).`));
+            plan.removed.length = 0;
         }
         isNewSpec = true;
         targetContent = buildSpecSkeleton(specName, changeName);
@@ -160,6 +165,7 @@ export async function buildUpdatedSpec(update, changeName) {
         nameToBlock.set(normalizeRequirementName(block.name), block);
     }
     // Apply operations in order: RENAMED → REMOVED → MODIFIED → ADDED
+    let skippedAdded = 0;
     // RENAMED
     for (const r of plan.renamed) {
         const from = normalizeRequirementName(r.from);
@@ -200,7 +206,10 @@ export async function buildUpdatedSpec(update, changeName) {
     for (const mod of plan.modified) {
         const key = normalizeRequirementName(mod.name);
         if (!nameToBlock.has(key)) {
-            throw new Error(`${specName} MODIFIED failed for header "### Requirement: ${mod.name}" - not found`);
+            // Lenient mode: if MODIFIED target is missing, treat it as ADDED.
+            console.log(chalk.yellow(`⚠️  Warning: ${specName} MODIFIED target not found for "### Requirement: ${mod.name}", auto-applying as ADDED.`));
+            nameToBlock.set(key, mod);
+            continue;
         }
         // Replace block with provided raw (ensure header line matches key)
         const modHeaderMatch = mod.raw.split('\n')[0].match(/^###\s*Requirement:\s*(.+)\s*$/);
@@ -213,7 +222,9 @@ export async function buildUpdatedSpec(update, changeName) {
     for (const add of plan.added) {
         const key = normalizeRequirementName(add.name);
         if (nameToBlock.has(key)) {
-            throw new Error(`${specName} ADDED failed for header "### Requirement: ${add.name}" - already exists`);
+            console.log(chalk.yellow(`⚠️  Warning: ${specName} ADDED target already exists for "### Requirement: ${add.name}", skipping.`));
+            skippedAdded++;
+            continue;
         }
         nameToBlock.set(key, add);
     }
@@ -247,7 +258,7 @@ export async function buildUpdatedSpec(update, changeName) {
     return {
         rebuilt,
         counts: {
-            added: plan.added.length,
+            added: plan.added.length - skippedAdded,
             modified: plan.modified.length,
             removed: plan.removed.length,
             renamed: plan.renamed.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhuan-ai/zhuanspec",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "zhuanspec",