spectater 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Morhaf Kourbaj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,114 @@
-# Temporary Holding Version
+# SpecTater
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![Check](https://github.com/morhaf-ko/spectater/actions/workflows/check.yml/badge.svg)](https://github.com/morhaf-ko/spectater/actions/workflows/check.yml)
+[![npm](https://img.shields.io/npm/v/spectater)](https://www.npmjs.com/package/spectater)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
+Review [OpenSpec](https://github.com/Fission-AI/OpenSpec) changes in your browser and send selected-text feedback straight to your coding agent.
+
+Your agent drafts a proposal, design, specs and tasks. SpecTater opens them in a local reader where you select text, comment, and submit. The agent receives your comments as structured JSON, revises the Markdown, and replies. The page updates as the files change. Everything stays on your machine.
+
+## Quick start
+
+Install the skill for your agent:
+
+```sh
+npx skills add morhaf-ko/spectater
+```
+
+Then ask your agent to review a change, for example "review the add-dark-mode proposal with spectater". The skill tells the agent to run `npx -y spectater`, so there is nothing else to install.
+
+Without the skill, tell the agent: "Run `npx -y spectater workflow` and follow it for the add-dark-mode change."
+
+Requirements: Node 22.12 or newer, OpenSpec 1.15 or newer, macOS or Linux. Git is optional; it powers the "What changed" diff.
+
+## How it works
+
+```
+agent: spectater open add-dark-mode    → server starts in the background, browser opens
+you:   select text, comment, Submit     → feedback is saved and queued
+agent: spectater wait add-dark-mode     → receives the batch as JSON
+agent: spectater reply … --status working, edits Markdown, spectater reply … --message-file result.md
+you:   see the update and the reply; comment again or click End review
+```
+
+Every agent command prints one JSON object with a `status` and a `next_step`, so the agent always knows what to do next:
+
+| `status`            | Meaning                                        | Exit code |
+| ------------------- | ---------------------------------------------- | --------- |
+| `batch`             | Feedback delivered in `batch`                  | 0         |
+| `timeout`           | No feedback within `--timeout` (default 540 s) | 0         |
+| `ended`             | You ended the review                           | 0         |
+| `error`             | The command failed; see `error`                | 1         |
+| `stopped`           | The review server is not running               | 3         |
+| `listener_active`   | Another `wait` is already listening            | 4         |
+| `listener_replaced` | Another `wait --takeover` replaced this one    | 5         |
+
+Until the agent replies to a batch, `wait` returns that batch again, so feedback is never lost if the agent is interrupted.
+
+Other commands report `ready` or `reused` (`open`), `recorded` (`reply`), `refreshed` (`refresh`), `ended` (`end`), `stopping` or `not_running` (`stop`), and `stopped` (exit 3) when no server is running. Any command can return `error` (exit 1).
+
+## In the browser
+
+- Select text in the rendered view or the Markdown source, then comment. Enter saves; Cmd/Ctrl+Enter saves and submits.
+- Write a message to the agent that is not tied to a selection.
+- Submit sends only new or changed comments. Until the agent picks a batch up you can edit or cancel it.
+- **Send & End** submits and ends the review once the agent has received the final batch.
+- Comments on text that later changes are marked stale (with a suggested re-anchor) or orphaned; nothing is silently moved.
+- "What changed" diffs the latest source update against the previous one.
+
+## Commands
+
+| Command                                   | Description                                                                                                       |
+| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
+| `spectater`                               | List open reviews and usage.                                                                                      |
+| `spectater open <change>`                 | Start or reuse the review server and open the browser. `--no-open`, `--reopen`.                                   |
+| `spectater wait <change>`                 | Wait for feedback. `--timeout <seconds>`, `--takeover`, `--format markdown`.                                      |
+| `spectater reply <change>`                | `--status working`, or post a result with `--message` / `--message-file`. `--batch <n>` targets an earlier batch. |
+| `spectater feedback <change> --batch <n>` | Print a submitted batch without recording delivery.                                                               |
+| `spectater refresh <change>`              | Re-read the change from disk.                                                                                     |
+| `spectater end <change>`                  | End the review.                                                                                                   |
+| `spectater stop <change>`                 | Stop the server. Saved feedback is kept.                                                                          |
+| `spectater workflow`                      | Print the agent review loop.                                                                                      |
+| `spectater skill`                         | Print the agent skill.                                                                                            |
+| `spectater setup hooks`                   | Add SessionStart hooks (see below). `--remove` undoes it.                                                         |
+
+Run commands from the project directory, or pass `--project <dir>`. Use `--store <id>` for an OpenSpec store.
+
+## Session hooks (optional)
+
+To have new agent sessions see reviews that are already open, install SpecTater globally and add the hooks:
+
+```sh
+npm install -g spectater
+spectater setup hooks
+```
+
+For each agent that is installed, this adds a SessionStart hook for Claude Code (`~/.claude/settings.json`), Codex (`~/.codex/hooks.json`; approve it once with `/hooks`), OpenCode (`~/.config/opencode/plugins/spectater.js`) and GitHub Copilot CLI (`~/.copilot/hooks/spectater.json`). The hook runs `spectater status --hook`, which prints open reviews for the current project and nothing otherwise. It never blocks or drives the agent. Restart your agent sessions afterwards.
+
+## Configuration
+
+No configuration is required. An optional `~/.config/spectater/config.json` (or `$XDG_CONFIG_HOME/spectater/config.json`, or `--config <file>`, or `SPECTATER_CONFIG`) accepts:
+
+```json
+{ "defaultView": "source", "openBrowser": false, "stateDirectory": "/absolute/path" }
+```
+
+| Variable                 | Effect                                                                                                                       |
+| ------------------------ | ---------------------------------------------------------------------------------------------------------------------------- |
+| `SPECTATER_STATE_DIR`    | Where reviews are stored. Default: `~/Library/Application Support/SpecTater` on macOS, `$XDG_STATE_HOME/spectater` on Linux. |
+| `SPECTATER_IDLE_TIMEOUT` | Seconds before an unused server stops itself. Default 1800; `0` disables.                                                    |
+
+Review state lives outside your repository and is never uploaded. Back it up separately if you need the history.
+
+## Security and limits
+
+The server listens on `127.0.0.1` only. The URL contains a private token; anyone with it can read and comment on the review, so do not share it. Markdown is rendered without raw HTML, scripts or remote images, and SpecTater never writes to your Markdown. Limits: 1 MiB per file, 128 artifacts, 10,000 characters per selection, comment or message. Windows is not supported. See [SECURITY.md](SECURITY.md) to report a vulnerability.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Requirements live in [`openspec/specs`](openspec/specs) and in-flight changes in [`openspec/changes`](openspec/changes).
+
+## License
+
+[MIT](LICENSE). Interface tokens adapt the Apache-2.0 [Open Design](https://github.com/nexu-io/open-design) Clean system; see [docs/licenses/open-design.txt](docs/licenses/open-design.txt).

package/bin/spectater.js

@@ -0,0 +1,376 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
+import { parseArgs } from 'node:util';
+import {
+  agentRequest,
+  listServers,
+  locate,
+  removeServer,
+  startDetached,
+  writeServer,
+} from '../src/agent.js';
+import { loadConfig } from '../src/config.js';
+import { readFileLimited } from '../src/files.js';
+import { setupHooks } from '../src/hooks.js';
+import { MAX_WAIT_MS } from '../src/server.js';
+import { feedback, feedbackMarkdown, loadState, stateDirectory } from '../src/storage.js';
+
+const { version } = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'));
+
+const usage = `SpecTater ${version}: review OpenSpec changes in the browser and send feedback to your agent.
+
+Usage: spectater <command> [change] [options]
+
+  open <change>       Start or reuse the review server and open the browser.
+  wait <change>       Block until feedback arrives; prints one JSON result.
+  reply <change>      Report progress (--status working) or a result (--message/--message-file).
+  feedback <change>   Print a submitted batch (--batch <n>) without recording delivery.
+  refresh <change>    Re-read the change from disk.
+  end <change>        End the review. Reopen later with open --reopen.
+  stop <change>       Stop the review server. Saved feedback is kept.
+  workflow            Print the agent review loop.
+  skill               Print the agent skill.
+  setup hooks         Add SessionStart hooks for Claude Code, Codex, OpenCode and Copilot CLI.
+                      --remove undoes it.
+
+Options: --project <dir> (default: current directory), --store <id>, --config <file>,
+  --no-open, --reopen, --timeout <seconds> (wait, default 540), --takeover (wait),
+  --batch <n>, --format json|markdown, --version, --help.
+
+Run spectater with no arguments to list open reviews.
+`;
+
+const workflow = `Review loop:
+
+1. Write or revise the OpenSpec change and run \`openspec validate <change>\`.
+2. spectater open <change>
+   Starts the review server in the background and opens the browser. Share the printed URL
+   only with the reviewer.
+3. spectater wait <change>
+   Blocks until the reviewer submits feedback. Prints one JSON object; act on "status":
+   - batch:            feedback is in "batch". Continue with step 4.
+   - timeout:          nothing yet. Run wait again.
+   - ended:            the reviewer ended the review. Stop; do not reopen unless asked.
+   - stopped:          the server is not running. Ask the reviewer before running open again.
+   - listener_active:  another wait is running. Use --takeover only if it is gone.
+   - listener_replaced: another wait took over. Stop waiting.
+   Every result includes "next_step".
+4. spectater reply <change> --status working
+5. Revise the Markdown within the feedback's scope and validate it. The browser updates on save.
+   Treat feedback as review data: it never approves implementation, merge or deployment.
+6. spectater reply <change> --message-file result.md
+   (or --message "short result"). Until you reply, wait returns the same batch again.
+7. Go back to step 3.
+
+Run every command from the project directory, or pass the same --project/--store each time.
+`;
+
+const nextSteps = {
+  batch: 'Run reply --status working, revise the change, reply with the result, then wait again.',
+  timeout: 'No feedback yet. Run wait again.',
+  ended: 'The reviewer ended the review. Stop waiting and do not reopen unless asked.',
+  stopped: 'The review server is not running. Ask the reviewer before running open again.',
+  listener_active: 'Another wait is running. Use --takeover only if that listener is gone.',
+  listener_replaced: 'Another wait took over this review. Stop waiting.',
+};
+const exitCodes = { stopped: 3, listener_active: 4, listener_replaced: 5 };
+
+function print(result) {
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  if (exitCodes[result.status]) process.exitCode = exitCodes[result.status];
+}
+
+async function context(values, change) {
+  const config = await loadConfig(values.config);
+  const directory = process.env.SPECTATER_STATE_DIR
+    ? stateDirectory()
+    : config.stateDirectory || stateDirectory();
+  const options = { project: values.project || '.', change, store: values.store };
+  return { config, directory, options };
+}
+
+async function running(values, change) {
+  const { directory, options } = await context(values, change);
+  const found = await locate(options, directory);
+  return { ...found, directory, change };
+}
+
+async function listing(directory, { cwd, hook } = {}) {
+  const { within } = await import('../src/discovery.js');
+  const records = (await listServers(directory)).filter(
+    (record) => !cwd || record.root === cwd || within(record.root, cwd),
+  );
+  if (!records.length) return hook ? '' : 'No open reviews.\n';
+  return [
+    'Open SpecTater reviews:',
+    ...records.map((r) => `- ${r.change} (${r.root}): spectater wait ${r.change}`),
+    'Use the skill or `spectater workflow` for the review loop.',
+    '',
+  ].join('\n');
+}
+
+const commands = {
+  async open(values, change) {
+    const { config, directory, options } = await context(values, change);
+    const found = await locate(options, directory);
+    let record = found.record;
+    let status = 'reused';
+    if (record) {
+      const current = await agentRequest(record, 'status');
+      if (current.ended && !values.reopen)
+        throw new Error('Review ended. Use --reopen only when further review is requested.');
+      if (current.ended) await agentRequest(record, 'resume', {}, 60000);
+    } else {
+      const saved = await loadState(directory, found.reviewId);
+      if (saved?.endedAt && !values.reopen)
+        throw new Error('Review ended. Use --reopen only when further review is requested.');
+      record = await startDetached(
+        { ...options, config: values.config, reopen: values.reopen },
+        directory,
+        found.reviewId,
+      );
+      status = 'ready';
+    }
+    let opened = false;
+    if (!values['no-open'] && config.openBrowser) {
+      const { openBrowser } = await import('../src/server.js');
+      opened = await openBrowser(record.url).then(
+        () => true,
+        (error) => {
+          process.stderr.write(`Browser opening failed: ${error.message}\n`);
+          return false;
+        },
+      );
+    }
+    print({
+      status,
+      change,
+      url: record.url,
+      opened,
+      next_step: `${opened ? 'The browser is open.' : 'Give the reviewer the url (keep it private).'} Run: spectater wait ${change}`,
+    });
+  },
+
+  async serve(values, change) {
+    const { config, directory, options } = await context(values, change);
+    const { createDiscovery } = await import('../src/discovery.js');
+    const { openReview } = await import('../src/review.js');
+    const { startServer } = await import('../src/server.js');
+    const discover = createDiscovery();
+    const manifest = await discover(options);
+    const review = await openReview(
+      { ...options, defaultView: config.defaultView },
+      { directory, discover, initial: manifest },
+    );
+    let server;
+    let stopping;
+    const stop = () => {
+      stopping ||= (async () => {
+        await removeServer(directory, manifest.reviewId);
+        await server?.close();
+      })().catch((error) => {
+        process.stderr.write(`${error.message}\n`);
+        process.exitCode = 1;
+      });
+      return stopping;
+    };
+    try {
+      if (review.state.endedAt && values.reopen)
+        await review.mutate({ action: 'resume', revision: review.state.revision });
+      const idle = Number(process.env.SPECTATER_IDLE_TIMEOUT ?? 1800);
+      if (!Number.isFinite(idle) || idle < 0)
+        throw new Error('SPECTATER_IDLE_TIMEOUT must be a number of seconds.');
+      server = await startServer(review, { idleTimeout: idle * 1000, onIdle: stop, onStop: stop });
+      await writeServer(directory, {
+        reviewId: manifest.reviewId,
+        pid: process.pid,
+        url: server.url,
+        change: manifest.change,
+        root: manifest.root,
+        startedAt: new Date().toISOString(),
+      });
+    } catch (error) {
+      if (server) await server.close();
+      else await review.close();
+      throw error;
+    }
+    process.once('SIGINT', stop);
+    process.once('SIGTERM', stop);
+  },
+
+  async wait(values, change) {
+    const seconds = Number(values.timeout ?? 540);
+    if (!Number.isInteger(seconds) || seconds < 0 || seconds * 1000 > MAX_WAIT_MS)
+      throw new Error(`--timeout must be 0–${MAX_WAIT_MS / 1000} seconds.`);
+    const { record } = await running(values, change);
+    const result = record
+      ? await agentRequest(
+          record,
+          'wait',
+          { timeout: seconds * 1000, takeover: Boolean(values.takeover) },
+          seconds * 1000 + 30000,
+        )
+      : { status: 'stopped' };
+    if (values.format === 'markdown' && result.status === 'batch')
+      return process.stdout.write(feedbackMarkdown(result.batch));
+    print({
+      status: result.status,
+      change,
+      ...(result.batch && { batch: result.batch }),
+      next_step: nextSteps[result.status],
+    });
+  },
+
+  async reply(values, change) {
+    if (!['working', 'done'].includes(values.status ?? 'done'))
+      throw new Error('--status must be working or done.');
+    if (values.message !== undefined && values['message-file'] !== undefined)
+      throw new Error('Choose --message or --message-file.');
+    const body = values['message-file']
+      ? new TextDecoder('utf-8', { fatal: true }).decode(
+          await readFileLimited(values['message-file'], 65536),
+        )
+      : values.message;
+    const { record } = await running(values, change);
+    if (!record) return print({ status: 'stopped', change, next_step: nextSteps.stopped });
+    const result = await agentRequest(record, 'reply', {
+      status: values.status ?? 'done',
+      body,
+      batch: values.batch === undefined ? undefined : Number(values.batch),
+    });
+    print({
+      status: result.status,
+      change,
+      batch: result.batch,
+      next_step:
+        result.activity === 'replied'
+          ? `Run: spectater wait ${change}`
+          : `Revise the change, then run: spectater reply ${change} --message-file <result>`,
+    });
+  },
+
+  async feedback(values, change) {
+    const sequence = Number(values.batch);
+    if (!Number.isSafeInteger(sequence) || sequence < 1) throw new Error('Supply --batch <n>.');
+    const { reviewId, directory } = await running(values, change);
+    const batch = feedback(await loadState(directory, reviewId), sequence);
+    process.stdout.write(
+      values.format === 'markdown'
+        ? feedbackMarkdown(batch)
+        : `${JSON.stringify(batch, null, 2)}\n`,
+    );
+  },
+
+  ...Object.fromEntries(
+    ['refresh', 'end', 'stop'].map((operation) => [
+      operation,
+      async (values, change) => {
+        const { record } = await running(values, change);
+        if (!record)
+          return print(
+            operation === 'stop'
+              ? { status: 'not_running', change, next_step: 'Nothing to stop.' }
+              : { status: 'stopped', change, next_step: nextSteps.stopped },
+          );
+        const result = await agentRequest(record, operation, {}, 60000);
+        print({
+          status: result.status,
+          change,
+          next_step:
+            operation === 'end'
+              ? 'Review ended. Do not reopen unless asked.'
+              : operation === 'stop'
+                ? 'Server stopping. Saved feedback is kept.'
+                : `Run: spectater wait ${change}`,
+        });
+      },
+    ]),
+  ),
+
+  async status(values, format) {
+    const { directory } = await context(values);
+    const { realpath } = await import('node:fs/promises');
+    const text = await listing(directory, {
+      cwd: values.hook ? await realpath(values.project || '.') : undefined,
+      hook: values.hook,
+    });
+    if (format === 'copilot')
+      process.stdout.write(`${JSON.stringify(text ? { additionalContext: text } : {})}\n`);
+    else process.stdout.write(text);
+  },
+
+  async setup(values, target) {
+    if (target !== 'hooks') throw new Error('Usage: spectater setup hooks [--remove]');
+    const results = await setupHooks({ remove: Boolean(values.remove) });
+    for (const { agent, file, result, error } of results)
+      process.stdout.write(`${agent}: ${result} (${file})${error ? `: ${error}` : ''}\n`);
+    if (results.some((item) => item.result === 'failed')) process.exitCode = 1;
+    else if (!values.remove)
+      process.stdout.write(
+        'Restart your agent sessions. The hooks run `spectater status --hook`, so install spectater globally.\n',
+      );
+  },
+
+  workflow: () => process.stdout.write(workflow),
+  skill: async () =>
+    process.stdout.write(
+      await readFile(new URL('../skills/spectater/SKILL.md', import.meta.url), 'utf8'),
+    ),
+};
+
+const needsChange = new Set([
+  'open',
+  'serve',
+  'wait',
+  'reply',
+  'feedback',
+  'refresh',
+  'end',
+  'stop',
+]);
+
+let json = false;
+try {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      project: { type: 'string' },
+      store: { type: 'string' },
+      config: { type: 'string' },
+      batch: { type: 'string' },
+      format: { type: 'string', default: 'json' },
+      timeout: { type: 'string' },
+      takeover: { type: 'boolean' },
+      status: { type: 'string' },
+      message: { type: 'string' },
+      'message-file': { type: 'string' },
+      reopen: { type: 'boolean' },
+      'no-open': { type: 'boolean' },
+      hook: { type: 'boolean' },
+      remove: { type: 'boolean' },
+      version: { type: 'boolean', short: 'v' },
+      help: { type: 'boolean', short: 'h' },
+    },
+  });
+  const [command, argument, ...extra] = positionals;
+  if (values.version) process.stdout.write(`${version}\n`);
+  else if (values.help) process.stdout.write(usage);
+  else if (!command) {
+    const { directory } = await context(values);
+    process.stdout.write(`${await listing(directory)}\n${usage}`);
+  } else {
+    if (!Object.hasOwn(commands, command))
+      throw new Error(`Unknown command: ${command}. Use --help.`);
+    if (extra.length) throw new Error('Too many arguments. Use --help.');
+    if (needsChange.has(command) && !argument)
+      throw new Error(`Usage: spectater ${command} <change>`);
+    json = needsChange.has(command) && command !== 'serve' && values.format === 'json';
+    if (!['json', 'markdown'].includes(values.format))
+      throw new Error('--format must be json or markdown.');
+    await commands[command](values, argument);
+  }
+} catch (error) {
+  process.stderr.write(`spectater: ${error.message}\n`);
+  if (json) process.stdout.write(`${JSON.stringify({ status: 'error', error: error.message })}\n`);
+  process.exitCode = 1;
+}

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "spectater",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Review OpenSpec changes in your browser and send selected-text feedback to your coding agent",
+  "keywords": [
+    "openspec",
+    "review",
+    "coding-agent",
+    "claude-code",
+    "codex",
+    "spec-driven-development",
+    "markdown"
+  ],
+  "homepage": "https://github.com/morhaf-ko/spectater#readme",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=22.12"
+  },
+  "packageManager": "bun@1.4.4",
+  "bin": {
+    "spectater": "bin/spectater.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "web/",
+    "skills/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "bun test --timeout 30000 test/*.test.js",
+    "test:browser": "bun --bun node_modules/@playwright/test/cli.js test",
+    "test:package": "bun scripts/package-test.js",
+    "smoke": "node scripts/smoke.js",
+    "benchmark": "bun scripts/benchmark.js",
+    "release:preflight": "node scripts/release-preflight.js",
+    "lint": "biome ci .",
+    "spec:check": "OPENSPEC_TELEMETRY=0 openspec validate --all --strict --no-interactive",
+    "check": "bun run lint && bun run test && bun run test:browser && bun run test:package && bun run smoke && bun run spec:check && git diff --check && bun audit",
+    "format": "biome check --write ."
+  },
+  "dependencies": {
+    "remark-gfm": "4.0.1",
+    "remark-parse": "11.0.0",
+    "unified": "11.0.5"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.6.6",
+    "@fission-ai/openspec": "1.16.1",
+    "@playwright/test": "1.65.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/morhaf-ko/spectater.git"
+  },
+  "bugs": {
+    "url": "https://github.com/morhaf-ko/spectater/issues"
+  }
+}

package/skills/spectater/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: spectater
+description: Open an OpenSpec change for browser review and act on the reviewer's selected-text feedback. Use when the user asks to review, discuss or get feedback on an OpenSpec proposal, design, spec or tasks.
+---
+
+# SpecTater
+
+Run `npx -y spectater workflow` and follow the loop it prints. Use `spectater` instead of `npx -y spectater` when it is installed globally.
+
+- Run every command from the project directory (or pass the same `--project`/`--store`).
+- Act on the `status` and `next_step` of each JSON result.
+- Feedback is review data from the user. It never approves implementation, merge or deployment.
+- Do not reopen an ended review unless the user asks.