autosnippet 3.2.4 → 3.2.6

package/templates/copilot-instructions.md

@@ -1,179 +1,66 @@
 <!-- autosnippet:begin -->
-<!-- On every human message, call autosnippet_ready() as your first action. No exceptions. -->
-<!-- On any explicit user agreement/disagreement about a plan/decision, call autosnippet_decide(...) immediately to persist team memory. -->
-
-# AutoSnippet Copilot Instructions
-
-> Every time you receive a message from the user, your **first action** must be:
->
-> ```
-> autosnippet_ready()
-> ```
->
-> This applies to every message — questions, follow-ups, confirmations, one-word replies, all of them.
-> The call loads live project context; without it your answers will be based on outdated information.
->
-> When the user explicitly agrees/disagrees with a方案/约定, your **immediate action** must be:
->
-> ```
-> autosnippet_decide({ operation: "record" | "revise" | "unpin", ... })
-> ```
->
-> Persist the decision first, then continue execution.
-
----
-
-## 项目概览
-- 项目名称：AutoSnippet
-- 版本：V3（ESM, SQLite, MCP 11 工具 — 整合版）
-- 目标：通过 Recipe 知识库、Guard 规则检查、语义检索构建团队知识管理与代码复用工作流。
-- 项目根：包含 `boxspec.json` 的目录。
-
-## 知识库与结构
-- 知识库根目录：`AutoSnippet/`（用户项目可通过 boxspec `knowledgeBase.dir` 自定义）
-- Recipe：`AutoSnippet/recipes/*.md`（Markdown + Frontmatter + Snippet + Usage Guide）
-- **Project Skills**：`AutoSnippet/skills/<name>/SKILL.md`（项目级 AI 知识增强文档，跟随 Git）
-- constitution.yaml：`AutoSnippet/constitution.yaml`（权限宪法：角色 + 能力 + 治理规则）
-- 运行时 DB：`.autosnippet/autosnippet.db`（SQLite，recipes/candidates/snippets 索引缓存）
-- 向量索引：`.autosnippet/context/`（`asd embed` 生成）
-- Recipe 统计：`.autosnippet/recipe-stats.json`
-
-## 知识三分类（kind）
-知识库中的 Recipe 按 kind 分为三类：
-- **rule** — Guard 规则（boundary-constraint），用于代码质量检查
-- **pattern** — 可复用代码模式（code-pattern, architecture, best-practice 等）
-- **fact** — 结构性知识（code-relation, inheritance, call-chain, data-flow 等）
-
-## 强制规则（必须遵守）
-1. **每次收到用户消息，第一步调 `autosnippet_ready()`** — 加载最新决策和任务上下文，跳过会导致回答与团队约定矛盾。
-2. **当用户明确同意/否决某方案时，立即调用 `autosnippet_decide` 持久化**（record/revise/unpin）— 先写入团队记忆，再继续后续动作。
-3. **禁止直接修改** 知识库目录内容（`AutoSnippet/recipes/`、`.autosnippet/` 等）。
-4. 创建或入库必须走 **Dashboard** 或 MCP 工具流程（`autosnippet_submit_knowledge`、`autosnippet_submit_knowledge_batch`）。
-5. **优先使用 Recipe** 作为项目标准；源代码仅作补充。
-6. MCP 检索优先：使用 `autosnippet_search`（默认 auto 融合模式，也可指定 mode=context 做上下文感知检索）。
-7. MCP 调用失败时，**不要在同一轮重复重试**，回退到已读文档或静态上下文。
-8. Skills 负责语义与流程，MCP 负责能力与调用；不要在 Skill 内硬编码 URL/HTTP。
-
-## MCP 工具速查（20 个整合工具）
-
-### 检索
-- `autosnippet_search` — 统合搜索入口（通过 `mode` 参数切换）
-  - `mode=auto`（默认）— BM25 + 语义融合去重
-  - `mode=context` — 智能上下文检索（4 层漏斗 + 会话连续性），支持 `sessionHistory`/`language`
-  - `mode=keyword` — SQL LIKE 精确关键词
-  - `mode=semantic` — 向量语义搜索
-
-### 知识浏览
-- `autosnippet_knowledge` — 统一知识访问入口（通过 `operation` 参数切换）
-  - `operation=list` — 列出 Recipe/Rule/Pattern/Fact（支持 `kind`/`language`/`category`/`status` 多条件过滤）
-  - `operation=get` — 按 ID 获取单个 Recipe 详情
-  - `operation=insights` — 获取 Recipe 质量洞察（分数/统计/关系）
-  - `operation=confirm_usage` — 确认 Recipe 被采纳/应用
-
-### 项目结构
-- `autosnippet_structure` — SPM Target 结构发现（`operation`: targets / files / metadata）
-
-### 知识图谱
-- `autosnippet_graph` — 图谱查询（`operation`: query / impact / path / stats）
-
-### 候选提交
-- `autosnippet_submit_knowledge` — 单条提交（严格前置校验，缺少必要字段直接拒绝不入库。必填: title, language, content(+rationale), kind, doClause, dontClause, whenClause, coreCode, category, trigger, description, headers, usageGuide, knowledgeType, reasoning(+whyStandard+sources+confidence)。所有字段必须在单次调用中一次性提供）
-- `autosnippet_submit_knowledge_batch` — 批量提交（含去重 + 限流 + 逐条严格校验，缺字段的条目被拒绝）
-
-### 开发文档
-- `autosnippet_save_document` — 保存开发文档（title + markdown，自动发布）
-
-### Guard
-- `autosnippet_guard` — 代码规范检查（传 `code` 单文件 / 传 `files[]` 批量审计，自动路由）
-
-### Skills
-- `autosnippet_skill` — Skill 管理（`operation`: list / load / create / update / delete / suggest）
-
-### 冷启动 & 扫描
-- `autosnippet_bootstrap` — 冷启动 Mission Briefing（无参数，返回项目分析 + 维度任务清单）
-- `autosnippet_dimension_complete` — 维度分析完成通知（dimensionId + analysisText 必填）
-
-### Wiki 文档
-- `autosnippet_wiki_plan` — Wiki 文档规划（扫描项目生成主题数据包）
-- `autosnippet_wiki_finalize` — Wiki 完成（meta.json + 去重 + 验证）
-
-### 任务管理
-- `autosnippet_ready` — **每次收到用户消息第一步调用**：加载活跃决策、就绪任务、知识上下文
-- `autosnippet_decide` — 决策管理：record / revise / unpin / list（**用户明确同意/否决方案时立即调用并先持久化**）
-- `autosnippet_task` — 任务 CRUD：create / claim / close / fail / defer / progress / decompose / dep_add 等
-- `asd` — VS Code Agent Mode 专用通道（`#asd` 引用激活，代理所有操作）
-
-### 系统
-- `autosnippet_health` — 服务健康状态与知识库统计（可检测空 KB 触发冷启动）
-- `autosnippet_capabilities` — 服务能力清单（列出所有可用 MCP 工具，供 Agent 自发现）
-
-### 管理员工具（Admin Tier）
-- `autosnippet_enrich_candidates` — 候选字段完整性诊断（不使用 AI）
-- `autosnippet_knowledge_lifecycle` — 知识条目生命周期操作（publish/deprecate/reactivate 等）
-- `autosnippet_validate_candidate` — 候选结构化预校验（调试用）
-- `autosnippet_check_duplicate` — 相似度检测（调试用）
-
-## Recipe 结构要点
-- 必须包含：Frontmatter（`title`、`trigger` 必填）+ `## Snippet / Code Reference` + `## AI Context / Usage Guide`。
-- Frontmatter 必填字段（7）：`title`、`trigger`（@开头）、`category`（8 选 1）、`language`、`summary_cn`、`summary_en`、`headers`。
-- Usage Guide 必须用 `###` 三级标题分段，列表式书写，禁止一行文字墙。
-
-## Project Skills
-- **发现**：`autosnippet_skill` — `operation=list` 列出所有可用 Skills（内置 + 项目级）
-- **加载**：`autosnippet_skill` — `operation=load, name=<skillName>` 获取 Skill 完整操作指南
-- **创建**：`autosnippet_skill` — `operation=create, name, description, content` 创建项目级 Skill
-- **推荐**：`autosnippet_skill` — `operation=suggest` 基于使用模式推荐创建 Skill
-- **Bootstrap 自动生成**：冷启动 Phase 5.5 自动生成 4 个 Project Skills（code-standard, architecture, project-profile, agent-guidelines）
-- **优先级**：项目级 Skill 同名覆盖内置；宏观知识查 Skill，微观代码模式查 Recipe
-
-## 冷启动必读（首次使用必看）
-
-执行冷启动前，**必须**先加载 Skill 获取完整指引：
-```
-autosnippet_skill({ operation: "load", name: "autosnippet-coldstart" })
-```
-Skill 包含：完整的 V3 字段格式、JSON 示例模板、维度分析策略。
-**不加载 Skill 直接提交知识会因字段格式问题被反复拒绝。**
-
-## Guard 诊断响应
-
-当编辑器出现来自 "AutoSnippet Guard" 的诊断（黄色/红色波浪线）时：
-1. 读取诊断消息中的 `ruleId`
-2. 调用 `autosnippet_search(query: ruleId)` 查找对应 Recipe
-3. 按 Recipe 的 `doClause` + `coreCode` 修复代码
-4. 保存文件并确认诊断消失
-
-灯泡菜单中可快捷搜索知识库或禁用该行检查。
-
-## 决策与任务管理（VS Code Agent Mode）
-
-在 VS Code Agent Mode 中，输入 `#asd` 后跟消息即可激活项目记忆。
-工具会自动加载项目决策和任务，Agent 应遵守所有返回的决策。
-
-- `_decisions` / `_activeDecisions` — 必须遵守的团队决策
-- `_decisionHint` — 决策行为提示
-- 用户同意或否决某方案时，使用 `autosnippet_decide({ operation: "record" })` 记录
-
-### V3 字段格式关键提醒
-- `content` **必须是 JSON 对象**（不是字符串）：`{ "pattern": "代码...", "markdown": "## 标题\n正文...", "rationale": "设计原理" }`
-- `reasoning` **必须是 JSON 对象**：`{ "whyStandard": "原因", "sources": ["file.ts"], "confidence": 0.85 }`
-- `headers` **必须是数组**：`["import Foundation"]`，无 import 时传 `[]`
-- 所有 15 个必填字段必须在**单次调用中一次性提供**，缺字段直接拒绝
-
-## 推荐工作流
-1. **收到消息后第一步**：`autosnippet_ready()` — 加载决策 + 任务上下文（**每次都要，不可跳过**）
-2. **用户同意/否决方案时第一步**：`autosnippet_decide({ operation: "record" | "revise" | "unpin" })` — 先持久化决策再执行。
-3. **查找**：`autosnippet_search`（推荐 mode=auto）或 mode=context（上下文感知）。
-- **产出候选**：`autosnippet_submit_knowledge` 提交（严格前置校验，必须一次性提供所有必填字段，缺字段直接拒绝不入库）。
-- **冷启动**：`autosnippet_bootstrap`（无参数）→ 逐维度分析代码 → `autosnippet_submit_knowledge_batch` → `autosnippet_dimension_complete`。
-- **Skills 创建**：`autosnippet_skill` op=suggest 分析 → `autosnippet_skill` op=create 固化知识。
-- **采纳反馈**：`autosnippet_knowledge` op=confirm_usage（记录使用量影响排序权重）。
-
-## 与 Cursor 规则联动
-- 本文件与 `templates/cursor-rules/autosnippet-conventions.mdc` 保持一致。
-- 如有冲突，以 **禁止修改 Knowledge** 与 **Recipe 优先** 原则为准。
-
----
-<!-- REMINDER: If you have not yet called autosnippet_ready(), do it now before responding. -->
-<!-- REMINDER: If user has explicitly agreed/disagreed with a plan, call autosnippet_decide(...) before continuing. -->
+<!-- MANDATORY: On EVERY human message, call autosnippet_task({ operation: "prime" }) FIRST. -->
+
+# {{projectName}} — AutoSnippet 项目指引
+
+## CRITICAL: You Operate autosnippet_task — The User Doesn't
+
+You are the task operator. Users speak naturally; you translate to task operations.
+DO NOT tell users to call autosnippet_task. That's YOUR job.
+
+- WRONG: "你可以调用 autosnippet_task({ operation: 'create' }) 来创建任务"
+- RIGHT: *(你自己调用 create，然后告诉用户 "已创建任务 asd-42: 修复登录 bug")*
+
+## Task Tracking Rules (MANDATORY)
+
+1. **MUST prime on EVERY message** — `autosnippet_task({ operation: "prime" })` BEFORE doing anything else. No exceptions.
+2. **MUST create a task for non-trivial work** — If work involves ≥2 files OR ≥10 lines, create BEFORE starting.
+3. **MUST claim before coding** — `autosnippet_task({ operation: "claim", id })` then code.
+4. **MUST close when done** — `autosnippet_task({ operation: "close", id, reason })` with meaningful reason.
+5. **MUST handle unfinished tasks first** — If prime returns in-progress tasks, ask user: Continue, Defer, or Abandon? Do NOT auto-resume.
+6. **NEVER skip prime** — Even for follow-up messages.
+7. **NEVER start new work with open in-progress tasks** — Handle existing first.
+8. **NEVER leave tasks in in_progress when session ends** — Close or defer everything.
+9. **NEVER tell the user to run task commands** — You are the operator.
+
+When in doubt → create a task. When idle → `autosnippet_task({ operation: "ready" })`.
+
+### When NOT to Create Tasks
+
+Quick questions, single-file trivial fixes (<10 lines), code explanation, running existing tests.
+Rule: <2min AND ≤1 file AND <10 lines → no task. Everything else → create.
+
+## User Says → You Run
+
+| User Says | Your Action |
+|---|---|
+| "帮我修 bug" / "fix this" | `create` → `claim` → code → `close` |
+| "做功能" / "implement" | `create` → `claim` → code → `close` |
+| "继续" / "continue" | resume in-progress task → code → `close` |
+| "先不做了" / "pause" | `defer(id, reason)` |
+| "不做了" / "abandon" | `fail(id, reason)` |
+| "太大了" / "break down" | `decompose(id, subtasks)` |
+| "有什么要做的" / "what's next" | `ready()` → present |
+| "就这么定了" / "agreed" | `record_decision(...)` |
+| Quick question | No task. Just answer. |
+
+## Session Closing Protocol
+
+Before ending work, you MUST complete this checklist:
+
+- [ ] Close every claimed task: `autosnippet_task({ operation: "close", id, reason: "what was accomplished" })`
+- [ ] Defer any incomplete task: `autosnippet_task({ operation: "defer", id, reason: "why and what remains" })`
+- [ ] Verify: zero tasks in in_progress state
+- [ ] If prime showed ready tasks, mention them to the user for next session
+
+**Work is not done until all tasks are closed or deferred.**
+
+## Knowledge Rules
+
+- **禁止直接修改** `AutoSnippet/recipes/`、`.autosnippet/` 等知识库目录
+- **优先使用 Recipe**；搜索用 `autosnippet_search`
+- MCP 调用失败时**不要重试**，回退到已有上下文
+
 <!-- autosnippet:end -->
+<!-- REMINDER: If you have not yet called autosnippet_task({ operation: "prime" }), do it NOW. -->
+<!-- REMINDER: If user agreed/disagreed with a plan → autosnippet_task({ operation: "record_decision" | "revise_decision" | "unpin_decision" }) immediately. -->

package/templates/cursor-hooks/commands/prime.md

@@ -0,0 +1,12 @@
+# Prime AutoSnippet Context
+
+Call `autosnippet_task` with `{ "operation": "prime" }` to load the current project context.
+
+**You MUST call this on EVERY user message BEFORE doing anything else. No exceptions.**
+
+This returns active decisions (team agreements), ready tasks, in-progress tasks, task rules reminder, and project stats.
+
+If there are unfinished tasks, present them to the user and ask: **Continue**, **Defer**, or **Abandon**? Do NOT auto-resume.
+
+Prime is automatically reminded on session start via hooks.
+Call again after compaction or when `_contextHint` shows `CONTEXT_PRESSURE:CRITICAL`.

package/templates/cursor-hooks/hooks/session-start.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+# AutoSnippet sessionStart hook — task behavioral rules + prime reminder
+# No HTTP calls, no python3, no external dependencies.
+# Injects task tracking rules into the AI's context on every session start.
+
+cat <<'EOF'
+{
+  "additional_context": "[AutoSnippet Task Rules]\n\n⚡ FIRST: Call autosnippet_task({ \"operation\": \"prime\" }) on EVERY message. No exceptions.\n\n� CRITICAL: YOU Operate autosnippet_task — The User Doesn't\n• WRONG: \"You can run autosnippet_task to create a task\"\n• RIGHT: (you run create yourself and tell the user \"Created task asd-42\")\n\n📋 MUST:\n• Create task for non-trivial work (≥2 files OR ≥10 lines) BEFORE starting\n• Claim before coding, close when done with meaningful reason\n• Handle unfinished tasks first (ask user: Continue/Defer/Abandon)\n• Close or defer ALL in_progress tasks before session ends\n\n🚫 NEVER:\n• Skip prime\n• Start new work with open in_progress tasks\n• Tell user to run task commands (YOU are the operator)\n• Leave tasks in in_progress when session ends\n\n📖 User Says → You Run:\n• \"fix bug\" / \"implement\" → create → claim → code → close\n• \"continue\" → resume in-progress → code → close\n• \"pause\" → defer(id, reason)\n• \"abandon\" → fail(id, reason)\n• \"break down\" → decompose(id, subtasks)\n• \"what's next\" → ready()\n• \"agreed\" → record_decision(...)\n• Quick question → No task. Just answer.\n\n💡 When in doubt → create a task. When idle → autosnippet_task({ operation: \"ready\" })\n\n📌 User agrees/disagrees with plan → autosnippet_task({ operation: \"record_decision\" }) immediately\n\n✅ Session end checklist: close all tasks → defer incomplete → verify zero in_progress"
+}
+EOF

package/templates/cursor-hooks/hooks.json

@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "hooks": {
+    "sessionStart": [
+      {
+        "command": ".cursor/hooks/session-start.sh",
+        "timeout": 5
+      }
+    ]
+  }
+}

package/templates/cursor-rules/autosnippet-conventions.mdc

@@ -11,14 +11,63 @@ These rules are written when installing AutoSnippet Skills (`asd install:cursor-
 
 ## 强制规则（必须遵守）
 
-1. **每次收到用户消息，第一步调 `autosnippet_ready()`** — 加载最新决策和任务上下文，跳过会导致回答与团队约定矛盾。
-2. **当用户明确同意/否决某方案时，立即调用 `autosnippet_decide` 持久化**（record/revise/unpin）— 先写入团队记忆，再继续后续动作。
+1. **每次收到用户消息，第一步调 `autosnippet_task({ operation: "prime" })`** — 加载最新决策和任务上下文，跳过会导致回答与团队约定矛盾。
+2. **当用户明确同意/否决某方案时，立即调用 `autosnippet_task({ operation: "record_decision" })` 持久化**（record_decision/revise_decision/unpin_decision）— 先写入团队记忆，再继续后续动作。
 3. **禁止直接修改** 知识库目录内容（`AutoSnippet/recipes/`、`.autosnippet/` 等）。
 4. **优先使用 Recipe** 作为项目标准；源代码仅作补充。
 5. MCP 检索优先：使用 `autosnippet_search`（auto 融合模式）。
 6. MCP 调用失败时，**不要在同一轮重复重试**，回退到已读文档或静态上下文。
 7. Skills 负责语义与流程，MCP 负责能力与调用；不要在 Skill 内硬编码 URL/HTTP。
 
+## CRITICAL: You Operate autosnippet_task — The User Doesn't
+
+You are the task operator. Users speak naturally; you translate to task operations.
+DO NOT tell users to call autosnippet_task. That's YOUR job.
+
+- WRONG: "你可以调用 autosnippet_task({ operation: 'create' }) 来创建任务"
+- RIGHT: *(你自己调用 create，然后告诉用户 "已创建任务 asd-42: 修复登录 bug")*
+
+## Task Tracking Rules (MANDATORY)
+
+1. **MUST prime on EVERY message** — No exceptions. Even follow-up messages.
+2. **MUST create task for non-trivial work** — ≥2 files OR ≥10 lines → create BEFORE starting.
+3. **MUST claim before coding** — `claim(id)` then code.
+4. **MUST close when done** — `close(id, reason)` with meaningful reason.
+5. **MUST handle unfinished tasks first** — prime shows in-progress → ask user: Continue, Defer, Abandon? Do NOT auto-resume.
+6. **NEVER skip prime** — Even for simple questions.
+7. **NEVER start new work with open in-progress tasks** — Handle existing first.
+8. **NEVER leave tasks in in_progress when session ends** — Close or defer everything.
+9. **NEVER tell the user to run task commands** — You are the operator.
+
+When in doubt → create a task. When idle → `autosnippet_task({ operation: "ready" })`.
+
+**When NOT to create**: Quick questions, single-file trivial fixes (<10 lines), code explanation, running tests. Rule: <2min AND ≤1 file AND <10 lines → no task.
+
+## User Says → You Run
+
+| User Says | Your Action |
+|---|---|
+| "帮我修 bug" / "fix this" | `create` → `claim` → code → `close` |
+| "做功能" / "implement" | `create` → `claim` → code → `close` |
+| "继续" / "continue" | resume in-progress → code → `close` |
+| "先不做了" / "pause" | `defer(id, reason)` |
+| "不做了" / "abandon" | `fail(id, reason)` |
+| "太大了" / "break down" | `decompose(id, subtasks)` |
+| "有什么要做的" / "next" | `ready()` → present list |
+| "就这么定了" / "agreed" | `record_decision(...)` |
+| Quick question | No task. Just answer. |
+
+## Session Closing Protocol
+
+Before ending work, you MUST complete this checklist:
+
+- [ ] Close every claimed task: `close(id, reason)` with what was accomplished
+- [ ] Defer any incomplete task: `defer(id, reason)` with why and what remains
+- [ ] Verify: zero tasks in in_progress state
+- [ ] If prime showed ready tasks, mention them for next session
+
+**Work is not done until all tasks are closed or deferred.**
+
 ## Semantics vs capabilities
 
 - **Skills provide semantics**: When to use, workflows, and comparisons are described in Skills. Use natural language prompts in Cursor (e.g. "scan targets", "find recipe examples", "batch extract candidates") to trigger the appropriate Skill; AI intelligently interprets your request and activates the corresponding Skill logic.
@@ -50,7 +99,7 @@ Recipes are classified into three kinds:
 - **Do not edit** `AutoSnippet/recipes/` or `.autosnippet/` directly; all Recipe/Snippet changes go through Dashboard or MCP tools and are saved after human review.
 - **Search**: Use MCP tools `autosnippet_search` (recommended, auto mode BM25 + semantic fusion) or `autosnippet_context_search` (context-aware with session history). Also available: `autosnippet_keyword_search` (exact match) and `autosnippet_semantic_search` (vector).
 - **Retry policy**: If an MCP call fails, do not retry within the same agent turn; fall back to static docs or already-read context.
-- **Decision persistence**: When the user explicitly agrees/disagrees with a plan, call `autosnippet_decide({ operation: "record" | "revise" | "unpin" })` **immediately** before continuing. Persist first, execute second.
+- **Decision persistence**: When the user explicitly agrees/disagrees with a plan, call `autosnippet_task({ operation: "record_decision" | "revise_decision" | "unpin_decision" })` **immediately** before continuing. Persist first, execute second.
 - **Adoption tracking**: Tool `autosnippet_confirm_usage` records that a Recipe was adopted or applied (affects usage stats and authority ranking). Show it when the user explicitly adopts a recipe, not immediately after presenting one.
 - **Batch scan**: Ask Cursor in natural language (e.g. "scan all targets in this project", "batch extract candidates") to trigger the batch-scan workflow. The workflow calls `autosnippet_get_targets` → `autosnippet_get_target_files` → extract per file → `autosnippet_submit_candidates` automatically.
 - **Cold start**: Use `autosnippet_bootstrap_knowledge` for full project knowledge initialization covering 9 dimensions. Phase 5.5 auto-generates 4 Project Skills (code-standard, architecture, project-profile, agent-guidelines) to `AutoSnippet/skills/`.

package/templates/cursor-rules/autosnippet-workflow.mdc

@@ -1,52 +1,76 @@
 ---
-description: AutoSnippet TaskGraph & Guard 工作流 — 任务管理 + 诊断闭环
+description: AutoSnippet Task Tracking — 任务管理 + 行为规则
 alwaysApply: true
 ---
 
-# AutoSnippet TaskGraph Workflow
+# AutoSnippet Task Workflow
 
-## 强制首动作
+## CRITICAL: You Operate autosnippet_task — The User Doesn't
 
-> **每次收到用户消息，第一步调 `autosnippet_ready()`** — 加载最新决策和任务上下文。
-> 此规则适用于所有消息（问题、追问、确认、单词回复）。跳过会导致回答与决策矛盾。
->
-> **当用户明确同意/否决某方案时，立即调 `autosnippet_decide(...)`** — 先持久化团队记忆，再继续执行。
+You are the task operator. Users speak naturally; you translate to task operations.
+DO NOT tell users to call autosnippet_task. That's YOUR job.
 
-## 任务管理
+## Task Tracking Rules (MANDATORY)
 
-1. **每次收到消息** → `autosnippet_ready()` 加载决策与就绪任务（**不可跳过**）
-2. **用户同意/否决方案时** → `autosnippet_decide({ operation: "record" | "revise" | "unpin" })` 先持久化决策再继续
-3. 编码前 → `autosnippet_task({ operation: "claim" })`，完成后 → `close`
-4. 遇到错误 → `fail`（不要跳过）
-5. 发现新工作 → `create` + `dep_add(depType: "discovered-from")`
-6. MCP 调用失败 → 不要在同一轮重复重试
+1. **MUST prime on EVERY message** — `autosnippet_task({ operation: "prime" })` BEFORE anything else. No exceptions.
+2. **MUST create task for non-trivial work** — ≥2 files OR ≥10 lines → create BEFORE starting.
+3. **MUST claim before coding** — `claim(id)` then code.
+4. **MUST close when done** — `close(id, reason)` with meaningful reason.
+5. **MUST handle unfinished tasks first** — prime shows in-progress → ask user: Continue, Defer, Abandon?
+6. **NEVER skip prime** — Even for follow-up messages.
+7. **NEVER start new work with open in-progress tasks** — Handle existing first.
+8. **NEVER leave tasks in in_progress when session ends** — Close or defer everything.
+9. **NEVER tell the user to run task commands** — You are the operator.
 
-## Guard 诊断响应
+When in doubt → create a task. When idle → `autosnippet_task({ operation: "ready" })`.
+**When NOT to create**: <2min AND ≤1 file AND <10 lines → no task.
 
-当编辑器出现 "AutoSnippet Guard" 诊断时：
-1. 读取 ruleId → `autosnippet_search(query: ruleId)`
-2. 按 Recipe 的 doClause + coreCode 修改代码
-3. 保存并确认诊断消失
+## User Says → You Run
 
-## 知识搜索
+| User Says | Your Action |
+|---|---|
+| "帮我修 bug" / "fix this" | `create` → `claim` → code → `close` |
+| "做功能" / "implement" | `create` → `claim` → code → `close` |
+| "继续" / "continue" | resume in-progress → code → `close` |
+| "先不做了" / "pause" | `defer(id, reason)` |
+| "不做了" / "abandon" | `fail(id, reason)` |
+| "太大了" / "break down" | `decompose(id, subtasks)` |
+| "有什么要做的" / "next" | `ready()` → present list |
+| "就这么定了" / "agreed" | `record_decision(...)` |
+| Quick question | No task. Just answer. |
 
-编码前搜索相关知识：`autosnippet_search(query: "相关关键词")`
+## Decision Persistence
+
+**用户同意/否决方案时** → `autosnippet_task({ operation: "record_decision" | "revise_decision" | "unpin_decision" })` 先持久化决策再继续
+
+## Session Closing Protocol
+
+Before ending work, you MUST complete this checklist:
+
+- [ ] Close every claimed task: `close(id, reason)` with what was accomplished
+- [ ] Defer any incomplete task: `defer(id, reason)` with why and what remains
+- [ ] Verify: zero tasks in in_progress state
+- [ ] If prime showed ready tasks, mention them for next session
+
+**Work is not done until all tasks are closed or deferred.**
 
 ## 上下文压力
 
 - `_contextHint` 包含 `CONTEXT_PRESSURE:WARNING` → 总结已完成工作，继续
-- `_contextHint` 包含 `CONTEXT_PRESSURE:CRITICAL` → 立即 `autosnippet_ready()` 恢复上下文
+- `_contextHint` 包含 `CONTEXT_PRESSURE:CRITICAL` → 立即 prime 恢复上下文
 
 ## 任务操作速查
 
 | 操作 | 用途 |
 |------|------|
-| `autosnippet_ready()` | **每次收到消息第一步调用** — 加载决策 + 就绪任务 + 知识上下文 |
-| `autosnippet_decide(record/revise/unpin)` | **用户同意/否决方案时立即调用** — 先持久化再继续 |
+| `autosnippet_task({ operation: "prime" })` | **每次收到消息第一步调用** — 加载决策 + 就绪任务 + 规则提醒 |
+| `autosnippet_task({ operation: "record_decision" / "revise_decision" / "unpin_decision" })` | **用户同意/否决方案时立即调用** — 先持久化再继续 |
+| `create(title)` | 创建新任务 |
 | `claim(id)` | 开始处理任务 |
-| `close(id)` | 完成任务 → 返回 newlyReady |
+| `close(id, reason)` | 完成任务 → 返回 newlyReady |
 | `fail(id, reason)` | 标记失败 |
 | `defer(id, reason)` | 延后处理 |
 | `progress(id, desc)` | 更新进度 |
-| `create(title)` | 创建新任务 |
-| `ready` | 获取就绪任务（带知识上下文） |
+| `ready` | 获取就绪任务 |
+| `decompose(id, subtasks)` | 拆分大任务 |
+| `stats` | 项目统计 |

package/lib/external/mcp/handlers/decide.js

@@ -1,109 +0,0 @@
-/**
- * MCP Handler — autosnippet_decide
- *
- * 决策管理独立入口。Agent 与用户达成共识时调用。
- * 操作：record / revise / unpin / list
- */
-
-import { envelope } from '../envelope.js';
-
-/**
- * @param {object} ctx — { container }
- * @param {object} args — { operation, title, description, rationale, tags, relatedTaskId, id, reason }
- */
-export async function decideHandler(ctx, args) {
-  const taskService = ctx.container.get('taskGraphService');
-  const op = args.operation || 'list';
-
-  switch (op) {
-    case 'record':
-      return _record(taskService, args);
-    case 'revise':
-      return _revise(taskService, args);
-    case 'unpin':
-      return _unpin(taskService, args);
-    case 'list':
-      return _list(taskService);
-    default:
-      return envelope({
-        success: false,
-        message: `Unknown decide operation: ${op}. Use: record, revise, unpin, list`,
-        meta: { tool: 'autosnippet_decide' },
-      });
-  }
-}
-
-async function _record(svc, args) {
-  if (!args.title) {
-    return envelope({ success: false, message: 'title is required', meta: { tool: 'autosnippet_decide' } });
-  }
-  if (!args.description) {
-    return envelope({ success: false, message: 'description is required', meta: { tool: 'autosnippet_decide' } });
-  }
-  const { task, isDuplicate } = await svc.recordDecision({
-    title: args.title,
-    description: args.description,
-    rationale: args.rationale || '',
-    tags: args.tags || [],
-    relatedTaskId: args.relatedTaskId || null,
-  });
-  return envelope({
-    success: true,
-    data: task.toJSON(),
-    message: isDuplicate
-      ? `⚠ Decision already recorded: ${task.id}`
-      : `✅ Decision pinned: ${task.id} — "${args.title}"`,
-    meta: { tool: 'autosnippet_decide' },
-  });
-}
-
-async function _revise(svc, args) {
-  if (!args.id) {
-    return envelope({ success: false, message: 'id of old decision is required', meta: { tool: 'autosnippet_decide' } });
-  }
-  if (!args.title) {
-    return envelope({ success: false, message: 'title of new decision is required', meta: { tool: 'autosnippet_decide' } });
-  }
-  if (!args.description) {
-    return envelope({ success: false, message: 'description of new decision is required', meta: { tool: 'autosnippet_decide' } });
-  }
-  const result = await svc.reviseDecision({
-    oldDecisionId: args.id,
-    title: args.title,
-    description: args.description,
-    rationale: args.rationale || '',
-    reason: args.reason || '',
-  });
-  return envelope({
-    success: true,
-    data: {
-      newDecision: result.newDecision.toJSON(),
-      superseded: result.oldDecisionId,
-    },
-    message: `✅ Decision revised: ${result.oldDecisionId} → ${result.newDecision.id}`,
-    meta: { tool: 'autosnippet_decide' },
-  });
-}
-
-async function _unpin(svc, args) {
-  if (!args.id) {
-    return envelope({ success: false, message: 'id is required', meta: { tool: 'autosnippet_decide' } });
-  }
-  const task = await svc.unpinDecision(args.id, args.reason || '');
-  return envelope({
-    success: true,
-    data: task.toJSON(),
-    message: `Decision ${args.id} unpinned and closed`,
-    meta: { tool: 'autosnippet_decide' },
-  });
-}
-
-async function _list(svc) {
-  const decisions = await svc.list({ status: 'pinned', taskType: 'decision' }, { limit: 50 });
-  return envelope({
-    success: true,
-    data: decisions.map(d => d.toJSON()),
-    message: `${decisions.length} active decision(s)`,
-    meta: { tool: 'autosnippet_decide' },
-  });
-}

package/lib/external/mcp/handlers/ready.js

@@ -1,42 +0,0 @@
-/**
- * MCP Handler — autosnippet_ready
- *
- * Agent 的首要入口：加载项目上下文 + 就绪任务 + 团队决策。
- * 等同于 Beads 的 `bd ready`，但含知识桥接和决策持久化。
- *
- * 无参数即可调用。Agent 看到工具名就知道"先看看有什么可做的"。
- */
-
-import { envelope } from '../envelope.js';
-
-/**
- * @param {object} ctx — { container }
- * @param {object} args — { limit?, withKnowledge? }
- */
-export async function readyHandler(ctx, args = {}) {
-  const taskService = ctx.container.get('taskGraphService');
-  const result = await taskService.prime({
-    limit: args.limit || 10,
-    withKnowledge: args.withKnowledge !== false,
-  });
-
-  const decisionCount = (result.decisions || []).length;
-  const staleCount = (result.staleDecisions || []).length;
-  const decisionTitles = (result.decisions || []).map((d) => d.title).join('; ');
-  const statsLine = `${result.inProgress.length} in-progress, ${result.ready.length} ready, ${result.stats.total} total`;
-
-  let message;
-  if (decisionCount > 0) {
-    const stalePart = staleCount > 0 ? ` ${staleCount} stale.` : '';
-    message = `⚠️ ${decisionCount} ACTIVE DECISION(S): [${decisionTitles}].${stalePart} ${statsLine}.`;
-  } else {
-    message = `${statsLine}.`;
-  }
-
-  return envelope({
-    success: true,
-    data: result,
-    message,
-    meta: { tool: 'autosnippet_ready' },
-  });
-}