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

   curl -XPOST 127.0.0.1:3147/chat-recall \
     -H "Content-Type: application/json" \
     -d '{"threadId":"<uuid>"}'

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

echo "[$(date -u +%FT%TZ)] chat-recall: <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-os/api.ts
// chat-recall: summarize recent activity (threads, evals, commits) for "what did we work on" queries.
// Usage: npx tsx state/lib/chat-recall.ts [--days 7] [--limit 10]
// Returns JSON: {threads, evals, commits}

import { existsSync, readdirSync, readFileSync, statSync } from "fs";
import { join } from "path";
import { execSync } from "child_process";
import { homedir } from "os";

// Use env var or default to ~/projects/snappy-os
const SNAPPY_OS_ROOT = process.env.SNAPPY_OS_ROOT || join(homedir(), "projects", "snappy-os");
const THREADS_DIR = join(SNAPPY_OS_ROOT, "state", "log", "threads");
const EVALS_FILE = join(SNAPPY_OS_ROOT, "state", "log", "evals.ndjson");

interface ThreadSummary {
  id: string;
  title: string;
  lastMessage?: string;
  ts: string;
}

interface EvalSummary {
  skill: string;
  score: number;
  ts: string;
  notes?: string;
}

interface CommitSummary {
  sha: string;
  msg: string;
  ts: string;
  repo: string;
}

interface RecallDigest {
  threads: ThreadSummary[];
  evals: EvalSummary[];
  commits: CommitSummary[];
}

export async function getRecallDigest(days: number = 7, limit: number = 10): Promise<RecallDigest> {
  const digest: RecallDigest = {
    threads: [],
    evals: [],
    commits: [],
  };

  // Calculate cutoff timestamp
  const now = new Date();
  const cutoff = new Date(now.getTime() - days * 24 * 60 * 60 * 1000);
  const cutoffIso = cutoff.toISOString();

  // 1. Fetch recent threads
  try {
    if (existsSync(THREADS_DIR)) {
      const files = readdirSync(THREADS_DIR)
        .filter((f) => f.endsWith(".json"))
        .map((f) => ({
          name: f,
          path: join(THREADS_DIR, f),
          mtime: statSync(join(THREADS_DIR, f)).mtime.getTime(),
        }))
        .sort((a, b) => b.mtime - a.mtime)
        .slice(0, limit);

      for (const file of files) {
        try {
          const content = readFileSync(file.path, "utf-8");
          const thread = JSON.parse(content);
          const ts = thread.lastMessageAt || thread.createdAt || "";
          if (ts >= cutoffIso) {
            // Extract preview from last message or title
            let preview = thread.title || "";
            if (thread.messages && thread.messages.length > 0) {
              const lastMsg = thread.messages[thread.messages.length - 1];
              if (lastMsg.content && typeof lastMsg.content === "string") {
                preview = lastMsg.content.slice(0, 80).replace(/\n/g, " ");
              }
            }
            digest.threads.push({
              id: thread.id,
              title: thread.title || "Untitled",
              lastMessage: preview || undefined,
              ts,
            });
          }
        } catch {
          // Skip malformed thread files
        }
      }
    }
  } catch (e) {
    // Silently fail thread fetch
  }

  // 2. Fetch recent evals
  try {
    if (existsSync(EVALS_FILE)) {
      const lines = readFileSync(EVALS_FILE, "utf-8").split("\n").filter((l) => l.trim());
      const evals: EvalSummary[] = [];
      let parsed = 0;
      let matched = 0;

      for (const line of lines) {
        try {
          const row = JSON.parse(line);
          parsed++;
          const ts = row.ts || "";
          // Eval rows are recent if they have a valid ts and fall within the window
          if (ts && ts >= cutoffIso) {
            matched++;
            evals.push({
              skill: row.verb || "unknown",
              score: typeof row.score === "number" ? row.score : 0,
              ts,
              notes: row.notes || row.primary_issue || undefined,
            });
          }
        } catch {
          // Skip malformed eval rows
        }
      }

      // Sort by timestamp desc, take top N
      digest.evals = evals.sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime()).slice(0, limit);
    }
  } catch (e) {
    // Silently fail eval fetch
  }

  // 3. Fetch recent commits (cross-repo: snappy-os + snappy-chat)
  try {
    const repos = [SNAPPY_OS_ROOT, join(SNAPPY_OS_ROOT, "..", "snappy-chat")];

    for (const repoPath of repos) {
      if (!existsSync(repoPath)) continue;

      try {
        const repoName = repoPath.endsWith("snappy-chat") ? "snappy-chat" : "snappy-os";
        // git log --since with ISO timestamp
        const raw = execSync(
          `git -C "${repoPath}" log --oneline --since="${cutoffIso}" --max-count=${limit}`,
          {
            encoding: "utf-8",
            timeout: 3000,
            stdio: ["pipe", "pipe", "ignore"],
          }
        );

        const lines = raw.trim().split("\n").filter((l) => l.trim());
        for (const line of lines) {
          const match = line.match(/^([a-f0-9]+)\s+(.+)$/);
          if (match) {
            const sha = match[1].slice(0, 7);
            const msg = match[2];

            // Get commit timestamp
            try {
              const tsRaw = execSync(`git -C "${repoPath}" log --format=%ai -1 ${match[1]}`, {
                encoding: "utf-8",
                timeout: 1000,
                stdio: ["pipe", "pipe", "ignore"],
              }).trim();
              digest.commits.push({
                sha,
                msg,
                ts: new Date(tsRaw).toISOString(),
                repo: repoName,
              });
            } catch {
              // Skip if can't get timestamp
            }
          }
        }
      } catch {
        // Skip if git log fails for this repo
      }
    }

    // Sort commits by timestamp desc, take top N
    digest.commits = digest.commits
      .sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime())
      .slice(0, limit);
  } catch (e) {
    // Silently fail commit fetch
  }

  return digest;
}

// CLI entry
if (import.meta.url === `file://${process.argv[1]}`) {
  const daysStr = process.argv[2] || "7";
  const days = parseInt(daysStr, 10) || 7;

  getRecallDigest(days, 10)
    .then((digest) => {
      console.log(JSON.stringify(digest, null, 2));
    })
    .catch((err) => {
      console.error("Error:", err.message);
      process.exit(1);
    });
}

export type { RecallDigest, ThreadSummary, EvalSummary, CommitSummary };

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