feat(agent): add windsurf as an install target

Windsurf (Cascade) is a widely-used AI editor that reads workspace rules
from `.windsurf/rules/*.md`. Add it as an own-file agent target so
`testsprite agent install --target windsurf` (and `setup --agent windsurf`)
wires the verification-loop skill into a Windsurf project.

The rule file uses Cascade's YAML frontmatter with `trigger: model_decision`
— the equivalent of the Cursor `.mdc` `alwaysApply: false` mode: only the
`description` is surfaced up front and Cascade pulls in the full body when it
is relevant, which matches how this skill should activate. (Cascade's other
triggers are `always_on`, `manual`, and `glob`.) The skill is well within
Windsurf's 12 KB per-rule budget.

The new target flows through the existing machinery automatically — the
`agent list` table, the `setup --agent` choices, and the skill-nudge install
detection all derive from the TARGETS map. Updated the hardcoded help strings
in `agent.ts`, the help snapshot, the agent-targets tests (including a
render test asserting the Cascade frontmatter), the dynamic agent.test.ts
fixtures, and the README/DOCUMENTATION target lists.

Author: Davidson3556

DOCUMENTATION.md

@@ -112,11 +112,12 @@ testsprite agent install claude     # install the skill for Claude Code
 testsprite agent install codex      # install into AGENTS.md for Codex (managed-section)
 testsprite agent install cursor     # .cursor/rules/testsprite-verify.mdc
 testsprite agent install cline      # .clinerules/testsprite-verify.md
+testsprite agent install windsurf   # .windsurf/rules/testsprite-verify.md
 testsprite agent install antigravity  # .agents/skills/testsprite-verify/SKILL.md
-testsprite agent list               # list all 5 targets with status + mode + path
+testsprite agent list               # list all 6 targets with status + mode + path
 ```
 
-Supported targets: `claude` (GA), `codex` (experimental), `cursor` (experimental), `cline` (experimental), `antigravity` (experimental).
+Supported targets: `claude` (GA), `codex` (experimental), `cursor` (experimental), `cline` (experimental), `windsurf` (experimental), `antigravity` (experimental).
 
 The `codex` target uses **managed-section mode** — it writes only a sentinel-delimited section inside your existing `AGENTS.md`, so your project instructions are never clobbered. Re-running without `--force` replaces the section in-place; user content outside the sentinels is always preserved.
 

README.md

@@ -61,7 +61,7 @@ npm install -g @testsprite/testsprite-cli
 testsprite setup
 ```
 
-`testsprite setup` prompts for your [API key](https://www.testsprite.com), verifies it, and installs the verification-loop skill for your coding agent (`claude`, `cursor`, `cline`, `antigravity`, `codex`, etc.) — one command, so your agent is wired to verify its own work. Non-interactive (CI / onboarding scripts):
+`testsprite setup` prompts for your [API key](https://www.testsprite.com), verifies it, and installs the verification-loop skill for your coding agent (`claude`, `cursor`, `cline`, `windsurf`, `antigravity`, `codex`, etc.) — one command, so your agent is wired to verify its own work. Non-interactive (CI / onboarding scripts):
 
 ```bash
 TESTSPRITE_API_KEY=sk-... testsprite setup --from-env --yes --agent claude
@@ -110,7 +110,7 @@ Prefer to configure each step by hand (or learn the surface offline with `--dry-
 |           | `test rerun`                                        | Cheap replay of one/many tests (FE verbatim; BE with deps); `--all --project <id>` reruns all tests                   |
 |           | `test wait`                                         | Block on a `runId` until terminal                                                                                     |
 |           | `test artifact get`                                 | Download the failure bundle for a specific `runId`                                                                    |
-| **Agent** | `agent install` / `agent list`                      | Add or list coding-agent targets (pure-local): `claude`, `codex`, `cursor`, `cline`, `antigravity`                    |
+| **Agent** | `agent install` / `agent list`                      | Add or list coding-agent targets (pure-local): `claude`, `codex`, `cursor`, `cline`, `windsurf`, `antigravity`        |
 
 > The earlier command names — `init`, `auth configure`, `auth whoami`, `auth logout` — still work as hidden, deprecated aliases (each prints a one-line notice pointing at the new name), so existing scripts keep running. `auth configure` now runs the full `setup` (it also installs the skill).
 

src/commands/agent.test.ts

@@ -723,11 +723,12 @@ describe('runList', () => {
 
     const json = JSON.parse(capture.stdout.join('\n')) as ListResult[];
     expect(Array.isArray(json)).toBe(true);
-    expect(json).toHaveLength(5);
+    expect(json).toHaveLength(6);
     const targets = json.map(r => r.target);
     expect(targets).toContain('claude');
     expect(targets).toContain('cursor');
     expect(targets).toContain('cline');
+    expect(targets).toContain('windsurf');
     expect(targets).toContain('antigravity');
     expect(targets).toContain('codex');
     const claudeEntry = json.find(r => r.target === 'claude');
@@ -857,11 +858,11 @@ describe('createAgentCommand wiring', () => {
 });
 
 // ---------------------------------------------------------------------------
-// All four own-file targets installed at once
+// All own-file targets installed at once
 // ---------------------------------------------------------------------------
 
-describe('runInstall — all four own-file targets', () => {
-  it('installs all four own-file targets in one invocation', async () => {
+describe('runInstall — all own-file targets', () => {
+  it('installs every own-file target in one invocation', async () => {
     const { store, fs: agentFs } = makeMemFs();
     const { capture, deps } = makeCapture();
 
@@ -871,7 +872,7 @@ describe('runInstall — all four own-file targets', () => {
         output: 'text',
         debug: false,
         dryRun: false,
-        target: ['claude', 'cursor', 'cline', 'antigravity'],
+        target: [...OWN_FILE_TARGETS],
         force: false,
       },
       { cwd: CWD, fs: agentFs, ...deps },

src/commands/agent.ts

@@ -703,7 +703,7 @@ function collect(v: string, prev: string[]): string[] {
 
 export function createAgentCommand(deps: AgentDeps = {}): Command {
   const agent = new Command('agent').description(
-    'Install TestSprite guidance into coding-agent config (Claude Code, Cursor, Cline, Antigravity, Codex)',
+    'Install TestSprite guidance into coding-agent config (Claude Code, Cursor, Cline, Windsurf, Antigravity, Codex)',
   );
 
   agent
@@ -713,7 +713,7 @@ export function createAgentCommand(deps: AgentDeps = {}): Command {
     )
     .option(
       '--target <t>',
-      'Agent target(s): claude, cursor, cline, antigravity, codex (comma-separated or repeated)',
+      'Agent target(s): claude, cursor, cline, windsurf, antigravity, codex (comma-separated or repeated)',
       collect,
       [],
     )

src/lib/agent-targets.test.ts

@@ -60,18 +60,19 @@ testsprite test artifact get <run-id> --out ./out/
 // ---------------------------------------------------------------------------
 
 describe('TARGETS', () => {
-  it('has all five required keys', () => {
+  it('has all six required keys', () => {
     const keys = Object.keys(TARGETS).sort();
-    expect(keys).toEqual(['antigravity', 'claude', 'cline', 'codex', 'cursor']);
+    expect(keys).toEqual(['antigravity', 'claude', 'cline', 'codex', 'cursor', 'windsurf']);
   });
 
   it('claude is GA', () => {
     expect(TARGETS.claude.status).toBe('ga');
   });
 
-  it('cursor, cline, antigravity, and codex are experimental', () => {
+  it('cursor, cline, windsurf, antigravity, and codex are experimental', () => {
     expect(TARGETS.cursor.status).toBe('experimental');
     expect(TARGETS.cline.status).toBe('experimental');
+    expect(TARGETS.windsurf.status).toBe('experimental');
     expect(TARGETS.antigravity.status).toBe('experimental');
     expect(TARGETS.codex.status).toBe('experimental');
   });
@@ -88,6 +89,7 @@ describe('TARGETS', () => {
     expect(TARGETS.antigravity.mode).toBe('own-file');
     expect(TARGETS.cursor.mode).toBe('own-file');
     expect(TARGETS.cline.mode).toBe('own-file');
+    expect(TARGETS.windsurf.mode).toBe('own-file');
   });
 
   it('codex target has mode managed-section', () => {
@@ -255,16 +257,43 @@ describe('renderForTarget("cline")', () => {
   });
 });
 
+describe('renderForTarget("windsurf")', () => {
+  const result = renderForTarget('windsurf', STUB_BODY);
+
+  it('returns the .windsurf/rules path', () => {
+    expect(result.path).toBe('.windsurf/rules/testsprite-verify.md');
+  });
+
+  it('uses the Cascade frontmatter (trigger: model_decision + description)', () => {
+    expect(result.content.startsWith('---\n')).toBe(true);
+    expect(result.content).toContain('trigger: model_decision');
+    expect(result.content).toContain(`description: ${SKILL_DESCRIPTION}`);
+  });
+
+  it('does NOT carry the Claude/Cursor frontmatter keys', () => {
+    const match = /^---\n([\s\S]*?)\n---/.exec(result.content);
+    const fm = match?.[1] ?? '';
+    expect(fm).not.toContain('name:'); // claude/kiro key
+    expect(fm).not.toContain('alwaysApply:'); // cursor .mdc key
+  });
+
+  it('preserves the skill body after the frontmatter and ends with a newline', () => {
+    expect(result.content).toContain('# TestSprite Verification Loop');
+    expect(result.content.endsWith('\n')).toBe(true);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Content integrity — load-bearing command strings must survive any body trim
 // ---------------------------------------------------------------------------
 
 describe('content integrity — own-file targets', () => {
-  const ownFileTargets: Array<'claude' | 'cursor' | 'cline' | 'antigravity'> = [
+  const ownFileTargets: Array<'claude' | 'cursor' | 'cline' | 'antigravity' | 'windsurf'> = [
     'claude',
     'cursor',
     'cline',
     'antigravity',
+    'windsurf',
   ];
 
   // Use the real body for these checks, since we're guarding against trimming.

src/lib/agent-targets.ts

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 
-export type AgentTarget = 'claude' | 'cursor' | 'cline' | 'antigravity' | 'codex';
+export type AgentTarget = 'claude' | 'cursor' | 'cline' | 'antigravity' | 'codex' | 'windsurf';
 
 export interface TargetSpec {
   status: 'ga' | 'experimental';
@@ -33,6 +33,19 @@ function wrapMdc(body: string): string {
   return `---\ndescription: ${SKILL_DESCRIPTION}\nalwaysApply: false\n---\n\n${body}\n`;
 }
 
+/**
+ * Windsurf (Cascade) reads workspace rules from `.windsurf/rules/*.md` with
+ * YAML frontmatter. `trigger: model_decision` is the Cascade equivalent of the
+ * Cursor `.mdc` `alwaysApply: false` mode: only the `description` is surfaced
+ * up front, and Cascade pulls in the full rule body when the description shows
+ * it is relevant — exactly the on-demand activation this verification skill
+ * wants. (The other triggers are `always_on`, `manual`, and `glob`.)
+ * Workspace rule files have a 12 KB budget, well above this skill's size.
+ */
+function wrapWindsurf(body: string): string {
+  return `---\ntrigger: model_decision\ndescription: ${SKILL_DESCRIPTION}\n---\n\n${body}\n`;
+}
+
 export const TARGETS: Record<AgentTarget, TargetSpec> = {
   claude: {
     status: 'ga',
@@ -58,6 +71,12 @@ export const TARGETS: Record<AgentTarget, TargetSpec> = {
     mode: 'own-file',
     wrap: body => body,
   },
+  windsurf: {
+    status: 'experimental',
+    path: '.windsurf/rules/testsprite-verify.md',
+    mode: 'own-file',
+    wrap: wrapWindsurf,
+  },
   /**
    * codex target — managed-section mode.
    *

test/__snapshots__/help.snapshot.test.ts.snap

@@ -4,7 +4,7 @@ exports[`--help snapshots > agent 1`] = `
 "Usage: testsprite agent [options] [command]
 
 Install TestSprite guidance into coding-agent config (Claude Code, Cursor,
-Cline, Antigravity, Codex)
+Cline, Windsurf, Antigravity, Codex)
 
 Options:
   -h, --help         display help for command
@@ -25,8 +25,8 @@ Write the TestSprite verification-loop skill file into a project for a coding
 agent
 
 Options:
-  --target <t>  Agent target(s): claude, cursor, cline, antigravity, codex
-                (comma-separated or repeated) (default: [])
+  --target <t>  Agent target(s): claude, cursor, cline, windsurf, antigravity,
+                codex (comma-separated or repeated) (default: [])
   --dir <path>  Project root to write into (default: cwd)
   --force       For own-file targets: overwrite existing file (a .bak backup is
                 kept). For codex (managed-section): replaces the section
@@ -110,7 +110,8 @@ Options:
   --from-env        Read TESTSPRITE_API_KEY from the environment instead of
                     prompting (default: false)
   --agent <target>  Coding-agent target to install: claude, antigravity,
-                    cursor, cline, codex (default: claude) (default: "claude")
+                    cursor, cline, windsurf, codex (default: claude) (default:
+                    "claude")
   --no-agent        Skip the agent skill install (configure credentials only)
   --force           Overwrite an existing skill file (a .bak backup is kept)
   --dir <path>      Project root for the skill install (default: current
@@ -579,8 +580,8 @@ Commands:
   project                      Manage TestSprite projects
   test                         Inspect TestSprite tests
   agent                        Install TestSprite guidance into coding-agent
-                               config (Claude Code, Cursor, Cline, Antigravity,
-                               Codex)
+                               config (Claude Code, Cursor, Cline, Windsurf,
+                               Antigravity, Codex)
   usage|credits                Show credit balance and plan/entitlement info
                                (proactive pre-flight before a large test run)
   help [command]               display help for command