prompt-contract 0.2.1 → 0.3.0

package/README.md

@@ -7,7 +7,7 @@
 
 English · [简体中文](README.zh-CN.md)
 
-![PromptContract — a vague one-line request becomes a structured task spec (goal, scope, acceptance criteria, non-goals), verified by six hard rules via `prompt-contract check`. Real-LLM latency P50 2.3s; engine adds 0.005ms. CLI · MCP · Playground — zero dependencies, BYOK, offline-capable.](docs/assets/hero-cover.png)
+![PromptContract — a vague one-line request becomes a structured task spec (goal, scope, acceptance criteria, non-goals), verified by six hard rules via `prompt-prompt-contract check`. Real-LLM latency P50 2.3s; engine adds 0.005ms. CLI · MCP · Playground — zero dependencies, BYOK, offline-capable.](docs/assets/hero-cover.png)
 
 **PromptContract is a deterministic prompt-contract layer for AI coding agents.** It compiles a vague one-line request into a structured task specification — goal, scope, constraints, acceptance criteria — and verifies the result against six hard rules before you ever see it.
 
@@ -16,7 +16,7 @@ It is *not* a smarter brain: your model does the thinking, PromptContract makes
 ## Why PromptContract
 
 - **Stable agent inputs** — a profile plus hard constraints turn "a website for my dog" into goal / scope / acceptance criteria / explicit non-goals. Reduced retries and scope drift are hypotheses measured by the task-level harness, not current product claims.
-- **Six deterministic guardrails** — language consistency, enhanced-text-only, length & completeness, expand-don't-answer, no hallucinated tech. Every enhancement can be asserted with `prompt-contract check`; the same spec drives templates and tests.
+- **Six deterministic guardrails** — language consistency, enhanced-text-only, length & completeness, expand-don't-answer, no hallucinated tech. Every enhancement can be asserted with `prompt-prompt-contract check`; the same spec drives templates and tests.
 - **One engine, three surfaces** — a CLI, an MCP server (agent-invoked **tool** + user-invoked **slash prompts**), and a browser playground. All share one zero-dependency core.
 - **Private by architecture** — bring your own key, no server in the middle, no telemetry, offline-capable via Ollama.
 
@@ -30,16 +30,21 @@ node packages/cli/bin/contract.js "帮我做一个展示我家狗的网站" \
 node packages/playground/serve.js                       # → http://127.0.0.1:8123/  (or ?demo=1 for the self-running demo)
 ```
 
-Install: `npm i -g prompt-contract` — or zero-install: `npx prompt-contract "your vague idea"`.
+Install: `npm i -g prompt-contract` — or zero-install: `npx prompt-prompt-prompt-contract "your vague idea"`.
 
 ## Your real model
 
 ```bash
-export CONTRACT_API_KEY=sk-xxx CONTRACT_MODEL=gpt-4o-mini    # any OpenAI-compatible endpoint (DeepSeek, Qwen, GLM, vLLM…)
-prompt-contract "A website for my dog"
+export CONTRACT_API_KEY=sk-xxx CONTRACT_MODEL=gpt-4o-mini    # any OpenAI-compatible endpoint (vLLM, OpenRouter, your gateway…)
+prompt-prompt-contract "A website for my dog"
+
+export CONTRACT_PROVIDER=deepseek CONTRACT_API_KEY=sk-…      # vendor presets carry the base URL + a suggested model
+export CONTRACT_PROVIDER=qwen                                 # also: glm, moonshot, groq, openrouter, lmstudio (keyless)
+export CONTRACT_PROVIDER=anthropic CONTRACT_API_KEY=sk-ant-…  # native Messages API — thinking deltas dropped in transport
+prompt-prompt-contract "帮我写一封请假邮件"
 
 export CONTRACT_PROVIDER=ollama CONTRACT_MODEL=qwen3:4b      # fully local/offline; keep_alive pins the model in RAM
-prompt-contract "帮我写一封请假邮件"
+prompt-prompt-prompt-contract "帮我写一封请假邮件"
 ```
 
 Or write `~/.prompt-contract/config.json` once: `{ "provider": "openai", "baseUrl": "…", "apiKey": "…", "model": "…" }`.
@@ -68,7 +73,7 @@ Community profiles are the main contribution surface — a PR adding `profiles/<
 ## Quality gates — and their honest limits
 
 ```bash
-npm test        # 60 tests: engine units + SSE/ndjson streaming + CLI/MCP e2e against a local mock
+npm test        # 102 tests (serial): engine units + SSE/ndjson streaming + CLI/MCP e2e against a local mock
 npm run eval    # 9 deterministic cases over the six hard-constraint assertions
 npm run eval:tasks -- --format-only  # validate the coding-agent task fixture format gate
 npm run bench   # engine overhead: P50 ≈ 0.005ms (budget < 5ms)
@@ -81,20 +86,20 @@ npm run bench   # engine overhead: P50 ≈ 0.005ms (budget < 5ms)
 ```
 raw input → script/scenario detect → profile + hard constraints + strength (+ optional context)
   → single streaming LLM call (small fast model by default; the model does the thinking)
-  → deterministic cleaning (quotes/fences/length clamp, empty → llm_error)
+  → deterministic cleaning (reasoning-block strip, quotes/fences/length clamp, empty → llm_error)
   → { enhanced, original, meta } — original always preserved, one-key revert in every surface
 ```
 
 ## Status & roadmap — stated honestly
 
-- **Shipped:** engine, CLI (`prompt-contract` / `check` / `doctor` / `profiles` / `spike-0`), MCP server (tool + zero-key prompts), playground, 3 profiles, eval cases, CI matrix.
-- **Gated:** `prompt-contract watch` (global-hotkey resident mode) remains intentionally unavailable. `prompt-contract spike-0` measures macOS capture/clipboard safety and dry-run focus eligibility, but never pastes or unlocks watch by itself; see [docs/SPIKE-0.md](docs/SPIKE-0.md).
+- **Shipped:** engine, CLI (`prompt-contract` / `check` / `doctor` / `profiles` / `spike-0` / `watch`), MCP server (tool + zero-key prompts), playground, 3 profiles, eval cases, CI matrix.
+- **Resident mode:** `prompt-prompt-contract watch` — select text anywhere on macOS, press ⌥B, and the enhanced prompt replaces your selection: clipboard backed up and restored, focus re-validated before pasting, gated by `prompt-prompt-contract spike-0` evidence (decision D7). See [docs/WATCH.md](docs/WATCH.md). `prompt-prompt-contract spike-0` itself remains a dry-run diagnostic and never pastes; see [docs/SPIKE-0.md](docs/SPIKE-0.md).
 - **Open validation:** task-level outcome evaluation remains an evidence-gathering task. The harness and curated fixture set exist, but PromptContract's downstream effectiveness is still a hypothesis until a declared runner produces reviewed results.
 - Deferred: animated demo asset, IDE plugins, LLM-as-judge as *one* scorer inside the task-level eval.
 
 ## Layout
 
-`packages/core` (engine, browser-safe, zero deps) · `packages/providers` (OpenAI-compatible SSE + Ollama `keep_alive`) · `packages/cli` · `packages/mcp-server` · `packages/playground` · `profiles/` · `eval/` · `mock/` · `docs/ACCEPTANCE.md` · `docs/SPIKE-0.md` (requirements → implementation → acceptance + evidence boundaries)
+docs/ACCEPTANCE.md` · `docs/SPIKE-0.md` · `docs/WATCH.md` (requirements → implementation → acceptance + evidence boundaries)
 
 ## Contributing & License
 

package/README.zh-CN.md

@@ -6,7 +6,7 @@
 
 [English](README.md) · 简体中文
 
-![PromptContract——模糊的一句话被编译成结构化任务规范（目标 / 范围 / 验收标准 / 明确不做的事），六条硬规则经 `contract check` 校验。真实 LLM 端到端 P50 2.3s，引擎附加开销 0.005ms。CLI · MCP · Playground——零依赖、BYOK、可离线。](docs/assets/hero-cover.png)
+![PromptContract——模糊的一句话被编译成结构化任务规范（目标 / 范围 / 验收标准 / 明确不做的事），六条硬规则经 `prompt-prompt-contract check` 校验。真实 LLM 端到端 P50 2.3s，引擎附加开销 0.005ms。CLI · MCP · Playground——零依赖、BYOK、可离线。](docs/assets/hero-cover.png)
 
 **PromptContract 是面向 AI 编码 agent 的确定性 prompt 契约层**：把模糊的一句话编译成结构化任务规范（目标 / 范围 / 约束 / 验收标准），并在你看到结果之前用六条硬规则完成校验。
 
@@ -15,7 +15,7 @@
 ## 为什么
 
 - **稳定的 agent 输入**——profile + 硬约束把「帮我做个网站」编译成目标 / 范围 / 验收标准 / 明确不做的事；重试与范围漂移是否减少，仍须由任务级 harness 验证，当前不作产品结论
-- **六条确定性护栏**——语言一致性、只输出增强文本、长度与完整性、扩写而非回答、无幻觉技术栈；`prompt-contract check` 随时可断言，模板与测试共用同一份规格
+- **六条确定性护栏**——语言一致性、只输出增强文本、长度与完整性、扩写而非回答、无幻觉技术栈；`prompt-prompt-contract check` 随时可断言，模板与测试共用同一份规格
 - **一个引擎、三个形态**——CLI、MCP server（agent 调用的 tool + 用户调用的斜杠 prompts）、浏览器 Playground，共享同一个零依赖内核
 - **隐私即架构**——BYOK、无中间服务、零遥测，Ollama 全本地可用
 
@@ -29,16 +29,21 @@ node packages/cli/bin/contract.js "帮我做一个展示我家狗的网站" \
 node packages/playground/serve.js                       # → http://127.0.0.1:8123/（?demo=1 为自运行演示）
 ```
 
-安装：`npm i -g prompt-contract`；或零安装体验：`npx prompt-contract "你的模糊想法"`。
+安装：`npm i -g prompt-contract`；或零安装体验：`npx prompt-prompt-prompt-contract "你的模糊想法"`。
 
 ## 接入真实模型
 
 ```bash
-export CONTRACT_API_KEY=sk-xxx CONTRACT_MODEL=gpt-4o-mini   # 任意 OpenAI 兼容端点（DeepSeek/Qwen/GLM/vLLM…）
-prompt-contract "A website for my dog"
+export CONTRACT_API_KEY=sk-xxx CONTRACT_MODEL=gpt-4o-mini   # 任意 OpenAI 兼容端点（vLLM、OpenRouter、自家网关…）
+prompt-prompt-contract "A website for my dog"
+
+export CONTRACT_PROVIDER=deepseek CONTRACT_API_KEY=sk-…     # 厂商预设：自带 base URL 与建议默认模型
+export CONTRACT_PROVIDER=qwen                                # 另有 glm、moonshot、groq、openrouter、lmstudio（免 key）
+export CONTRACT_PROVIDER=anthropic CONTRACT_API_KEY=sk-ant-… # Anthropic 原生 Messages API——思考增量在传输层即被丢弃
+prompt-prompt-contract "帮我写一封请假邮件"
 
 export CONTRACT_PROVIDER=ollama CONTRACT_MODEL=qwen3:4b     # 全本地；keep_alive 把模型钉在内存
-prompt-contract "帮我写一封请假邮件"
+prompt-prompt-prompt-contract "帮我写一封请假邮件"
 ```
 
 或一次写入 `~/.prompt-contract/config.json`。
@@ -53,7 +58,7 @@ prompt-contract "帮我写一封请假邮件"
 ## 质量门禁与诚实边界
 
 ```bash
-npm test        # 60 项：引擎单测 + SSE/ndjson 流式 + CLI/MCP 端到端（对本地 mock）
+npm test        # 102 项（串行）：引擎单测 + SSE/ndjson 流式 + CLI/MCP 端到端（对本地 mock）
 npm run eval    # 9 个确定性用例（六条硬约束断言）
 npm run eval:tasks -- --format-only  # 校验 coding-agent 任务 fixture 的格式门禁
 npm run bench   # 引擎自身开销 P50 ≈ 0.005ms（预算 <5ms）
@@ -63,8 +68,8 @@ npm run bench   # 引擎自身开销 P50 ≈ 0.005ms（预算 <5ms）
 
 ## 状态与路线图（诚实版）
 
-- **已交付**：引擎、CLI（含 `spike-0`）、MCP server（tool + 零 key prompts）、Playground、3 个 profiles、eval 用例、CI 矩阵
-- **被门控**：`prompt-contract watch`（全局热键常驻）仍不可用。`prompt-contract spike-0` 只测 macOS 取词、剪贴板恢复和焦点校验的 dry-run，不发送粘贴，也不会自行解锁 watch；见 [docs/SPIKE-0.md](docs/SPIKE-0.md)
+- **已交付**：引擎、CLI（含 `prompt-prompt-contract spike-0`、`prompt-prompt-contract watch` 常驻模式）、MCP server（tool + 零 key prompts）、Playground、3 个 profiles、eval 用例、CI 矩阵
+- **常驻模式**：`prompt-prompt-contract watch`——在 macOS 任意应用选中一段粗糙 prompt，按 ⌥B，增强结果原地替换选区：剪贴板先备份后恢复、回贴前焦点复验（漂移即放弃）、以 `prompt-prompt-contract spike-0` 证据为启动门控（决策 D7）；详见 [docs/WATCH.md](docs/WATCH.md)。`prompt-prompt-contract spike-0` 本身仍是 dry-run 诊断，永不发送粘贴；见 [docs/SPIKE-0.md](docs/SPIKE-0.md)
 - **开放验证**：任务级效果评测的 harness 与任务 fixture 已交付，但还没有声明 runner 产生并复核结果；长期价值在此之前仍是假设
 - **推迟**：动画 demo 资产、IDE 插件、LLM-as-judge（作为任务级评测中的评分器之一）
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-contract",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "publishConfig": {
     "access": "public"
   },

package/packages/cli/bin/contract.js

@@ -2,11 +2,13 @@
 /**
  * contract — PromptContract CLI (PRD §4 P0). Physical file kept as contract.js for path stability.
  * One-shot enhance (arg or stdin), profiles, check (rule assertions), doctor.
- * `contract watch` is intentionally gated by decision D7 (Spike-0 first) — see docs/SPIKE-0.md.
+ * One-shot enhance (arg or stdin), profiles, check (rule assertions), doctor,
+ * spike-0 (capture diagnostic), watch (resident hotkey mode — see docs/WATCH.md).
  */
 import { enhance, checkRules, PromptContractError, normalizeError } from '../../core/src/index.js';
 import { loadProfiles, loadProfile, resolveConfig } from '../../core/src/node.js';
 import { createOpenAIProvider } from '../../providers/src/openai.js';
+import { createAnthropicProvider } from '../../providers/src/anthropic.js';
 import { createOllamaProvider } from '../../providers/src/ollama.js';
 import { readFileSync, existsSync, writeFileSync } from 'node:fs';
 import { basename } from 'node:path';
@@ -18,30 +20,32 @@ import {
   resolveSpikeTargets,
   runSpike0,
 } from '../src/spike-0.js';
+import { runWatch } from '../src/watch.js';
 
-// `contract` was the command name before the prompt-contract rename; warn while the alias ships.
+// `prompt-contract` was the command name before the prompt-contract rename; warn while the alias ships.
 if (basename(process.argv[1] || '') === 'contract') {
-  process.stderr.write('[deprecated] this CLI is now `contract` (prompt-contract); the `contract` command will be removed in a future release.\n');
+  process.stderr.write('[deprecated] this CLI is now `prompt-contract` (prompt-contract); the `prompt-contract` command will be removed in a future release.\n');
 }
 
-const VERSION = '0.2.1';
+const VERSION = '0.3.0';
 const USAGE = `prompt-contract — one-key prompt enhancement (PromptContract v${VERSION})
 
 Usage:
-  prompt-contract "build me a website for my dog"     enhance a prompt (prints enhanced text to stdout)
+  prompt-prompt-prompt-contract "build me a website for my dog"     enhance a prompt (prints enhanced text to stdout)
   cat prompt.txt | prompt-contract                    enhance from stdin
-  prompt-contract profiles                            list built-in profiles
-  prompt-contract check --original "..." --enhanced "..."
+  prompt-prompt-contract profiles                            list built-in profiles
+  prompt-prompt-prompt-contract check --original "..." --enhanced "..."
                                          run the six hard-constraint rule assertions
-  prompt-contract doctor                              verify config, provider reachability, profiles
-  prompt-contract spike-0                             macOS-only capture/restore compatibility diagnostic (dry-run)
-  prompt-contract watch                               NOT BUILT — gated by decision D7 (Spike-0 first); see docs/SPIKE-0.md
+  prompt-prompt-contract doctor                              verify config, provider reachability, profiles
+  prompt-prompt-prompt-contract spike-0                             macOS-only capture/restore compatibility diagnostic (dry-run)
+  prompt-prompt-prompt-contract watch                               resident mode: select text → hotkey → enhanced text replaces it (macOS; docs/WATCH.md)
 
 Options:
   -p, --profile <name>     scenario profile (default: coding-agent)
   -s, --strength <mode>    polish | standard (default) | expand
   -m, --model <model>      model override
-      --provider <name>    openai (default) | ollama
+      --provider <name>    openai (default) | anthropic | ollama | vendor presets:
+                           deepseek qwen glm moonshot groq openrouter lmstudio
       --base-url <url>     OpenAI-compatible base URL (or CONTRACT_BASE_URL)
       --api-key <key>      API key (or CONTRACT_API_KEY; local ollama needs none)
       --context <text>     background context to assemble into the prompt
@@ -54,19 +58,30 @@ Options:
       --setup-delay-ms <ms> Spike-0 delay before each target capture
       --no-prompt          Spike-0 do not wait for target/app setup
       --output <path>      write Spike-0 JSON report to a file
+      --hotkey <spec>      watch trigger combo: ctrl=⌃ alt/option=⌥ cmd=⌘ shift=⇧ + key,
+                           e.g. "ctrl+alt+b" = hold ⌃⌥ and press B (default alt+b; persist via "hotkey"
+                           in ~/.prompt-contract/config.json)
+      --trigger <name>     watch trigger source: hotkey (default) | stdin (each Enter = trigger, q quits)
+      --report <path>      Spike-0 JSON report satisfying the watch evidence gate (D7)
+      --force              run watch without Spike-0 evidence (at your own risk)
+      --dry-run            watch: capture + enhance but never paste
+      --paste-delay-ms <ms> watch: wait between ⌘V and clipboard restore (default: 1000)
+      --cooldown-ms <ms>   watch: minimum gap between cycles (default: 800)
       --json               machine-readable output {original, enhanced, meta, rules}
       --no-stream          buffer instead of streaming progress
   -h, --help               show this help`;
 
 function parseArgs(argv) {
   const flags = { _: [] };
-  const needsValue = new Set(['--profile', '-p', '--strength', '-s', '--model', '-m', '--provider', '--base-url', '--api-key', '--context', '--max-chars', '--timeout', '--app', '--iterations', '--settle-ms', '--pause-ms', '--setup-delay-ms', '--output', '--original', '--enhanced']);
+  const needsValue = new Set(['--profile', '-p', '--strength', '-s', '--model', '-m', '--provider', '--base-url', '--api-key', '--context', '--max-chars', '--timeout', '--app', '--iterations', '--settle-ms', '--pause-ms', '--setup-delay-ms', '--output', '--original', '--enhanced', '--hotkey', '--trigger', '--report', '--paste-delay-ms', '--cooldown-ms']);
   const camel = (k) => k.replace(/^--?/, '').replace(/-([a-z])/g, (_, c) => c.toUpperCase());
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === '--json') flags.json = true;
     else if (a === '--no-stream') flags.noStream = true;
     else if (a === '--no-prompt') flags.noPrompt = true;
+    else if (a === '--dry-run') flags.dryRun = true;
+    else if (a === '--force') flags.force = true;
     else if (a === '--help' || a === '-h') flags.help = true;
     else if (a === '--version') flags.version = true;
     else if (needsValue.has(a)) flags[camel(a)] = argv[++i];
@@ -77,9 +92,9 @@ function parseArgs(argv) {
 }
 
 function buildProvider(cfg) {
-  return cfg.provider === 'ollama'
-    ? createOllamaProvider({ baseUrl: cfg.baseUrl })
-    : createOpenAIProvider({ baseUrl: cfg.baseUrl, apiKey: cfg.apiKey });
+  if (cfg.provider === 'ollama') return createOllamaProvider({ baseUrl: cfg.baseUrl });
+  if (cfg.provider === 'anthropic') return createAnthropicProvider({ baseUrl: cfg.baseUrl, apiKey: cfg.apiKey });
+  return createOpenAIProvider({ baseUrl: cfg.baseUrl, apiKey: cfg.apiKey });
 }
 
 function makeProvider(cfg, { warm = false } = {}) {
@@ -133,7 +148,7 @@ async function cmdEnhance(flags) {
     if (!flags.noStream) {
       process.stderr.write(`\n— ${res.meta.profile} · ${res.meta.model} · ${res.meta.ms}ms · ${res.meta.chars} chars\n`);
       if (!rules.pass) {
-        process.stderr.write('rule assertions (advisory — run `contract check` for gate mode):\n');
+        process.stderr.write('rule assertions (advisory — run `prompt-prompt-prompt-contract check` for gate mode):\n');
         for (const r of rules.results.filter((r) => !r.pass)) {
           process.stderr.write(`  [FAIL] ${r.title}${r.detail ? ` — ${r.detail}` : ''}\n`);
         }
@@ -168,7 +183,7 @@ function cmdCheck(flags) {
     }
   }
   if (original === undefined || enhanced === undefined) {
-    process.stderr.write('contract check requires --original and --enhanced (or a JSON {original, enhanced} line on stdin)\n');
+    process.stderr.write('prompt-prompt-contract check requires --original and --enhanced (or a JSON {original, enhanced} line on stdin)\n');
     return 2;
   }
   const rules = checkRules(original, enhanced, { maxChars: flags.maxChars ? parseInt(flags.maxChars, 10) : 800 });
@@ -204,7 +219,7 @@ async function cmdDoctor(flags) {
 
 async function cmdSpike0(flags) {
   if (!isMacOS) {
-    process.stderr.write('contract spike-0 is macOS-only: requires pbpaste, pbcopy, and Accessibility-backed System Events.\n');
+    process.stderr.write('prompt-prompt-contract spike-0 is macOS-only: requires pbpaste, pbcopy, and Accessibility-backed System Events.\n');
     return 2;
   }
 
@@ -216,7 +231,7 @@ async function cmdSpike0(flags) {
   const pauseMs = flags.pauseMs === undefined ? 0 : Number.parseInt(flags.pauseMs, 10);
   const setupDelayMs = flags.setupDelayMs === undefined ? 0 : Number.parseInt(flags.setupDelayMs, 10);
   if (!Number.isInteger(iterations) || iterations < 1 || !Number.isInteger(settleMs) || settleMs < 0 || !Number.isInteger(pauseMs) || pauseMs < 0 || !Number.isInteger(setupDelayMs) || setupDelayMs < 0) {
-    process.stderr.write('contract spike-0 requires non-negative integer --settle-ms/--pause-ms/--setup-delay-ms and positive integer --iterations\n');
+    process.stderr.write('prompt-prompt-contract spike-0 requires non-negative integer --settle-ms/--pause-ms/--setup-delay-ms and positive integer --iterations\n');
     return 2;
   }
 
@@ -237,6 +252,10 @@ async function cmdSpike0(flags) {
   return report.decision.pass ? 0 : 1;
 }
 
+async function cmdWatch(flags) {
+  return runWatch(flags);
+}
+
 async function main() {
   const flags = parseArgs(process.argv.slice(2));
   if (flags.help) { process.stdout.write(USAGE + '\n'); return 0; }
@@ -249,9 +268,7 @@ async function main() {
     case 'check': return cmdCheck(flags);
     case 'doctor': return await cmdDoctor(flags);
     case 'spike-0': return await cmdSpike0(flags);
-    case 'watch':
-      process.stderr.write('contract watch is gated by decision D7: run `contract spike-0` and review its evidence before implementing watch.\nThe watch implementation remains intentionally unavailable in this Spike-0-only change.\n');
-      return 2;
+    case 'watch': return await cmdWatch(flags);
     default:
       // treat unknown first word as prompt text
       flags._.unshift(cmd);

package/packages/cli/src/spike-0.js

@@ -36,6 +36,9 @@ export const APP_TARGETS = Object.freeze({
 });
 
 const COPY_SCRIPT = 'tell application "System Events" to keystroke "c" using {command down}';
+// Used only by prompt-contract watch. The Spike-0 diagnostic itself never issues ⌘V; its
+// safety contract is enforced in captureSelectedText/validatePasteBackDryRun.
+const PASTE_SCRIPT = 'tell application "System Events" to keystroke "v" using {command down}';
 
 // The report deliberately excludes AXValue: it can contain the user's prompt or
 // other sensitive text. These attributes are enough to conservatively detect a
@@ -212,6 +215,12 @@ export function createMacOSAdapter({ run = runCommand } = {}) {
       if (result.code !== 0) throw commandError('osascript-copy', result);
     },
 
+    async pasteSelection() {
+      const result = await run('/usr/bin/osascript', ['-e', PASTE_SCRIPT]);
+      if (result.error) throw result.error;
+      if (result.code !== 0) throw commandError('osascript-paste', result);
+    },
+
     async getFocusIdentity() {
       const result = await run('/usr/bin/osascript', ['-e', CONTEXT_SCRIPT], { timeoutMs: 5000 });
       if (result.error) throw result.error;
@@ -275,7 +284,7 @@ function fingerprintForContext(context) {
   return createHash('sha256').update(fields.join('\u001f')).digest('hex').slice(0, 16);
 }
 
-function sameFocusIdentity(left, right) {
+export function sameFocusIdentity(left, right) {
   if (!left || !right) return false;
   const appStable = normalized(left.processName) === normalized(right.processName)
     && normalized(left.bundleId) === normalized(right.bundleId)
@@ -309,8 +318,17 @@ export async function captureSelectedText(adapter, { settleMs = 75 } = {}) {
     clipboardUntouched = false;
     await adapter.copySelection();
     await adapter.sleep(settleMs);
-    const copiedText = await adapter.readClipboard();
-    selectedText = typeof copiedText === 'string' && copiedText.trim() ? copiedText : null;
+    let copiedText = await adapter.readClipboard();
+    // ⌘C is delivered asynchronously: a read that still shows the pre-copy
+    // clipboard means the copy has not landed — poll briefly instead of
+    // mistaking the stale clipboard for the selection. A read identical to the
+    // pre-copy clipboard after polling reports an empty selection (the
+    // clipboard fallback then covers the intentional selection==clipboard case).
+    for (let polls = 0; copiedText === originalClipboard && polls < 6; polls++) {
+      await adapter.sleep(60);
+      copiedText = await adapter.readClipboard();
+    }
+    selectedText = typeof copiedText === 'string' && copiedText.trim() && copiedText !== originalClipboard ? copiedText : null;
     contextAfterCapture = await adapter.getFocusIdentity();
   } catch (captureError) {
     error = captureError;
@@ -457,7 +475,7 @@ export function buildCompatibilityReport({
       pass: reasons.length === 0,
       reasons,
       watchGate: 'closed',
-      note: 'A dry-run cannot prove actual paste landing; contract watch remains gated until a separate implementation decision.',
+      note: 'A dry-run cannot prove actual paste landing; this report is evidence for prompt-contract watch, never an authorization by itself.',
     },
   };
 }
@@ -575,7 +593,7 @@ export function formatSpike0Summary(report) {
     `capture ${summary.captureSuccesses}/${summary.attempts} (${summary.captureSuccessRate})`,
     `clipboard restore ${summary.clipboardRestoreSuccesses}/${summary.attempts} (${summary.clipboardRestoreSuccessRate})`,
     `dry-run paste-back eligibility ${summary.dryRunPasteBackSuccesses}/${summary.attempts} (${summary.dryRunPasteBackRate})`,
-    report.decision.reasons.length ? `reasons: ${report.decision.reasons.join('; ')}` : 'thresholds met; contract watch remains gated',
+    report.decision.reasons.length ? `reasons: ${report.decision.reasons.join('; ')}` : 'thresholds met; evidence usable by prompt-contract watch',
   ].join('\n');
 }
 

package/packages/cli/src/watch.js

@@ -0,0 +1,609 @@
+/**
+ * prompt-contract watch — resident hotkey mode (PRD §7, Snipaste-style).
+ * Hotkey → capture selection (clipboard fallback) → enhance → focus re-validation → paste back.
+ *
+ * Safety contract (carried over from Spike-0, now with a real paste step):
+ *  - The user's clipboard is snapshotted and restored around every capture and paste.
+ *  - Paste only fires when the foreground/focus identity still matches capture time;
+ *    otherwise the cycle aborts with a notification (fail closed).
+ *  - Evidence gate: `prompt-prompt-contract watch` requires a passing `prompt-prompt-contract spike-0` report (--report) or an
+ *    explicit --force, honoring decision D7. Spike-0 itself never unlocks anything.
+ *  - --dry-run exercises capture + enhance but never issues ⌘V.
+ *
+ * macOS only. The global hotkey comes from a small Swift helper (Carbon
+ * RegisterEventHotKey — needs no Accessibility permission) compiled on first run
+ * from the embedded source below; capture/paste keystrokes still need Accessibility.
+ */
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { readFile as readFileAsync } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { enhance as enhanceCore, PromptContractError } from '../../core/src/index.js';
+import { loadProfile, readUserConfig, resolveConfig } from '../../core/src/node.js';
+import { createOpenAIProvider } from '../../providers/src/openai.js';
+import { createOllamaProvider } from '../../providers/src/ollama.js';
+import {
+  captureSelectedText,
+  createMacOSAdapter,
+  isMacOS,
+  sameFocusIdentity,
+} from './spike-0.js';
+
+export const DEFAULT_WATCH_OPTIONS = Object.freeze({
+  hotkey: 'alt+b',
+  settleMs: 75,
+  // 1000ms between ⌘V and the clipboard restore — measured on a live TextEdit
+  // round-trip: 150ms and 500ms both let the restore beat the target app's
+  // paste read (the document then receives the RESTORED content); 1000ms and
+  // 2500ms passed. The window cuts both ways (a user ⌘C inside it gets
+  // clobbered by the restore), so it is deliberately the tested minimum.
+  pasteDelayMs: 1000,
+  cooldownMs: 800,
+  dryRun: false,
+});
+
+// Carbon key codes (kVK_*) for the keys we accept in --hotkey.
+export const KEY_CODES = Object.freeze({
+  a: 0, s: 1, d: 2, f: 3, h: 4, g: 5, z: 6, x: 7, c: 8, v: 9, b: 11,
+  q: 12, w: 13, e: 14, r: 15, y: 16, t: 17, u: 32, i: 34, o: 31, p: 35,
+  l: 37, j: 38, k: 40, n: 45, m: 46,
+  0: 29, 1: 18, 2: 19, 3: 20, 4: 21, 5: 23, 6: 22, 7: 26, 8: 28, 9: 25,
+  space: 49, return: 36, enter: 36, tab: 48, escape: 53, delete: 51, forwarddelete: 117,
+  '=': 24, '-': 27, '[': 33, ']': 30, ';': 41, "'": 39, ',': 43, '.': 47, '/': 44, '\\': 42, '`': 50,
+  f1: 122, f2: 120, f3: 99, f4: 118, f5: 96, f6: 97, f7: 98, f8: 100, f9: 101,
+  f10: 109, f11: 103, f12: 111,
+});
+
+// Carbon modifier masks (cmdKey/shiftKey/optionKey/controlKey).
+export const MODIFIER_MASKS = Object.freeze({
+  cmd: 1 << 8,
+  shift: 1 << 9,
+  alt: 1 << 11,
+  ctrl: 1 << 12,
+});
+
+const MODIFIER_ALIASES = Object.freeze({
+  cmd: 'cmd', meta: 'cmd', apple: 'cmd',
+  alt: 'alt', option: 'alt',
+  ctrl: 'ctrl', control: 'ctrl',
+  shift: 'shift',
+});
+
+const GLYPHS = Object.freeze({ cmd: '⌘', shift: '⇧', alt: '⌥', ctrl: '⌃' });
+
+export function parseHotkey(spec = DEFAULT_WATCH_OPTIONS.hotkey) {
+  const parts = String(spec).split('+').map((part) => part.trim()).filter(Boolean);
+  if (parts.length < 2) {
+    throw new PromptContractError('config_error', `hotkey "${spec}" must combine a modifier with a key, e.g. alt+b (supported modifiers: cmd, alt/option, ctrl, shift)`);
+  }
+  let modifiers = 0;
+  const labelParts = [];
+  for (const part of parts.slice(0, -1)) {
+    const name = MODIFIER_ALIASES[part.toLowerCase()];
+    if (!name) {
+      throw new PromptContractError('config_error', `unknown hotkey modifier "${part}" (supported: cmd(⌘), alt/option(⌥), ctrl(⌃), shift(⇧))`);
+    }
+    const mask = MODIFIER_MASKS[name];
+    if (modifiers & mask) {
+      throw new PromptContractError('config_error', `duplicate hotkey modifier "${part}"`);
+    }
+    modifiers |= mask;
+    labelParts.push(GLYPHS[name]);
+  }
+  const keyToken = parts[parts.length - 1].toLowerCase();
+  const keyCode = KEY_CODES[keyToken];
+  if (keyCode === undefined) {
+    throw new PromptContractError('config_error', `unknown hotkey key "${parts[parts.length - 1]}" (supported: a-z, 0-9, space, return, tab, escape, delete, f1-f12, -=[];',./\\)`);
+  }
+  const keyLabel = keyToken.length === 1 ? keyToken.toUpperCase() : keyToken.charAt(0).toUpperCase() + keyToken.slice(1);
+  return { keyCode, modifiers, label: labelParts.join('') + keyLabel };
+}
+
+/**
+ * Trigger precedence: --hotkey flag > "hotkey" in ~/.prompt-contract/config.json > default.
+ * The hotkey is pressed deliberately, so everyday ⌘C copies never trigger anything;
+ * ⌘C is only sent synthetically after the trigger fires.
+ */
+export function resolveWatchHotkey(flags = {}, config = {}) {
+  return String(flags.hotkey ?? config.hotkey ?? DEFAULT_WATCH_OPTIONS.hotkey);
+}
+
+/**
+ * D7 evidence gate: a passing Spike-0 compatibility report, or an explicit --force.
+ */
+export async function evaluateWatchGate({ force = false, reportPath, readFile } = {}) {
+  if (force) return { ok: true, mode: 'forced' };
+  if (!reportPath) {
+    return { ok: false, reason: 'no Spike-0 evidence provided' };
+  }
+  let raw;
+  try {
+    raw = await readFile(reportPath, 'utf8');
+  } catch (err) {
+    return { ok: false, reason: `cannot read report ${reportPath}: ${err.code || err.message}` };
+  }
+  let report;
+  try {
+    report = JSON.parse(raw);
+  } catch {
+    return { ok: false, reason: `report ${reportPath} is not valid JSON` };
+  }
+  if (report?.schemaVersion !== 'prompt-contract/spike-0.v1' || report?.kind !== 'compatibility-report') {
+    return { ok: false, reason: `${reportPath} is not a Spike-0 compatibility report (schemaVersion/kind mismatch)` };
+  }
+  if (report.decision?.pass !== true) {
+    const reasons = Array.isArray(report.decision?.reasons) && report.decision.reasons.length
+      ? report.decision.reasons.join('; ')
+      : 'decision.pass is false';
+    return { ok: false, reason: `Spike-0 report did not pass: ${reasons}` };
+  }
+  return { ok: true, mode: 'report', report };
+}
+
+/**
+ * Read-only startup probe: proves clipboard access and the Accessibility-backed
+ * focus query work before watch goes resident. Never writes the clipboard.
+ */
+export async function probeCaptureSafety(adapter) {
+  const warnings = [];
+  try {
+    await adapter.readClipboard();
+  } catch (err) {
+    return { ok: false, error: `clipboard read failed: ${err.message}` };
+  }
+  try {
+    await adapter.checkClipboardRestorable();
+  } catch (err) {
+    warnings.push(`current clipboard is not text-only (${err.message}); capture refuses to run while rich content is on the pasteboard`);
+  }
+  try {
+    await adapter.getFocusIdentity();
+  } catch (err) {
+    return { ok: false, error: `focus query failed: ${err.message} — grant Accessibility to your terminal under System Settings → Privacy & Security → Accessibility` };
+  }
+  return { ok: true, warnings };
+}
+
+/**
+ * The resident loop. Pure logic: every side effect (capture, enhance, paste,
+ * notify) is injected or goes through the adapter, so tests drive it with fakes.
+ */
+export function createWatchService({
+  adapter,
+  enhance,
+  options = {},
+  notify = async () => {},
+  log = () => {},
+  now = () => Date.now(),
+} = {}) {
+  const opts = { ...DEFAULT_WATCH_OPTIONS, ...options };
+  let busy = false;
+  let lastCycleEnd = -Infinity;
+
+  async function pasteBack(enhancedText) {
+    // Snapshot whatever is on the clipboard right now (the user may have copied
+    // something while the model was thinking); restore it after the paste lands.
+    let saved = null;
+    let restorable = false;
+    try {
+      saved = await adapter.readClipboard();
+      await adapter.checkClipboardRestorable();
+      restorable = true;
+    } catch {
+      restorable = false;
+    }
+    await adapter.writeClipboard(enhancedText);
+    await adapter.pasteSelection();
+    if (opts.pasteDelayMs > 0) await adapter.sleep(opts.pasteDelayMs);
+    if (restorable) {
+      await adapter.writeClipboard(saved);
+      const restored = await adapter.readClipboard();
+      if (restored !== saved) log('watch: clipboard restore could not be verified');
+    } else {
+      log('watch: clipboard held non-text content; it was not preserved across the paste');
+    }
+  }
+
+  async function handleTrigger() {
+    if (busy) {
+      log('watch: busy — trigger ignored (D8: no queueing on the hotkey path)');
+      return;
+    }
+    if (now() - lastCycleEnd < opts.cooldownMs) {
+      log('watch: cooldown — trigger ignored');
+      return;
+    }
+    busy = true;
+    try {
+      const capture = await captureSelectedText(adapter, { settleMs: opts.settleMs });
+      if (capture.error) {
+        await notify({ title: 'PromptContract watch', message: `capture failed: ${capture.error}` });
+        return;
+      }
+      let text = capture.selectedText;
+      let source = 'selection';
+      if (!text) {
+        // PRD §7.3: with nothing selected, fall back to the clipboard content
+        // (captureSelectedText has already restored the pre-capture clipboard).
+        const clip = await adapter.readClipboard();
+        if (typeof clip === 'string' && clip.trim()) {
+          text = clip;
+          source = 'clipboard';
+        }
+      }
+      if (!text) {
+        await notify({ title: 'PromptContract watch', message: 'No selected text and an empty clipboard — select text first.' });
+        return;
+      }
+      log(`watch: captured ${text.length} chars from ${source}`);
+      const res = await enhance(text);
+      log(`watch: enhanced ${text.length} → ${res.text.length} chars · ${res.meta?.model ?? 'model'} · ${res.meta?.ms ?? '?'}ms`);
+      if (opts.dryRun) {
+        log('watch: dry-run — nothing pasted, clipboard untouched. Enhanced text:');
+        log(res.text);
+        return;
+      }
+      if (!capture.contextBefore) {
+        await notify({ title: 'PromptContract watch', message: 'Focus identity unavailable at capture time — paste aborted.' });
+        return;
+      }
+      const focusNow = await adapter.getFocusIdentity();
+      if (!sameFocusIdentity(capture.contextBefore, focusNow)) {
+        await notify({
+          title: 'PromptContract watch',
+          message: `Focus moved to ${focusNow?.processName ?? 'another app'}; return to ${capture.contextBefore.processName} and press the hotkey again.`,
+        });
+        log('watch: focus drift detected — paste aborted (fail closed)');
+        return;
+      }
+      await pasteBack(res.text);
+      log('watch: pasted enhanced text');
+    } catch (err) {
+      await notify({ title: 'PromptContract watch', message: `error: ${err.code || ''} ${err.message}`.trim() });
+      log(`watch: cycle failed: ${err.code || ''} ${err.message}`.trim());
+    } finally {
+      lastCycleEnd = now();
+      busy = false;
+    }
+  }
+
+  return {
+    handleTrigger,
+    stop: () => { busy = false; },
+    isBusy: () => busy,
+  };
+}
+
+// Swift helper: registers one global hotkey via Carbon and prints a line-based
+// protocol on stdout. Kept interpolation-free so it can live in a JS template
+// literal. Compiled on demand to the cache dir; source is embedded here so the
+// compiled binary is always reproducible from this audited file.
+export const HELPER_SOURCE = `import AppKit
+import Carbon.HIToolbox
+import Foundation
+
+// pb hotkey helper — embedded in packages/cli/src/watch.js; audit changes there.
+// argv: <keyCode> <modifierMask>. Prints READY, then one TRIGGER line per press.
+let args = CommandLine.arguments
+guard args.count >= 3, let keyCode = UInt32(args[1]), let modifiers = UInt32(args[2]) else {
+    fputs("usage: pb-hotkey-helper <keyCode> <modifierMask>\\n", stderr)
+    exit(2)
+}
+
+let signature = OSType(0x5042_484B) // 'PBHK'
+var hotKeyID = EventHotKeyID(signature: signature, id: 1)
+var hotKeyRef: EventHotKeyRef?
+var eventType = EventTypeSpec(eventClass: OSType(kEventClassKeyboard), eventKind: UInt32(kEventHotKeyPressed))
+
+func hotKeyHandler(_ callRef: EventHandlerCallRef?, _ event: EventRef?, _ data: UnsafeMutableRawPointer?) -> OSStatus {
+    var id = EventHotKeyID()
+    let status = GetEventParameter(event, EventParamName(kEventParamDirectObject), EventParamType(typeEventHotKeyID), nil, MemoryLayout<EventHotKeyID>.size, nil, &id)
+    if status == noErr && id.signature == signature && id.id == 1 {
+        fputs("TRIGGER\\n", stdout)
+        fflush(stdout)
+    }
+    return status
+}
+
+let installStatus = InstallEventHandler(GetApplicationEventTarget(), hotKeyHandler, 1, &eventType, nil, nil)
+let registerStatus = RegisterEventHotKey(keyCode, modifiers, hotKeyID, GetApplicationEventTarget(), 0, &hotKeyRef)
+if installStatus != noErr || registerStatus != noErr {
+    fputs("hotkey registration failed\\n", stderr)
+    exit(1)
+}
+
+let app = NSApplication.shared
+app.setActivationPolicy(.accessory) // invisible resident: no Dock icon, no window
+fputs("READY\\n", stdout)
+fflush(stdout)
+app.run()
+`;
+
+export function defaultCacheDir() {
+  return process.env.CONTRACT_CACHE_DIR || join(homedir(), '.cache', 'prompt-boost');
+}
+
+function runProcess(child, { timeoutMs = 120000 } = {}) {
+  return new Promise((resolve) => {
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGTERM');
+    }, timeoutMs);
+    child.stdout?.setEncoding('utf8');
+    child.stderr?.setEncoding('utf8');
+    child.stdout?.on('data', (chunk) => { stdout += chunk; });
+    child.stderr?.on('data', (chunk) => { stderr += chunk; });
+    child.on('error', (error) => {
+      clearTimeout(timer);
+      resolve({ code: null, stdout, stderr, error });
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      resolve({ code, stdout, stderr, timedOut });
+    });
+  });
+}
+
+async function ensureHelperBinary({ cacheDir, spawnFn = spawn, log = () => {} }) {
+  const hash = createHash('sha256').update(HELPER_SOURCE).digest('hex').slice(0, 12);
+  const binPath = join(cacheDir, `pb-hotkey-helper-${hash}`);
+  if (existsSync(binPath)) return binPath;
+  mkdirSync(cacheDir, { recursive: true });
+  const srcPath = `${binPath}.swift`;
+  // HELPER_SOURCE is written verbatim: its \n sequences are Swift string
+  // escapes and must reach the compiler untouched.
+  writeFileSync(srcPath, HELPER_SOURCE, 'utf8');
+  log('watch: compiling global-hotkey helper (one-time, up to ~30s, needs the Xcode Command Line Tools)…');
+  const result = await runProcess(spawnFn('swiftc', ['-O', srcPath, '-o', binPath], { stdio: ['ignore', 'pipe', 'pipe'] }), { timeoutMs: 180000 });
+  if (result.error || result.code !== 0) {
+    const detail = String(result.stderr || result.error?.message || '').trim().split('\n').slice(0, 5).join('\n');
+    const error = new Error(`failed to compile the hotkey helper (swiftc${result.timedOut ? ' timed out' : ` exited ${result.code ?? 'n/a'}`}). Is the Xcode Command Line Tools installed (xcode-select --install)?\n${detail}`);
+    error.code = 'hotkey_helper_compile_failed';
+    throw error;
+  }
+  log('watch: helper compiled');
+  return binPath;
+}
+
+/**
+ * Global hotkey via the Swift helper. Registration itself needs no permission;
+ * only the later ⌘C/⌘V keystrokes require Accessibility.
+ */
+export function createSwiftHotkeySource({
+  hotkeySpec = DEFAULT_WATCH_OPTIONS.hotkey,
+  cacheDir = defaultCacheDir(),
+  spawnFn = spawn,
+  readyTimeoutMs = 30000,
+  log = () => {},
+} = {}) {
+  let child = null;
+  let triggerCb = null;
+  let exitCb = null;
+  let stopped = false;
+
+  async function start() {
+    const { keyCode, modifiers, label } = parseHotkey(hotkeySpec);
+    const binPath = await ensureHelperBinary({ cacheDir, spawnFn, log });
+    child = spawnFn(binPath, [String(keyCode), String(modifiers)], { stdio: ['ignore', 'pipe', 'pipe'] });
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    const ready = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error(`hotkey helper not READY within ${readyTimeoutMs}ms`)), readyTimeoutMs);
+      let readySeen = false;
+      const onLine = (line) => {
+        if (line === 'READY' && !readySeen) {
+          readySeen = true;
+          clearTimeout(timer);
+          resolve(label);
+        } else if (line === 'TRIGGER') {
+          triggerCb?.();
+        } else if (line) {
+          log(`watch helper: ${line}`);
+        }
+      };
+      createInterface({ input: child.stdout }).on('line', onLine);
+      createInterface({ input: child.stderr }).on('line', (line) => { if (line) log(`watch helper: ${line}`); });
+      child.on('error', (err) => { clearTimeout(timer); reject(err); });
+      child.on('close', (code) => {
+        clearTimeout(timer);
+        if (!readySeen) reject(new Error(`hotkey helper exited before READY (code ${code})`));
+        else exitCb?.({ code, clean: stopped });
+      });
+    });
+    return ready;
+  }
+
+  return {
+    start,
+    label: parseHotkey(hotkeySpec).label,
+    onTrigger: (cb) => { triggerCb = cb; },
+    onExit: (cb) => { exitCb = cb; },
+    async stop() {
+      stopped = true;
+      if (!child || child.exitCode !== null) return;
+      child.kill('SIGTERM');
+      await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          try { child.kill('SIGKILL'); } catch { /* already gone */ }
+          resolve();
+        }, 2000);
+        child.on('close', () => { clearTimeout(timer); resolve(); });
+      });
+    },
+    get running() { return !stopped && child && child.exitCode === null; },
+  };
+}
+
+/**
+ * Portable fallback trigger (any platform): each Enter on stdin fires the
+ * cycle; the line "q" quits. Useful without a desktop session or for manual testing.
+ */
+export function createStdinTriggerSource({ input = process.stdin, log = () => {} } = {}) {
+  let triggerCb = null;
+  let exitCb = null;
+  let rl = null;
+  return {
+    label: 'Enter',
+    onTrigger: (cb) => { triggerCb = cb; },
+    onExit: (cb) => { exitCb = cb; },
+    async start() {
+      rl = createInterface({ input });
+      rl.on('line', (line) => {
+        const trimmed = line.trim().toLowerCase();
+        if (trimmed === 'q') {
+          rl.close();
+          return;
+        }
+        triggerCb?.();
+      });
+      rl.on('close', () => exitCb?.({ code: 0, clean: true }));
+      return 'Enter';
+    },
+    async stop() {
+      rl?.close();
+    },
+    get running() { return Boolean(rl); },
+    log,
+  };
+}
+
+function buildProvider(cfg) {
+  return cfg.provider === 'ollama'
+    ? createOllamaProvider({ baseUrl: cfg.baseUrl })
+    : createOpenAIProvider({ baseUrl: cfg.baseUrl, apiKey: cfg.apiKey });
+}
+
+async function defaultNotify({ title, message }) {
+  const escaped = String(message).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const escapedTitle = String(title).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  await runProcess(spawn('/usr/bin/osascript', ['-e', `display notification "${escaped}" with title "${escapedTitle}"`], { stdio: ['ignore', 'ignore', 'pipe'] }), { timeoutMs: 5000 });
+}
+
+/**
+ * `prompt-prompt-contract watch` entry point. Deps are injectable for tests; flags come from contract.js parseArgs.
+ */
+export async function runWatch(flags = {}, deps = {}) {
+  const {
+    isMacOSPlatform = isMacOS,
+    adapter = null,
+    enhance = null,
+    source = null,
+    notify = defaultNotify,
+    log = (message) => process.stderr.write(`${message}\n`),
+    readFile = readFileAsync,
+    config = null,
+    registerSignals = true,
+    processRef = process,
+  } = deps;
+
+  if (!isMacOSPlatform) {
+    log('prompt-contract watch is macOS-only: it drives ⌘C/⌘V through System Events and needs the macOS clipboard. See docs/WATCH.md for the platform matrix.');
+    return 2;
+  }
+
+  const gate = await evaluateWatchGate({
+    force: Boolean(flags.force),
+    reportPath: flags.report,
+    readFile,
+  });
+  if (!gate.ok) {
+    log(`prompt-prompt-contract watch refused to start (decision D7 evidence gate): ${gate.reason}
+Watch pastes over your selection, so it runs only with measured evidence. Either:
+  - run  prompt-contract spike-0 --json --output ~/.cache/prompt-contract/spike-0.json  first, then
+        prompt-contract watch --report ~/.cache/prompt-contract/spike-0.json
+  - or pass --force to accept the risk without evidence.`);
+    return 2;
+  }
+
+  // Fail fast on a bad hotkey before touching the clipboard or going resident.
+  const hotkeySpec = resolveWatchHotkey(flags, config ?? readUserConfig(flags.configPath));
+  try {
+    parseHotkey(hotkeySpec);
+  } catch (err) {
+    log(`prompt-prompt-contract watch: ${err.message}
+Fix it with --hotkey <spec> or the "hotkey" field in ~/.prompt-contract/config.json (e.g. "hotkey": "ctrl+alt+b").`);
+    return 2;
+  }
+
+  const macAdapter = adapter ?? createMacOSAdapter();
+  const probe = await probeCaptureSafety(macAdapter);
+  if (!probe.ok) {
+    log(`prompt-prompt-contract watch startup probe failed: ${probe.error}`);
+    return 2;
+  }
+  for (const warning of probe.warnings) log(`watch: warning — ${warning}`);
+
+  // D8 low-latency charter: load config/profile and warm the provider once at
+  // startup; the hotkey path below is pure async with no further initialization.
+  // (Skipped when a test injects enhance directly.)
+  let enhanceFn = enhance;
+  let cfg = null;
+  if (!enhanceFn) {
+    const profile = loadProfile(flags.profile || 'coding-agent');
+    cfg = resolveConfig(flags);
+    const provider = buildProvider(cfg);
+    provider.warmup?.({ model: cfg.model });
+    enhanceFn = (text) => enhanceCore(text, {
+      profile,
+      provider,
+      model: cfg.model,
+      strength: flags.strength,
+      context: flags.context,
+      maxChars: flags.maxChars ? parseInt(flags.maxChars, 10) : undefined,
+      timeoutMs: flags.timeout ? parseInt(flags.timeout, 10) : undefined,
+    });
+  }
+
+  const triggerSource = source ?? (flags.trigger === 'stdin'
+    ? createStdinTriggerSource({ log })
+    : createSwiftHotkeySource({ hotkeySpec, log }));
+
+  const service = createWatchService({
+    adapter: macAdapter,
+    enhance: enhanceFn,
+    options: {
+      settleMs: flags.settleMs !== undefined ? parseInt(flags.settleMs, 10) : undefined,
+      pasteDelayMs: flags.pasteDelayMs !== undefined ? parseInt(flags.pasteDelayMs, 10) : undefined,
+      cooldownMs: flags.cooldownMs !== undefined ? parseInt(flags.cooldownMs, 10) : undefined,
+      dryRun: Boolean(flags.dryRun),
+    },
+    notify,
+    log,
+  });
+
+  let stopReason = null;
+  const stopped = new Promise((resolve) => {
+    triggerSource.onTrigger(() => { service.handleTrigger(); });
+    // Sources classify their own exit: { clean: true } for a shutdown we (or
+    // the user via `q`) initiated, { clean: false } for a crash.
+    triggerSource.onExit((info) => {
+      if (info?.clean === false) stopReason = stopReason ?? `trigger source exited (code ${info?.code ?? '?'})`;
+      resolve();
+    });
+    if (registerSignals) {
+      const shutdown = () => { stopReason = stopReason ?? 'interrupted'; resolve(); };
+      processRef.once?.('SIGINT', shutdown);
+      processRef.once?.('SIGTERM', shutdown);
+    }
+  });
+
+  const label = await triggerSource.start();
+  const profileName = flags.profile || 'coding-agent';
+  const providerLabel = cfg ? `${cfg.provider} model=${cfg.model}` : 'injected enhance fn';
+  const suffix = flags.dryRun ? ' · DRY-RUN (never pastes)' : '';
+  const usingStdin = !source && flags.trigger === 'stdin';
+  const triggerDesc = usingStdin ? label : `${label}  [${hotkeySpec}]`;
+  log(`prompt-prompt-contract watch resident — ${triggerDesc} enhances the selection · profile=${profileName} provider=${providerLabel}${suffix}
+Ctrl+C to quit. Paste replaces the selected text; the clipboard is restored afterwards. See docs/WATCH.md.`);
+
+  await stopped;
+  await triggerSource.stop();
+  log(`watch: stopped${stopReason ? ` — ${stopReason}` : ''}`);
+  return stopReason && /exited/.test(stopReason) ? 1 : 0;
+}

package/packages/core/src/clean.js

@@ -11,6 +11,28 @@ const QUOTE_PAIRS = [
   ['\u300c', '\u300d']  // 「 」
 ];
 
+/**
+ * Strip reasoning-model blocks (<think>/<thinking>/<reasoning>/<thought>) so chain-of-thought
+ * from models like DeepSeek-R1, Qwen3-thinking, or Hermes never reaches a user surface
+ * (critical for prompt-prompt-contract watch: the cleaned text is pasted into the user's document).
+ * A reasoning tag opened but never closed is cut to end-of-text (truncated streams).
+ */
+const REASONING_TAGS = ['think', 'thinking', 'reasoning', 'thought'];
+
+export function stripReasoningBlocks(t) {
+  let prev;
+  do {
+    prev = t;
+    for (const tag of REASONING_TAGS) {
+      const tagPattern = new RegExp(`<${tag}>[\\s\\S]*?</${tag}>`, 'gi');
+      t = t.replace(tagPattern, '');
+      const openPattern = new RegExp(`<${tag}>[\\s\\S]*$`, 'i');
+      t = t.replace(openPattern, '');
+    }
+  } while (t !== prev);
+  return t;
+}
+
 /** Remove wrapping quote pairs, repeatedly (WorkBuddy stripWrappingQuotes, generalized). */
 export function stripWrappingQuotes(t) {
   let prev;
@@ -50,6 +72,7 @@ export function clampChars(t, maxChars) {
 
 export function postprocess(raw, maxChars) {
   let t = String(raw ?? '');
+  t = stripReasoningBlocks(t);
   t = stripFences(t);
   t = stripWrappingQuotes(t);
   t = t.trim();

package/packages/core/src/node.js

@@ -55,24 +55,48 @@ export function loadProfile(name, explicitDir) {
 }
 
 /**
- * Config resolution order: explicit flags > env (PB_*) > config file (CONTRACT_CONFIG or ~/.prompt-contract/config.json).
+ * Vendor presets — convenience sugar over the OpenAI-compatible protocol (openai.js already
+ * speaks it): `"provider": "deepseek"` resolves the known base URL and a suggested default
+ * small/fast model. Explicit flags/env/config always win over preset values. Model ids are
+ * best-effort defaults maintained per vendor naming and can always be overridden with
+ * CONTRACT_MODEL/--model; presets deliberately stay a data table, not an SDK dependency.
+ */
+export const PROVIDER_PRESETS = Object.freeze({
+  deepseek: { baseUrl: 'https://api.deepseek.com/v1', model: 'deepseek-chat' },
+  qwen: { baseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1', model: 'qwen-plus' },
+  glm: { baseUrl: 'https://open.bigmodel.cn/api/paas/v4', model: 'glm-4-flash' },
+  moonshot: { baseUrl: 'https://api.moonshot.cn/v1', model: 'kimi-k2-turbo-preview' },
+  groq: { baseUrl: 'https://api.groq.com/openai/v1', model: 'llama-3.3-70b-versatile' },
+  openrouter: { baseUrl: 'https://openrouter.ai/api/v1', model: 'openai/gpt-4o-mini' },
+  lmstudio: { baseUrl: 'http://127.0.0.1:1234/v1', keyless: true },
+  anthropic: { baseUrl: 'https://api.anthropic.com', model: 'claude-haiku-4-5' },
+});
+
+/**
+ * Config resolution order: explicit flags > env (CONTRACT_*) > config file (CONTRACT_CONFIG or ~/.prompt-contract/config.json).
  * Defaults follow PRD §3.2: local Ollama if nothing else is configured (privacy-first).
  * `flags.configPath` / `CONTRACT_CONFIG` exist so tests and embedded shells can isolate the file source.
  */
-export function resolveConfig(flags = {}) {
-  const cfgPath = flags.configPath ?? process.env.CONTRACT_CONFIG ?? join(homedir(), '.prompt-contract', 'config.json');
+export function readUserConfig(configPath) {
+  const cfgPath = configPath ?? process.env.CONTRACT_CONFIG ?? join(homedir(), '.prompt-contract', 'config.json');
   let file = {};
   try {
     if (existsSync(cfgPath)) file = JSON.parse(readFileSync(cfgPath, 'utf8'));
   } catch (err) {
     throw new PromptContractError(CODES.CONFIG, `invalid config at ${cfgPath}: ${err.message}`);
   }
+  return file;
+}
+
+export function resolveConfig(flags = {}) {
+  const file = readUserConfig(flags.configPath);
   const pick = (...sources) => { for (const s of sources) if (s !== undefined && s !== null && s !== '') return s; return undefined; };
 
   const provider = pick(flags.provider, process.env.CONTRACT_PROVIDER, file.provider, guessProvider(flags.baseUrl ?? process.env.CONTRACT_BASE_URL ?? file.baseUrl), 'openai');
-  const baseUrl = String(pick(flags.baseUrl, process.env.CONTRACT_BASE_URL, file.baseUrl, provider === 'ollama' ? 'http://localhost:11434' : 'https://api.openai.com/v1')).replace(/\/+$/, '');
-  const apiKey = pick(flags.apiKey, process.env.CONTRACT_API_KEY, file.apiKey, provider === 'ollama' ? 'ollama' : undefined);
-  const model = pick(flags.model, process.env.CONTRACT_MODEL, file.model, provider === 'ollama' ? 'qwen3:4b' : 'gpt-4o-mini');
+  const preset = PROVIDER_PRESETS[provider];
+  const baseUrl = String(pick(flags.baseUrl, process.env.CONTRACT_BASE_URL, file.baseUrl, preset?.baseUrl, provider === 'ollama' ? 'http://localhost:11434' : 'https://api.openai.com/v1')).replace(/\/+$/, '');
+  const apiKey = pick(flags.apiKey, process.env.CONTRACT_API_KEY, file.apiKey, preset?.keyless ? 'not-needed' : undefined, provider === 'ollama' ? 'ollama' : undefined);
+  const model = pick(flags.model, process.env.CONTRACT_MODEL, file.model, preset?.model, provider === 'ollama' ? 'qwen3:4b' : 'gpt-4o-mini');
   if (!apiKey) throw new PromptContractError(CODES.CONFIG, `no API key: set CONTRACT_API_KEY, --api-key, or ~/.prompt-contract/config.json (or use --provider ollama)`);
   return { provider, baseUrl, apiKey, model };
 }

package/packages/core/src/rules.js

@@ -1,6 +1,6 @@
 /**
  * The six hard constraints from the PRD appendix, as deterministic rule assertions.
- * Same spec drives three surfaces: `contract check` (CLI), playground badges, eval runner —
+ * Same spec drives three surfaces: `prompt-prompt-prompt-contract check` (CLI), playground badges, eval runner —
  * template and evaluation share one source of truth (PRD: 模板与评测共用同一份规格).
  *
  * Known heuristic limits (do not oversell — see docs/ACCEPTANCE.md "Evidence boundaries"):

package/packages/mcp-server/src/server.js

@@ -10,6 +10,7 @@
 import { enhance, hardConstraints, STRENGTHS, PromptContractError, normalizeError } from '../../core/src/index.js';
 import { loadProfiles, loadProfile, resolveConfig } from '../../core/src/node.js';
 import { createOpenAIProvider } from '../../providers/src/openai.js';
+import { createAnthropicProvider } from '../../providers/src/anthropic.js';
 import { createOllamaProvider } from '../../providers/src/ollama.js';
 
 const SERVER_INFO = { name: 'prompt-contract', version: '0.1.0' };
@@ -131,7 +132,9 @@ export async function serve({ stdin = process.stdin, stdout = process.stdout, st
     const config = resolveConfig({ provider: flag('--provider'), baseUrl: flag('--base-url'), apiKey: flag('--api-key'), model: flag('--model'), configPath: flag('--config') });
     const provider = config.provider === 'ollama'
       ? createOllamaProvider({ baseUrl: config.baseUrl })
-      : createOpenAIProvider({ baseUrl: config.baseUrl, apiKey: config.apiKey });
+      : config.provider === 'anthropic'
+        ? createAnthropicProvider({ baseUrl: config.baseUrl, apiKey: config.apiKey })
+        : createOpenAIProvider({ baseUrl: config.baseUrl, apiKey: config.apiKey });
     provider.warmup({ model: config.model }).catch(() => {}); // §7.6-1: prewarm, best effort
     runtime = { config, provider };
     return runtime;

package/packages/providers/src/anthropic.js

@@ -0,0 +1,84 @@
+/**
+ * Anthropic provider — native Messages API (SSE). The one protocol family the OpenAI-compatible
+ * adapter cannot cover: different auth header (x-api-key), separate `system` parameter, and
+ * content_block_delta events. Reasoning deltas (thinking_delta) are dropped at the transport
+ * layer; any <think>…</think> that still lands inside text is stripped later by core/clean.js.
+ */
+import { PromptContractError } from '../../core/src/errors.js';
+import { withTimeout } from './openai.js';
+
+export const ANTHROPIC_VERSION = '2023-06-01';
+
+export function createAnthropicProvider({ baseUrl = 'https://api.anthropic.com', apiKey = '', version = ANTHROPIC_VERSION, fetchImpl = globalThis.fetch } = {}) {
+  const root = String(baseUrl).replace(/\/+$/, '');
+  const headers = { 'content-type': 'application/json', 'x-api-key': apiKey, 'anthropic-version': version };
+  return {
+    name: 'anthropic',
+    /** Best-effort connection open (PRD §7.6-1); /v1/models exists but a miss never blocks a request. */
+    async warmup({ signal } = {}) {
+      try { await fetchImpl(`${root}/v1/models`, { headers, signal }); } catch { /* best effort */ }
+    },
+    async complete({ system, user, model, signal, onDelta, maxTokens = 1024, timeoutMs = 30000, temperature = 0.7 }) {
+      const { signal: fullSignal, cleanup } = withTimeout(signal, timeoutMs);
+      let res;
+      try {
+        res = await fetchImpl(`${root}/v1/messages`, {
+          method: 'POST',
+          signal: fullSignal,
+          headers,
+          body: JSON.stringify({
+            model,
+            stream: true,
+            // Anthropic requires max_tokens — pipeline derives it from the profile's maxChars.
+            max_tokens: maxTokens,
+            temperature,
+            system,
+            messages: [{ role: 'user', content: user }]
+          })
+        });
+      } catch (err) {
+        cleanup();
+        throw err; // pipeline normalizes AbortError / network errors
+      }
+      if (!res.ok) {
+        cleanup();
+        let detail = '';
+        try { detail = (await res.text()).slice(0, 300); } catch { /* body unreadable */ }
+        throw new PromptContractError('provider_unavailable', `anthropic HTTP ${res.status}${detail ? `: ${detail}` : ''}`);
+      }
+      let text = '';
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+      try {
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          let nl;
+          while ((nl = buffer.indexOf('\n')) >= 0) {
+            const line = buffer.slice(0, nl).trim();
+            buffer = buffer.slice(nl + 1);
+            if (!line.startsWith('data:')) continue;
+            const data = line.slice(5).trim();
+            if (!data) continue;
+            let json;
+            try { json = JSON.parse(data); } catch { continue; }
+            if (json.type === 'error') {
+              throw new PromptContractError('provider_unavailable', `anthropic stream error: ${json.error?.message ?? 'unknown'}`);
+            }
+            // Only text deltas are answer content; thinking_delta / signature deltas are dropped here.
+            if (json.type === 'content_block_delta' && json.delta?.type === 'text_delta' && json.delta.text) {
+              text += json.delta.text;
+              if (onDelta) onDelta(json.delta.text);
+            }
+            if (json.type === 'message_stop') return { text };
+          }
+        }
+      } finally {
+        cleanup();
+      }
+      return { text };
+    }
+  };
+}

package/packages/providers/src/openai.js

@@ -4,8 +4,9 @@
  */
 import { PromptContractError } from '../../core/src/errors.js';
 
-/** Combine caller signal + internal timeout. Caller abort must always stay effective (ADR-017). */
-function withTimeout(signal, timeoutMs) {
+/** Combine caller signal + internal timeout. Caller abort must always stay effective (ADR-017).
+ *  Shared by the anthropic provider (same streaming-shape needs). */
+export function withTimeout(signal, timeoutMs) {
   const timeoutCtrl = new AbortController();
   const timer = timeoutMs
     ? setTimeout(() => timeoutCtrl.abort(new DOMException('timeout', 'TimeoutError')), timeoutMs)