SKILL.md- the skill, written out in plain English

   curl -XPOST 127.0.0.1:3147/chat-edit \
     -H "Content-Type: application/json" \
     -d '{"messageId":"<id>","content":"<new text>"}'

AGENTS.md- what the AI loads when this skill comes up

echo "[$(date -u +%FT%TZ)] chat-edit: <what was missing or fixed> [FIXED|LOGGED] action_kind=skill-ran" >> state/log/loader-feedback.log

api.ts- the code it can call

#!/usr/bin/env npx tsx
/**
 * snappy-chat-edit/api.ts
 *
 * Edit surface for snappy-chat: preview a unified diff before applying.
 * Supports file reads, validation, preview generation, and atomic writes.
 * Used by server.ts /edit/preview and /edit/apply endpoints.
 *
 * Exports:
 *  - previewEdit(path, oldText, newText) → {token, diff, ok, error}
 *  - applyEdit(path, oldText, newText) → {ok, error}
 *
 * Token expiry: 5 minutes (in-memory map in server.ts, not persisted).
 */

import { readFileSync, writeFileSync, existsSync, renameSync, unlinkSync } from "fs";
import { dirname } from "path";

/**
 * Unified diff generator. Simple line-by-line diff for readability.
 * Output format: each line prefixed with " " (context), "-" (removed), or "+" (added).
 * Returned as a single string with embedded \n characters (not literal newlines).
 */
export function generateUnifiedDiff(oldText: string, newText: string): string {
  const oldLines = oldText.split("\n");
  const newLines = newText.split("\n");
  const diff: string[] = [];

  // Simple line-level diff (not a full Myers algorithm, but sufficient for UI).
  let oldIdx = 0;
  let newIdx = 0;

  while (oldIdx < oldLines.length || newIdx < newLines.length) {
    if (oldIdx < oldLines.length && newIdx < newLines.length) {
      if (oldLines[oldIdx] === newLines[newIdx]) {
        diff.push(` ${oldLines[oldIdx]}`);
        oldIdx++;
        newIdx++;
      } else {
        // Mismatch: collect all consecutive old lines, then all consecutive new lines
        const oldStart = oldIdx;
        while (oldIdx < oldLines.length && newIdx < newLines.length && oldLines[oldIdx] !== newLines[newIdx]) {
          oldIdx++;
        }
        // Check if we've reached the end or found a match
        if (oldIdx === oldLines.length || newIdx === newLines.length || oldLines[oldIdx] !== newLines[newIdx]) {
          // Still mismatched or end of one; emit what we've collected
          for (let i = oldStart; i < oldIdx; i++) {
            diff.push(`-${oldLines[i]}`);
          }
          const newStart = newIdx;
          while (newIdx < newLines.length && oldIdx < oldLines.length && oldLines[oldIdx] !== newLines[newIdx]) {
            newIdx++;
          }
          for (let i = newStart; i < newIdx; i++) {
            diff.push(`+${newLines[i]}`);
          }
        } else {
          // Found a match; emit old deletions then new additions
          for (let i = oldStart; i < oldIdx; i++) {
            diff.push(`-${oldLines[i]}`);
          }
          const newStart = newIdx;
          while (newIdx < newLines.length && newLines[newIdx] !== oldLines[oldIdx]) {
            newIdx++;
          }
          for (let i = newStart; i < newIdx; i++) {
            diff.push(`+${newLines[i]}`);
          }
        }
      }
    } else if (oldIdx < oldLines.length) {
      diff.push(`-${oldLines[oldIdx]}`);
      oldIdx++;
    } else {
      diff.push(`+${newLines[newIdx]}`);
      newIdx++;
    }
  }

  // Return as a string with escaped newlines for JSON safety
  return diff.join("\n");
}

/**
 * Preview an edit: read the file, verify oldText exists exactly once,
 * generate a unified diff, and return a token for later application.
 *
 * Returns: { ok, token?, diff?, error? }
 *   - ok=true: token and diff are present (apply later with /edit/apply?token=X)
 *   - ok=false: error message (file not found, oldText mismatch, etc.)
 */
export function previewEdit(
  path: string,
  oldText: string,
  newText: string,
): { ok: boolean; token?: string; diff?: string; error?: string } {
  try {
    if (!existsSync(path)) {
      return { ok: false, error: `file not found: ${path}` };
    }

    const content = readFileSync(path, "utf8");

    // Verify oldText appears exactly once
    const count = (content.split(oldText).length - 1);
    if (count === 0) {
      return { ok: false, error: `oldText not found in file: ${path}` };
    }
    if (count > 1) {
      return { ok: false, error: `oldText appears ${count} times in file (expected exactly 1): ${path}` };
    }

    const diff = generateUnifiedDiff(content, content.replace(oldText, newText));
    const token = `edit-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;

    return { ok: true, token, diff };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    return { ok: false, error: `preview failed: ${msg}` };
  }
}

/**
 * Apply an edit: read the file, verify oldText exists exactly once,
 * apply the replacement, and write atomically.
 *
 * Returns: { ok, error? }
 *   - ok=true: file written successfully
 *   - ok=false: error message (file not found, oldText mismatch, etc.)
 */
export function applyEdit(
  path: string,
  oldText: string,
  newText: string,
): { ok: boolean; error?: string } {
  try {
    if (!existsSync(path)) {
      return { ok: false, error: `file not found: ${path}` };
    }

    const content = readFileSync(path, "utf8");

    // Verify oldText appears exactly once
    const count = (content.split(oldText).length - 1);
    if (count === 0) {
      return { ok: false, error: `oldText not found in file: ${path}` };
    }
    if (count > 1) {
      return { ok: false, error: `oldText appears ${count} times in file (expected exactly 1): ${path}` };
    }

    // Apply the replacement
    const updated = content.replace(oldText, newText);

    // Atomic write: write to temp, then rename
    const tempPath = `${path}.tmp-${Date.now()}`;
    try {
      writeFileSync(tempPath, updated, "utf8");
      // Rename atomic on POSIX systems
      renameSync(tempPath, path);
    } catch (err) {
      try {
        unlinkSync(tempPath);
      } catch {}
      throw err;
    }

    return { ok: true };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    return { ok: false, error: `apply failed: ${msg}` };
  }
}

scripts- helper scripts it can run

prose-only skill - no sidecar under state/bin/ yet. Steps, if any, are described in SKILL.md.

how we check it- the checks, plus the last 3 runs