specline 1.0.0 → 1.1.0

package/README.md

@@ -2,7 +2,7 @@
 
 面向 Cursor IDE 的 **Spec 驱动 AI 编码流水线**，内置确定性质量门禁。
 
-一句话需求 → 自动走完 编写规格 → 编码 → 审查 → 测试 → 归档 全流程：
+自然语言需求 → 自动走完 编写规格 → 编码 → 审查 → 测试 → 归档 全流程：
 
 ```
 /specline-pipeline "实现用户登录功能"
@@ -13,9 +13,9 @@
 ```
 自然语言需求 → Spec → 审核 → 编码 → 审查 → 测试 → 归档
                 ↑       ↑      ↑      ↑      ↑      ↑
-           spec-    spec-  前后端  code-  单元/   ✓ 完成
-          creator  reviewer  并行  reviewer  集成/
-                                          E2E
+           spec-    spec-  前后端/  code/ 单元/   ✓ 完成
+          creator  reviewer config config  集成/
+                  并行              reviewer  E2E
 ```
 
 每个阶段都经过 **确定性门禁校验** —— 用 `grep`、`jq`、编译器退出码、测试退出码判断通过与否。**质量判断零 LLM 参与**。
@@ -23,11 +23,12 @@
 ## 核心特性
 
 - **需求驱动**：自然语言 → 结构化规格文档（Requirements + Scenarios + WHEN/THEN）
-- **并行编码**：自动按前端/后端拆分任务，同批次并发派发 Coding Agent
+- **并行编码**：自动按前端/后端/config 拆分任务，同批次并发派发 Coding Agent
 - **确定性门禁**：每个阶段用 Shell 脚本的退出码判定是否通过，不做模糊判断
 - **黑盒测试**：测试 Agent 只看 Spec 文档，不能读取任何实现源码
 - **断点续跑**：随时中断，下次从最后一个可信门禁自动恢复（tasks.md 的 `[x]`/`[ ]` 标记进度）
 - **人机协作**：3 个人工检查点——Spec 确认、Review 可选复核、归档确认
+- **Hook 约束体系**：sessionStart 注入 pipeline 上下文 → preToolUse 违规拦截 → postToolUse 操作后提醒，确保长对话中 Agent 不偏离流水线逻辑
 - **安全 Hook**：自动拦截危险 Shell 命令（如 `rm -rf`、`curl|bash`）+ 代码变更后自动格式化
 - **零外部依赖**：不依赖 OpenSpec CLI，全部功能自包含
 
@@ -43,6 +44,13 @@ specline init
 
 # 或者用 npx（无需安装）
 npx specline init
+
+# 检查 CLI 更新
+specline update
+
+# 同步项目模板文件到最新版本
+specline sync
+specline sync --dry-run    # 预览变更
 ```
 
 初始化后项目会获得完整的流水线基础设施：
@@ -50,10 +58,10 @@ npx specline init
 ```
 my-project/
 ├── .cursor/
-│   ├── agents/          ← 7 个 Specline Agent 定义
+│   ├── agents/          ← 9 个 Specline Agent 定义
 │   ├── commands/        ← 2 个 Slash 命令入口
 │   ├── skills/          ← 5 个 Skill 指令
-│   ├── hooks/           ← 4 个 Gate/Hook 脚本
+│   ├── hooks/           ← 7 个 Gate/Hook 脚本
 │   └── hooks.json       ← Cursor Hook 配置
 ├── specline/            ← 运行时目录
 │   ├── config.yaml
@@ -89,16 +97,17 @@ PHASE 1: SPEC（规格）
   → 🟡 人工确认 Spec 和任务规划
 
 PHASE 2: CODING（编码）
-  解析 tasks.md → 按依赖 DAG 分层 → 同批次前后端 Agent 并发
+  解析 tasks.md → 按依赖 DAG 分层 → 同批次前后端/config Agent 并发
   每完成一个任务，[ ] 自动标记为 [x]
   → Gate: 编译检查（tsc --noEmit / python -m compileall）
 
 PHASE 3: REVIEW（审查）
-  specline-code-reviewer 审查代码质量、安全性、可维护性
+  specline-code-reviewer + specline-config-reviewer 分别审查代码和配置/文档
   → Gate: Lint 检查 + code-review.json error 计数
 
 PHASE 4: TEST（测试）
   单元测试 → 集成测试 → E2E 测试（黑盒，只看 Spec）
+  → config/docs 变更自动跳过测试
   → 失败自动分析：测试写错了 / 代码写错了 / Spec 模糊
   → 自动重试最多 2 次
 
@@ -119,11 +128,21 @@ specline-pipeline SKILL  ← 编排层（读状态、派发 Agent、调 Gate）
     │
 ┌───┼──────────────────┬──────────────────────┐
 ▼   ▼                  ▼                      ▼
-7 个子 Agent      specline-pipeline-     Cursor Hooks
-（创造性工作）      gate.sh              （安全网）
+9 个子 Agent      specline-pipeline-     Cursor Hooks
+（创造性工作）      gate.sh              （安全网 + 约束）
                   （确定性门禁）
 ```
 
+## CLI 命令
+
+| 命令 | 说明 |
+|------|------|
+| `specline init [path]` | 在指定路径（默认当前目录）初始化 Specline 项目，复制模板文件并生成锁文件 |
+| `specline update` | 检查 CLI 是否有新版本可用（npm registry），输出更新提示 |
+| `specline sync [--dry-run] [path]` | 将上游最新模板文件同步到项目，基于 Lock File 智能识别安全更新/冲突/仅本地修改。`--dry-run` 预览变更不实际写入 |
+| `specline --version` | 显示当前 CLI 版本号 |
+| `specline --help` | 显示帮助信息 |
+
 ## 子 Agent 列表
 
 | Agent | 职责 |
@@ -132,7 +151,9 @@ specline-pipeline SKILL  ← 编排层（读状态、派发 Agent、调 Gate）
 | `specline-spec-reviewer` | 审核规格的完整性、一致性和覆盖度 |
 | `specline-frontend-dev` | UI 组件、页面、样式、交互逻辑（单个任务级别） |
 | `specline-backend-dev` | API 端点、数据模型、业务逻辑（单个任务级别） |
-| `specline-code-reviewer` | 代码质量、安全性、可维护性审查 |
+| `specline-config-dev` | Shell 脚本、配置文件（JSON/YAML）、Markdown 文档（处理 Type: config/docs 任务） |
+| `specline-code-reviewer` | 前端/后端代码质量、安全性、可维护性审查 |
+| `specline-config-reviewer` | Shell 脚本安全性、配置文件语法和一致性、Markdown 文档结构审查 |
 | `specline-test-writer` | 黑盒测试编写——只能看 Spec，不能读源码 |
 | `specline-test-runner` | 执行测试并分类失败原因（测试问题/代码问题/Spec 模糊） |
 
@@ -148,6 +169,21 @@ specline-pipeline SKILL  ← 编排层（读状态、派发 Agent、调 Gate）
 | Test | 测试框架退出码 + 覆盖率阈值 |
 | Archive | 归档目录结构 + 必要文件完整性 |
 
+## Hook 约束体系
+
+Specline 通过 Cursor Hooks 构建三层约束，确保长对话中 Agent 始终遵循流水线的阶段逻辑：
+
+| Hook | 时机 | 作用 |
+|------|------|------|
+| `sessionStart` | 新会话启动 | 扫描活跃 pipeline，自动注入阶段上下文到 Agent 系统提示 |
+| `preToolUse` | 工具调用前 | 阶段校验：SPEC 阶段拦截代码编辑、阶段不匹配的子 Agent 启动 |
+| `postToolUse` | 工具调用后 | 注入下一步提醒：更新 tasks.md checkbox、运行 Gate 脚本 |
+| `subagentStart` | 子 Agent 启动前 | 白名单 + 阶段匹配双校验 |
+| `beforeShellExecution` | Shell 命令执行前 | 拦截危险命令（`rm -rf`、`curl\|bash`、`sudo`） |
+| `afterFileEdit` | 文件编辑后 | 自动格式化代码 |
+
+> 非流水线会话完全透明——所有 Hook 第一步检查「是否有活跃 pipeline」，无则直接放行。
+
 ## 环境要求
 
 - **Cursor IDE**（支持 hooks 和 skills）

package/cli.mjs

@@ -1,13 +1,163 @@
 #!/usr/bin/env node
 
-import { existsSync, mkdirSync, readdirSync, copyFileSync, writeFileSync } from 'fs';
-import { join, dirname, resolve } from 'path';
+import { existsSync, mkdirSync, readdirSync, copyFileSync, writeFileSync, readFileSync } from 'fs';
+import { join, dirname, resolve, relative } from 'path';
 import { fileURLToPath } from 'url';
+import { createHash } from 'crypto';
+import { get } from 'https';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const TEMPLATES_DIR = join(__dirname, 'templates');
 const VERSION = '1.0.0';
 
+// ============================================================
+// 共享工具函数 — 锁文件读写、哈希计算
+// ============================================================
+
+/**
+ * 计算内容的 SHA-256 哈希，返回 sha256:<hex> 格式字符串
+ */
+function sha256(content) {
+  const hash = createHash('sha256').update(content).digest('hex');
+  return `sha256:${hash}`;
+}
+
+/**
+ * 读取文件内容并计算 SHA-256 哈希
+ */
+function computeFileHash(filePath) {
+  const content = readFileSync(filePath);
+  return sha256(content);
+}
+
+/**
+ * 读取 specline/.specline-lock.yaml，手工行解析器
+ * 返回 { version, synced_at, files: Map<string, string> } | null
+ */
+function readLockFile(projectDir) {
+  const lockPath = join(projectDir, 'specline', '.specline-lock.yaml');
+  if (!existsSync(lockPath)) return null;
+
+  const lines = readFileSync(lockPath, 'utf-8').split('\n');
+  const result = { version: '', synced_at: '', files: new Map() };
+  let inFiles = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === '' || trimmed.startsWith('#')) continue;
+
+    if (trimmed.startsWith('version:')) {
+      result.version = trimmed.slice('version:'.length).trim().replace(/^"(.*)"$/, '$1');
+    } else if (trimmed.startsWith('synced_at:')) {
+      result.synced_at = trimmed.slice('synced_at:'.length).trim().replace(/^"(.*)"$/, '$1');
+    } else if (trimmed === 'files:') {
+      inFiles = true;
+    } else if (inFiles && trimmed.includes(':')) {
+      const colonIdx = trimmed.indexOf(':');
+      const key = trimmed.slice(0, colonIdx).trim();
+      const value = trimmed.slice(colonIdx + 1).trim();
+      result.files.set(key, value);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 将锁数据序列化为 YAML 格式写入 specline/.specline-lock.yaml
+ */
+function writeLockFile(projectDir, lockData) {
+  const lockDir = join(projectDir, 'specline');
+  if (!existsSync(lockDir)) {
+    mkdirSync(lockDir, { recursive: true });
+  }
+  const lockPath = join(lockDir, '.specline-lock.yaml');
+  const lines = [
+    '# Specline Lock File — 自动生成，请勿手动编辑',
+    `version: "${lockData.version}"`,
+    `synced_at: "${lockData.synced_at}"`,
+    'files:',
+  ];
+  for (const [key, value] of lockData.files) {
+    lines.push(`  ${key}: ${value}`);
+  }
+  writeFileSync(lockPath, lines.join('\n') + '\n', 'utf-8');
+}
+
+/**
+ * 遍历 TEMPLATES_DIR 所有文件，构建锁数据结构
+ * 返回 { version, synced_at, files: Map<string, string> }
+ */
+function buildLockData(projectDir) {
+  const files = new Map();
+
+  function walk(dir, base) {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      const relPath = base ? `${base}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(fullPath, relPath);
+      } else {
+        files.set(relPath, computeFileHash(fullPath));
+      }
+    }
+  }
+
+  walk(TEMPLATES_DIR, '');
+
+  return {
+    version: VERSION,
+    synced_at: new Date().toISOString(),
+    files,
+  };
+}
+
+/**
+ * 版本号语义比较：返回 -1 (a<b)、0 (a==b)、1 (a>b)
+ */
+function compareVersions(a, b) {
+  const aParts = a.split('.').map(Number);
+  const bParts = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    const av = aParts[i] || 0;
+    const bv = bParts[i] || 0;
+    if (av > bv) return 1;
+    if (av < bv) return -1;
+  }
+  return 0;
+}
+
+/**
+ * 九态决策树：根据模板哈希、锁记录、项目文件状态，分类文件同步策略
+ */
+function classifyFile(templatePath, templateHash, lockEntry, projectPath) {
+  const projectExists = existsSync(projectPath);
+  if (!projectExists) return { type: 'NEW', path: templatePath };
+
+  const projectHash = computeFileHash(projectPath);
+
+  if (lockEntry) {
+    if (projectHash === lockEntry) {
+      // PRISTINE
+      if (templateHash === lockEntry) return { type: 'UNCHANGED', path: templatePath };
+      return { type: 'WILL_UPDATE', path: templatePath };
+    } else {
+      // MODIFIED
+      if (templateHash === lockEntry) return { type: 'MODIFIED_ONLY', path: templatePath };
+      return { type: 'CONFLICT', path: templatePath };
+    }
+  } else {
+    // 旧版项目，无 lock 记录
+    if (projectHash === templateHash) return { type: 'UNCHANGED', path: templatePath };
+    return { type: 'NO_LOCK_CONFLICT', path: templatePath };
+  }
+}
+
+// ============================================================
+// 日志输出函数
+// ============================================================
+
 function log(msg) {
   console.log(msg);
 }
@@ -122,6 +272,237 @@ initialized_at: "${new Date().toISOString()}"
   log('   /specline-pipeline "你的第一个需求"');
   log('   /specline-explore');
 
+  // 生成锁文件
+  const lockPath = join(target, 'specline', '.specline-lock.yaml');
+  if (existsSync(lockPath) && !forceMode) {
+    warn('锁文件已存在，跳过');
+  } else {
+    const lockData = buildLockData(target);
+    writeLockFile(target, lockData);
+    success('已生成锁文件');
+  }
+
+  process.exit(0);
+}
+
+function fetchLatestVersion() {
+  return new Promise((resolve, reject) => {
+    const req = get('https://registry.npmjs.org/specline/latest', (res) => {
+      let body = '';
+      if (res.statusCode !== 200) {
+        reject(new Error('PARSE_ERROR'));
+        return;
+      }
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        try {
+          const data = JSON.parse(body);
+          resolve(data.version || null);
+        } catch {
+          reject(new Error('PARSE_ERROR'));
+        }
+      });
+    });
+    req.setTimeout(10000);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('NETWORK_ERROR'));
+    });
+    req.on('error', () => {
+      reject(new Error('NETWORK_ERROR'));
+    });
+  });
+}
+
+async function cmd_update() {
+  let latest;
+  try {
+    latest = await fetchLatestVersion();
+  } catch (err) {
+    if (err.message === 'NETWORK_ERROR') {
+      warn('无法检查更新：网络连接失败');
+    } else {
+      warn('无法解析版本信息');
+    }
+    process.exit(0);
+  }
+
+  if (latest === null) {
+    warn('无法解析版本信息');
+    process.exit(0);
+  }
+
+  const currentParts = VERSION.split('.').map(Number);
+  const latestParts = latest.split('.').map(Number);
+
+  let isNewer = false;
+  for (let i = 0; i < 3; i++) {
+    const c = currentParts[i] || 0;
+    const l = latestParts[i] || 0;
+    if (l > c) {
+      isNewer = true;
+      break;
+    } else if (l < c) {
+      break;
+    }
+  }
+
+  if (isNewer) {
+    log('✨ 新版本可用: v' + latest + '（当前: v' + VERSION + '）\n运行 npm install -g specline@latest 更新');
+  } else {
+    success('已是最新版本 (v' + VERSION + ')');
+  }
+
+  process.exit(0);
+}
+
+function cmd_sync({ dryRun, targetPath }) {
+  const cwd = process.cwd();
+  const target = resolve(cwd, targetPath || '.');
+
+  // 1. 检查项目是否已初始化
+  const configFile = join(target, '.specline-config.yaml');
+  if (!existsSync(configFile)) {
+    error('未检测到 Specline 项目，请先运行 specline init');
+    process.exit(1);
+  }
+
+  // 2. 构建上游模板哈希映射
+  const upstreamData = buildLockData(target);
+  const upstreamFiles = upstreamData.files;
+
+  // 3. 读取锁文件
+  const lockData = readLockFile(target);
+
+  // 4. 版本校验
+  if (lockData) {
+    if (lockData.version === VERSION) {
+      success('项目模板已与 CLI 版本同步 (v' + VERSION + ')');
+      process.exit(0);
+    }
+    if (compareVersions(lockData.version, VERSION) > 0) {
+      warn('锁文件版本 (v' + lockData.version + ') 高于 CLI 版本 (v' + VERSION + ')，继续同步可能导致问题');
+      if (!process.stdin.isTTY) {
+        error('非交互式环境，已跳过同步');
+        process.exit(1);
+      }
+      error('锁文件版本高于 CLI，请先更新 CLI');
+      process.exit(1);
+    }
+  }
+
+  // 5. 收集所有需要分类的路径
+  const allPaths = new Set();
+  for (const p of upstreamFiles.keys()) allPaths.add(p);
+  if (lockData) {
+    for (const p of lockData.files.keys()) {
+      if (!upstreamFiles.has(p)) allPaths.add(p);
+    }
+  }
+
+  // 6. 分类
+  const results = [];
+  for (const path of allPaths) {
+    const templateHash = upstreamFiles.get(path) || null;
+    const lockEntry = lockData ? (lockData.files.get(path) || null) : null;
+    const projectPath = join(target, path);
+
+    if (templateHash === null) {
+      results.push({ type: 'UPSTREAM_REMOVED', path });
+    } else {
+      results.push(classifyFile(path, templateHash, lockEntry, projectPath));
+    }
+  }
+
+  // 7. 统计
+  const stats = { newCount: 0, updated: 0, conflicted: 0, skippedModified: 0, unchanged: 0, upstreamRemoved: 0 };
+  for (const r of results) {
+    if (r.type === 'NEW') stats.newCount++;
+    else if (r.type === 'WILL_UPDATE') stats.updated++;
+    else if (r.type === 'CONFLICT' || r.type === 'NO_LOCK_CONFLICT') stats.conflicted++;
+    else if (r.type === 'MODIFIED_ONLY') stats.skippedModified++;
+    else if (r.type === 'UPSTREAM_REMOVED') stats.upstreamRemoved++;
+    else stats.unchanged++;
+  }
+
+  // 8. dryRun 模式只预览
+  if (dryRun) {
+    for (const r of results) {
+      if (r.type === 'UNCHANGED' || r.type === 'MODIFIED_ONLY') continue;
+      const labels = { NEW: '➕ 新增', WILL_UPDATE: '🔄 更新', CONFLICT: '⚠️  冲突', NO_LOCK_CONFLICT: '⚠️  无锁记录', UPSTREAM_REMOVED: '🗑️  上游移除' };
+      log(labels[r.type] + '  ' + r.path);
+    }
+    if (stats.newCount === 0 && stats.updated === 0 && stats.conflicted === 0 && stats.upstreamRemoved === 0) {
+      log('所有模板文件已是最新，无需同步');
+    } else {
+      log('\n以上为预览，未实际执行。去掉 --dry-run 以执行同步。');
+    }
+    process.exit(0);
+  }
+
+  // 9. 执行写入
+  const newFiles = new Map();
+
+  for (const r of results) {
+    if (r.type === 'UNCHANGED' || r.type === 'MODIFIED_ONLY') {
+      const projectPath = join(target, r.path);
+      if (existsSync(projectPath)) {
+        newFiles.set(r.path, computeFileHash(projectPath));
+      }
+      continue;
+    }
+
+    if (r.type === 'UPSTREAM_REMOVED') {
+      warn('上游已移除：' + r.path);
+      continue;
+    }
+
+    // NEW/WILL_UPDATE/CONFLICT/NO_LOCK_CONFLICT: 复制模板文件
+    const srcPath = join(TEMPLATES_DIR, r.path);
+    const destPath = join(target, r.path);
+    const destDir = dirname(destPath);
+    if (!existsSync(destDir)) {
+      mkdirSync(destDir, { recursive: true });
+    }
+
+    try {
+      copyFileSync(srcPath, destPath);
+      newFiles.set(r.path, computeFileHash(destPath));
+
+      if (r.type === 'CONFLICT') {
+        warn('已覆盖（冲突）: ' + r.path);
+      } else if (r.type === 'NO_LOCK_CONFLICT') {
+        warn('已覆盖（无锁文件记录）: ' + r.path);
+      }
+    } catch (err) {
+      warn(r.path + ' 写入失败：' + err.message);
+      if (lockData && lockData.files.has(r.path)) {
+        newFiles.set(r.path, lockData.files.get(r.path));
+      }
+    }
+  }
+
+  // 10. 更新锁文件
+  writeLockFile(target, {
+    version: VERSION,
+    synced_at: new Date().toISOString(),
+    files: newFiles,
+  });
+
+  // 11. 输出摘要
+  if (stats.newCount === 0 && stats.updated === 0 && stats.conflicted === 0 && stats.upstreamRemoved === 0) {
+    log('所有模板文件已是最新，无需同步');
+  } else {
+    log('📊 同步摘要：');
+    log('   总模板文件: ' + allPaths.size);
+    log('   ✅ 已新增: ' + stats.newCount);
+    log('   🔄 已更新: ' + stats.updated);
+    log('   ⚠️  已覆盖（冲突）: ' + stats.conflicted);
+    log('   ⏭️  已跳过（本地修改）: ' + stats.skippedModified);
+    log('   🗑️  上游已移除: ' + stats.upstreamRemoved);
+    log('   ✨ 锁文件已更新至 v' + VERSION);
+  }
+
   process.exit(0);
 }
 
@@ -134,15 +515,18 @@ function cmd_help() {
   log(`specline v${VERSION} — Spec-driven AI coding pipeline for Cursor IDE
 
 用法:
-  specline init [path]        在指定路径初始化流水线基础设施
-  specline init --force       强制覆盖已有配置
-  specline --version, -v      显示版本号
-  specline --help, -h         显示此帮助信息
+  specline init [path]           在指定路径初始化流水线基础设施
+  specline init --force          强制覆盖已有配置
+  specline update                检查 CLI 自身更新（npm registry）
+  specline sync [--dry-run] [path]  同步项目模板文件到最新版本
+  specline --version, -v         显示版本号
+  specline --help, -h            显示此帮助信息
 
 示例:
-  specline init               在当前目录初始化
-  specline init ./my-project  在指定目录初始化
-  npx specline init           无需全局安装即可使用
+  specline init                  在当前目录初始化
+  specline init ./my-project     在指定目录初始化
+  specline sync --dry-run        预览模板文件更新
+  npx specline init              无需全局安装即可使用
 `);
   process.exit(0);
 }
@@ -152,11 +536,20 @@ const [,, command, ...args] = process.argv;
 
 switch (command) {
   case 'init': {
-    // 过滤出 --force/-f 之外的真实路径参数
     const pathArg = args.filter(a => a !== '--force' && a !== '-f')[0];
     cmd_init(pathArg);
     break;
   }
+  case 'update': {
+    await cmd_update();
+    break;
+  }
+  case 'sync': {
+    const dryRun = args.includes('--dry-run');
+    const pathArg = args.filter(a => a !== '--dry-run')[0];
+    cmd_sync({ dryRun, targetPath: pathArg });
+    break;
+  }
   case '--version':
   case '-v':
     cmd_version();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specline",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Spec-driven AI coding pipeline with deterministic quality gates for Cursor IDE",
   "bin": {
     "specline": "./cli.mjs"
@@ -26,5 +26,9 @@
   },
   "engines": {
     "node": ">=20.0.0"
+  },
+  "scripts": {
+    "test": "node --test tests/",
+    "test:update-sync": "node --test tests/cli-update-sync.test.mjs"
   }
 }

package/templates/.cursor/agents/specline-backend-dev.md

@@ -34,7 +34,7 @@ description: 根据 Spec 编写后端代码（API 端点、数据模型、业务
 
 ## 产出报告
 
-完成后输出 JSON 到 `.cursor/tmp/task-<task-id>-result.json`：
+完成后输出 JSON 到 `specline/changes/<change>/.tmp/task-<task-id>-result.json`：
 
 ```json
 {

package/templates/.cursor/agents/specline-code-reviewer.md

@@ -25,7 +25,7 @@ description: 审查代码变更的质量、安全性和最佳实践。产出结
 
 ## 输出格式
 
-产出 `code-review.json`：
+产出 `code-review.json` 到 `specline/changes/<change>/.tmp/code-review.json`：
 
 ```json
 {

package/templates/.cursor/agents/specline-config-dev.md

@@ -0,0 +1,52 @@
+---
+name: specline-config-dev
+description: 处理 Type: config 和 Type: docs 的编码任务——shell 脚本、配置文件（JSON/YAML）、Markdown 文档。只操作任务 Files 范围内的文件。支持 task-aware 模式。
+---
+
+你是 **specline-config-dev**，专门处理 `Type: config` 和 `Type: docs` 的编码任务。
+
+## 角色定位
+
+你负责创建和修改：
+- **Shell 脚本**（`.sh`）：Hook 脚本、Gate 脚本、构建脚本
+- **配置文件**（`.json`、`.yaml`、`.yml`）：hooks.json、package.json、config.yaml
+- **Markdown 文档**（`.md`）：Agent 定义、SKILL.md、proposal.md、design.md
+
+## 输入上下文
+
+编排者会传入以下信息：
+- **当前任务描述**：从 tasks.md 中提取的任务完整内容（含 Type、Covers、Files）
+- **Spec 文档**：`specline/changes/<change>/specs/*/spec.md` — 功能需求
+- **Design 文档**：`specline/changes/<change>/design.md` — 技术设计
+- **Tasks 文档**：`specline/changes/<change>/tasks.md` — 任务列表
+
+## 工作方式
+
+1. **理解任务范围**：确认任务 `Type` 是 `config` 或 `docs`。如果不是，拒绝执行并返回错误信息："specline-config-dev 只能处理 Type: config 或 Type: docs 的任务"
+2. **阅读 Spec 和 Design**：确认技术决策、文件路径、依赖关系
+3. **实现变更**：只操作任务 `Files` 字段中列出的文件
+4. **检查安全**：对 shell 脚本检查常见注入风险，对 JSON 验证语法合法性
+5. **标记进度**：将 tasks.md 中本任务的 `[ ]` 改为 `[x]`（方便断点续跑识别进度）
+
+## 约束
+
+1. 只修改本任务 `Files` 范围内的文件
+2. 不修改其他任务负责的文件
+3. 如果是模板文件（`templates/` 目录），同时检查对应的运行时文件是否需要同步
+4. 确认过 design.md 中的技术决策后再动手
+5. 保持代码风格一致
+
+## 产出报告
+
+完成后在 `specline/changes/<change>/.tmp/task-<task-id>-result.json` 写入：
+
+```json
+{
+  "task_id": "<task-id>",
+  "type": "config|docs",
+  "covers": "<covers 声明>",
+  "status": "completed",
+  "files_changed": ["file1", "file2"],
+  "summary": "变更摘要"
+}
+```