director-kit 0.0.0-stage → 0.2.1

package/.claude-plugin/marketplace.json

@@ -0,0 +1,17 @@
+{
+  "name": "director-kit",
+  "owner": {
+    "name": "Vladislav Popov",
+    "url": "https://github.com/devladpopov"
+  },
+  "metadata": {
+    "description": "director-kit: CHECKPOINT protocol, memory floors and a cross-project board for Claude Code."
+  },
+  "plugins": [
+    {
+      "name": "director-kit",
+      "source": "./",
+      "description": "CHECKPOINT protocol, memory floors and a cross-project audit for Claude Code."
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "director-kit",
+  "version": "0.2.1",
+  "description": "CHECKPOINT protocol, memory floors and a cross-project audit for Claude Code. Sessions resume where they stopped and never redo finished steps.",
+  "author": { "name": "Vladislav Popov", "url": "https://github.com/devladpopov" },
+  "homepage": "https://github.com/devladpopov/director-kit",
+  "repository": "https://github.com/devladpopov/director-kit",
+  "license": "MIT",
+  "keywords": ["checkpoint", "memory", "audit", "dashboard"]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vladislav Popov
+
+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,90 @@
-# Temporary Holding Version
+# director-kit
 
-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.
+**One person, 214 projects, 3,790 commits in 30 days: the whole operating system is open.**
+
+<sup>Counted by `director-kit board` on the author's machine on 23 Oct 2026; worktrees share history, so each commit is counted once. Run it on yours.</sup>
+
+<!-- refresh both numbers and the date from a live `director-kit board` on release day, never type them by hand -->
+
+director-kit is the core of how I run every project with Claude Code: one board over all of them, and a protocol that makes every session resume exactly where the last one stopped and never redo finished work.
+
+```
+npx director-kit
+```
+
+Five minutes later you see a board of everything in your projects folder: what waits on you, what is active, what stalled, what is not backed up. It works on day zero, from git history alone. Nothing leaves your machine.
+
+![director-kit in 70 seconds](docs/screencast/director-kit.gif)
+
+70-second walkthrough on sample data ([mp4](docs/screencast/director-kit.mp4)). Still screenshot: [docs/board.png](docs/board.png).
+
+## What is inside
+
+| Part | What it does |
+|---|---|
+| **Board** | `~/.director-kit/board.html`, one static file. Columns: waiting on you, active, stalled, paused, done, dormant. Every card: task, next step, blocker, days silent, commits, risks. |
+| **Audit** | `director-kit audit`: markdown report. Waiting on you first, then stalled, then repos without a remote, unpushed or uncommitted work, memory indexes over their limit, stale backups. |
+| **CHECKPOINT protocol** | `CHECKPOINT.md` in each project: STATUS, TASK, LAST_ACTION, NEXT, DO_NOT_REDO, VERIFY_BEFORE_ACT. A SessionStart hook shows it to Claude before it acts. After compaction or a crash the session continues instead of starting over. |
+| **Memory floors** | Index under 6000 chars, topic files, archive. Never delete, move. Test memory before and after compressing it. |
+| **Backup watch** | `director-kit backup add <folder>`: the audit flags any backup whose newest file is older than the limit (26 h by default). |
+| **Templates** | `SOUL.md` (how the assistant behaves, what needs your yes), `VISION.md` (goal, criteria, constraints), `MEMORY.md`, `CHECKPOINT.md`. |
+
+## Install
+
+Board and audit (Node 18+, git):
+
+```
+npx director-kit            # asks for your projects folder, builds the board, opens it
+npx director-kit audit
+```
+
+Claude Code plugin (protocol, hook, `/director-kit:audit`, `/director-kit:board`, `/director-kit:checkpoint`):
+
+```
+claude plugin marketplace add devladpopov/director-kit
+claude plugin install director-kit@director-kit
+```
+
+## How status is decided
+
+A project is any subfolder with `.git` or `CHECKPOINT.md`.
+
+- With a CHECKPOINT: `STATUS` decides. `NEXT: await user input` puts it in **waiting on you**. In progress but silent longer than 7 days: **stalled**.
+- Without one: commits or edits in the last 7 days: **active**; 7 to 30 days: **stalled**; older: **dormant**.
+- Worktrees share history, so a commit is counted once.
+
+Limits live in `~/.director-kit/config.json`:
+
+```json
+{
+  "root": "/home/me/Projects",
+  "activeDays": 7,
+  "dormantDays": 30,
+  "memoryIndexLimit": 6000,
+  "backups": [{ "name": "photos to NAS", "path": "/mnt/nas/photos", "maxAgeHours": 26 }]
+}
+```
+
+## Commands
+
+```
+director-kit [root]           first run: pick folder, build board, open it
+director-kit board            rebuild the board
+director-kit audit            markdown audit, saved to ~/.director-kit/audits/
+director-kit checkpoint [dir] create CHECKPOINT.md from the template (never overwrites)
+director-kit doctor           check node, git, claude
+director-kit demo             board with sample data (~/.director-kit/demo/, for screenshots)
+director-kit backup add <path> [--name=nas] [--max-age=26]   watch a backup folder
+director-kit backup list | rm <name>                          OK / STALE per folder
+  --no-open  --json  --private (no absolute paths)  --root=<dir>
+```
+
+## Privacy
+
+The board is a local file. No telemetry, no network calls, no dependencies. `--private` strips absolute paths if you want to share a screenshot.
+
+## Want it set up for you?
+
+The full system also runs every project from Telegram topics with Claude, auto-resume and a director that audits all topics every 8 hours. That part is a done-for-you install: {INSTALL_LINK}.
+
+MIT

package/bin/director-kit.mjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+// director-kit: a board over all your projects in one command.
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn, execFileSync } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+import { fileURLToPath } from 'node:url';
+import { loadConfig, saveConfig, guessRoot, isDir, HOME, CONFIG_PATH } from '../lib/config.mjs';
+import { scanRoot } from '../lib/scan.mjs';
+import { buildBoard, writeBoard } from '../lib/board.mjs';
+import { renderAudit, backupFindings } from '../lib/audit.mjs';
+import { checkpointTemplate } from '../lib/checkpoint.mjs';
+import { demoScan } from '../lib/demo.mjs';
+
+const KIT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const argv = process.argv.slice(2);
+const flags = new Set(argv.filter((a) => a.startsWith('--')));
+const pos = argv.filter((a) => !a.startsWith('--'));
+const COMMANDS = ['init', 'board', 'audit', 'checkpoint', 'doctor', 'demo', 'backup', 'help'];
+const cmd = pos[0] && (COMMANDS.includes(pos[0]) || !isDir(pos[0])) ? pos.shift() : 'init';
+
+const HELP = `director-kit: one board over all your projects
+
+  director-kit [root]           first run: pick projects folder, build board, open it
+  director-kit board            rebuild board (~/.director-kit/board.html)
+  director-kit audit            markdown audit: waiting on you, stalled, not backed up
+  director-kit checkpoint [dir] create CHECKPOINT.md from template (does not overwrite)
+  director-kit doctor           check node, git, claude
+  director-kit demo             board with sample data (~/.director-kit/demo/, for screenshots)
+  director-kit backup add <path> [--name=photos] [--max-age=26]
+  director-kit backup list | rm <name|path>   folders the audit watches
+
+  --no-open   do not open the browser      --json   print board json
+  --private   no absolute paths in board   --root=<dir>  projects folder
+`;
+
+const has = (bin) => { try { execFileSync(bin, ['--version'], { stdio: 'ignore', timeout: 10000, shell: process.platform === 'win32' }); return true; } catch { return false; } };
+const flagVal = (k) => { const a = argv.find((x) => x.startsWith(`--${k}=`)); return a ? a.split('=').slice(1).join('=') : null; };
+
+function open(file) {
+  if (flags.has('--no-open') || process.env.CI) return;
+  const [c, a] = process.platform === 'win32' ? ['cmd', ['/c', 'start', '', file]] : process.platform === 'darwin' ? ['open', [file]] : ['xdg-open', [file]];
+  try { spawn(c, a, { stdio: 'ignore', detached: true }).unref(); } catch {}
+}
+
+async function build(cfg, scan, outDir = HOME) {
+  const board = buildBoard(scan || await scanRoot(cfg.root, cfg), { privatePaths: flags.has('--private') });
+  const out = writeBoard(board, outDir);
+  if (flags.has('--json')) console.log(JSON.stringify(board, null, 2));
+  const S = board.summary;
+  console.log(`${S.total} projects, ${S.commits30d} commits in 30 days | waiting on you ${S.waiting}, active ${S.active}, stalled ${S.stalled}, done ${S.done}, dormant ${S.dormant}, at risk ${S.atRisk}`);
+  console.log(`board: ${out.html}`);
+  return { board, out };
+}
+
+async function ask(q, dflt) {
+  if (!process.stdin.isTTY || flags.has('--yes')) return dflt;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const a = (await rl.question(`${q} [${dflt}] `)).trim();
+  rl.close();
+  return a || dflt;
+}
+
+async function init() {
+  const cfg = loadConfig();
+  let root = flagVal('root') || pos[0] || cfg.root;
+  if (!root) root = await ask('Projects folder:', guessRoot());
+  root = path.resolve(root);
+  if (!isDir(root)) { console.error(`not a folder: ${root}`); process.exit(1); }
+  cfg.root = root;
+  const saved = saveConfig(cfg);
+  console.log(`config: ${saved}`);
+  const { out, board } = await build(cfg);
+  if (!board.summary.total) console.log(`no projects found in ${root}: a project is a subfolder with .git or CHECKPOINT.md`);
+  open(out.html);
+  if (has('claude')) {
+    console.log('\nClaude Code found. Add the protocol (CHECKPOINT, memory floors, /audit) to every session:');
+    console.log('  claude plugin marketplace add devladpopov/director-kit');
+    console.log('  claude plugin install director-kit@director-kit');
+  }
+}
+
+const cmds = {
+  init,
+  async board() { const cfg = needRoot(); open((await build(cfg)).out.html); },
+  async audit() {
+    const cfg = needRoot();
+    const { board } = await build(cfg);
+    const { markdown } = renderAudit(board, cfg);
+    const dir = path.join(HOME, 'audits');
+    fs.mkdirSync(dir, { recursive: true });
+    const f = path.join(dir, `audit-${new Date().toISOString().slice(0, 10)}.md`);
+    fs.writeFileSync(f, markdown);
+    console.log('\n' + markdown + `\nsaved: ${f}`);
+  },
+  checkpoint() {
+    const dir = path.resolve(pos[0] || process.cwd());
+    const f = path.join(dir, 'CHECKPOINT.md');
+    if (fs.existsSync(f)) { console.log(`exists, not touched: ${f}`); return; }
+    fs.writeFileSync(f, checkpointTemplate());
+    console.log(`created: ${f}`);
+  },
+  doctor() {
+    const v = process.versions.node.split('.').map(Number);
+    console.log(`node ${process.versions.node} ${v[0] >= 18 ? 'OK' : 'FAIL: need 18+'}`);
+    console.log(`git ${has('git') ? 'OK' : 'missing: projects without CHECKPOINT.md will not be detected'}`);
+    console.log(`claude ${has('claude') ? 'OK' : 'not found (optional: the board works without it)'}`);
+    const cfg = loadConfig();
+    console.log(`config ${fs.existsSync(CONFIG_PATH) ? CONFIG_PATH + ' root=' + cfg.root : 'none yet: run director-kit'}`);
+    console.log(`kit ${KIT}`);
+  },
+  // Separate folder: the demo must never overwrite the real board.
+  async demo() { const cfg = loadConfig(); open((await build(cfg, demoScan(), path.join(HOME, 'demo'))).out.html); },
+  backup,
+  help() { console.log(HELP); },
+};
+
+// Backup watch: the audit flags a folder whose newest file is older than maxAgeHours.
+function backup() {
+  const [sub = 'list', target] = pos;
+  const cfg = loadConfig();
+  const list = cfg.backups || [];
+  if (sub === 'add') {
+    if (!target) { console.error('usage: director-kit backup add <path> [--name=...] [--max-age=hours]'); process.exit(1); }
+    const p = path.resolve(target);
+    if (!fs.existsSync(p)) console.log(`note: ${p} does not exist yet, the audit will report it as STALE until it does`);
+    const maxAgeHours = Number(flagVal('max-age') || 26);
+    if (!(maxAgeHours > 0)) { console.error('--max-age must be a number of hours'); process.exit(1); }
+    const entry = { name: flagVal('name') || path.basename(p), path: p, maxAgeHours };
+    const i = list.findIndex((b) => path.resolve(b.path) === p);
+    if (i >= 0) list[i] = entry; else list.push(entry);
+    cfg.backups = list;
+    saveConfig(cfg);
+    console.log(`${i >= 0 ? 'updated' : 'added'}: ${entry.name} (${p}), limit ${maxAgeHours}h`);
+  } else if (sub === 'rm' || sub === 'remove') {
+    const keep = list.filter((b) => b.name !== target && path.resolve(b.path) !== path.resolve(target || ''));
+    if (!target || keep.length === list.length) { console.error(`no backup named or at: ${target}`); process.exit(1); }
+    cfg.backups = keep;
+    saveConfig(cfg);
+    console.log(`removed: ${target}`);
+  } else if (sub === 'list') {
+    if (!list.length) { console.log('no backups watched yet: director-kit backup add <path>'); return; }
+    for (const b of backupFindings(list)) console.log(`${b.ok ? 'OK   ' : 'STALE'} ${b.name}: ${b.ageHours == null ? 'nothing found' : b.ageHours + 'h old'} (limit ${b.maxAgeHours}h) ${b.path}`);
+  } else { console.error(`unknown: backup ${sub}`); process.exit(1); }
+}
+
+function needRoot() {
+  const cfg = loadConfig();
+  if (flagVal('root')) cfg.root = path.resolve(flagVal('root'));
+  if (!cfg.root) { console.error('no projects folder yet: run "director-kit" first'); process.exit(1); }
+  return cfg;
+}
+
+if (flags.has('--help') || cmd === '-h') cmds.help();
+else if (!cmds[cmd]) { console.error(`unknown command: ${cmd}\n`); cmds.help(); process.exit(1); }
+else await cmds[cmd]();

package/bin/session-start.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// SessionStart hook: puts the project's CHECKPOINT.md in front of the model before it does anything.
+// stdout of a SessionStart hook is added to the session context.
+import path from 'node:path';
+import { readCheckpoint, statusOf } from '../lib/checkpoint.mjs';
+
+const dir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const cp = readCheckpoint(dir);
+
+if (!cp) {
+  console.log('[director-kit] No CHECKPOINT.md in this project. After the first significant task, write one (skill: checkpoint-protocol).');
+  process.exit(0);
+}
+
+const f = cp.fields;
+const st = statusOf(f.STATUS);
+const L = [`[director-kit] CHECKPOINT.md (${path.basename(dir)}), read before acting:`];
+for (const k of ['STATUS', 'TASK', 'DATE', 'LAST_ACTION', 'NEXT', 'BLOCKER', 'VERIFY_BEFORE_ACT']) if (f[k]) L.push(`${k}: ${f[k]}`);
+if (cp.lists.DO_NOT_REDO?.length) L.push('DO_NOT_REDO:', ...cp.lists.DO_NOT_REDO.map((x) => `- ${x}`));
+if (st === 'done') L.push('The task above is COMPLETED. Do not repeat it; wait for a new instruction.');
+else L.push('Continue from NEXT. Before any deploy, migration or delete, run VERIFY_BEFORE_ACT; skip steps that are already done.');
+console.log(L.join('\n'));

package/commands/audit.md

@@ -0,0 +1,4 @@
+---
+description: Audit all projects: waiting on you, stalled, not backed up, memory over the floor
+---
+Use the project-audit skill: run the audit and report waiting-on-you items first, then stalled, then not-safe repos, then memory and backups.

package/commands/board.md

@@ -0,0 +1,4 @@
+---
+description: Rebuild the director-kit board over all projects and open it
+---
+Run `node "${CLAUDE_PLUGIN_ROOT}/bin/director-kit.mjs" board` (fallback: `npx -y director-kit board`). Reply with the one summary line it prints and the path to board.html. Nothing else.

package/commands/checkpoint.md

@@ -0,0 +1,4 @@
+---
+description: Write or refresh CHECKPOINT.md for the current project from what was actually done
+---
+Use the checkpoint-protocol skill. If CHECKPOINT.md exists, rewrite it to the current state (new LAST_ACTION, NEXT, DO_NOT_REDO). If it does not, create it. Fill every field from real evidence in this session or the repo (git log, files); no placeholders, no secrets. Show the result.

package/hooks/hooks.json

@@ -0,0 +1,11 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          { "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/bin/session-start.mjs\"" }
+        ]
+      }
+    ]
+  }
+}

package/lib/audit.mjs

@@ -0,0 +1,71 @@
+// Audit: one markdown report over all projects. What needs you, what is stuck,
+// what is not backed up, which memory indexes outgrew their floor.
+import fs from 'node:fs';
+import path from 'node:path';
+
+const INDEX_FILES = ['CLAUDE.md', 'MEMORY.md', 'AGENTS.md'];
+
+export function memoryFindings(projects, limit) {
+  const out = [];
+  for (const p of projects) {
+    if (!p.path) continue;
+    for (const f of INDEX_FILES) {
+      try {
+        const n = fs.readFileSync(path.join(p.path, f), 'utf8').length;
+        if (n > limit) out.push({ project: p.name, file: f, chars: n });
+      } catch {}
+    }
+  }
+  return out;
+}
+
+// Newest file under a folder, depth-limited so a huge backup tree stays cheap.
+export function newestFile(dir, depth = 3) {
+  let best = null;
+  const walk = (d, left) => {
+    let entries;
+    try { entries = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) { if (left > 0) walk(p, left - 1); continue; }
+      try { const m = fs.statSync(p).mtimeMs; if (!best || m > best.mtime) best = { path: p, mtime: m }; } catch {}
+    }
+  };
+  try { if (fs.statSync(dir).isFile()) return { path: dir, mtime: fs.statSync(dir).mtimeMs }; } catch { return null; }
+  walk(dir, depth);
+  return best;
+}
+
+export function backupFindings(backups, now = Date.now()) {
+  return (backups || []).map((b) => {
+    const f = newestFile(b.path);
+    const ageH = f ? (now - f.mtime) / 36e5 : null;
+    const max = b.maxAgeHours || 26;
+    return { name: b.name || b.path, path: b.path, ageHours: ageH == null ? null : Math.round(ageH), maxAgeHours: max, ok: ageH != null && ageH <= max };
+  });
+}
+
+export function renderAudit(board, cfg, now = Date.now()) {
+  const P = board.projects;
+  const S = board.summary;
+  const L = [];
+  const line = (p, extra) => `- **${p.name}**${extra ? `: ${extra}` : ''}`;
+  L.push(`# Audit ${new Date(now).toISOString().slice(0, 16).replace('T', ' ')} UTC`, '');
+  L.push(`${S.total} projects, ${S.commits30d} commits in 30 days. Waiting on you ${S.waiting}, active ${S.active}, stalled ${S.stalled}, done ${S.done}, dormant ${S.dormant}.`, '');
+
+  const sect = (title, items) => { if (items.length) L.push(`## ${title} (${items.length})`, ...items, ''); };
+  sect('Waiting on you', P.filter((p) => p.status === 'waiting').map((p) => line(p, p.blocker || p.next || p.task)));
+  sect('Stalled', P.filter((p) => p.status === 'stalled').sort((a, b) => b.idleDays - a.idleDays)
+    .map((p) => line(p, `silent ${p.idleDays}d. ${p.next ? 'Next was: ' + p.next : p.task || ''}`.trim())));
+  sect('Not safe (no remote, unpushed or uncommitted work)', P.filter((p) => p.risks.length && p.status !== 'dormant').map((p) => line(p, p.risks.join(', '))));
+  sect('Active without a CHECKPOINT.md', P.filter((p) => !p.hasCheckpoint && ['active', 'stalled'].includes(p.status)).map((p) => line(p, `run: director-kit checkpoint "${p.path || p.name}"`)));
+
+  const mem = memoryFindings(P, cfg.memoryIndexLimit);
+  sect(`Memory indexes over ${cfg.memoryIndexLimit} chars (move details to topic files)`, mem.map((m) => `- **${m.project}/${m.file}**: ${m.chars} chars`));
+
+  const bk = backupFindings(cfg.backups, now);
+  sect('Backups', bk.map((b) => `- ${b.ok ? 'OK' : 'STALE'} **${b.name}**: ${b.ageHours == null ? 'nothing found at ' + b.path : `newest file ${b.ageHours}h old`} (limit ${b.maxAgeHours}h)`));
+  if (!bk.length) L.push('## Backups', '- not configured: add folders to "backups" in ~/.director-kit/config.json, see README', '');
+
+  return { markdown: L.join('\n'), memory: mem, backups: bk };
+}

package/lib/board.mjs

@@ -0,0 +1,101 @@
+// board.json + a single self-contained board.html (no server, no CDN, opens from disk).
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const COLUMNS = [
+  { id: 'waiting', label: 'Waiting on you' },
+  { id: 'active', label: 'Active' },
+  { id: 'stalled', label: 'Stalled' },
+  { id: 'paused', label: 'Paused' },
+  { id: 'done', label: 'Done' },
+  { id: 'dormant', label: 'Dormant' },
+];
+
+export function buildBoard(scan, { privatePaths = false } = {}) {
+  const unique = new Set();
+  for (const p of scan.projects) for (const h of p.git?.hashes || []) unique.add(h);
+  const projects = scan.projects.map((p) => {
+    const { hashes, ...g } = p.git || {};
+    return { ...p, git: p.git ? g : null, path: privatePaths ? undefined : p.path };
+  });
+  const count = (s) => projects.filter((p) => p.status === s).length;
+  const summary = Object.fromEntries(COLUMNS.map((c) => [c.id, count(c.id)]));
+  summary.total = projects.length;
+  // Worktrees share history, count each commit once. Data without hashes (demo) falls back to the sum.
+  summary.commits30d = unique.size || projects.reduce((n, p) => n + (p.git?.commits30d || 0), 0);
+  summary.withCheckpoint = projects.filter((p) => p.hasCheckpoint).length;
+  summary.atRisk = projects.filter((p) => p.risks.length).length;
+  return {
+    generatedAt: new Date().toISOString(),
+    root: privatePaths ? path.basename(scan.root) : scan.root,
+    summary,
+    columns: COLUMNS,
+    projects,
+  };
+}
+
+export function writeBoard(board, outDir) {
+  fs.mkdirSync(outDir, { recursive: true });
+  const json = path.join(outDir, 'board.json');
+  const html = path.join(outDir, 'board.html');
+  fs.writeFileSync(json, JSON.stringify(board, null, 2));
+  fs.writeFileSync(html, renderHtml(board));
+  return { json, html };
+}
+
+export function renderHtml(board) {
+  const data = JSON.stringify(board).replace(/</g, '\\u003c');
+  return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Board: ${board.summary.total} projects</title>
+<style>
+:root{--bg:#f6f7f9;--card:#fff;--ink:#16181d;--mute:#6b7280;--line:#e5e7eb;--warn:#b45309;--bad:#b91c1c;--ok:#15803d;--acc:#2563eb}
+@media (prefers-color-scheme:dark){:root{--bg:#0f1115;--card:#181b21;--ink:#e6e8ec;--mute:#9aa1ac;--line:#2a2f38;--warn:#f59e0b;--bad:#f87171;--ok:#4ade80;--acc:#60a5fa}}
+*{box-sizing:border-box}body{margin:0;font:14px/1.45 system-ui,-apple-system,Segoe UI,Roboto,sans-serif;background:var(--bg);color:var(--ink)}
+header{padding:20px 24px 8px;display:flex;flex-wrap:wrap;gap:16px;align-items:baseline}
+h1{font-size:22px;margin:0}.stat{color:var(--mute)}.stat b{color:var(--ink);font-size:18px}
+.tools{padding:0 24px 12px;display:flex;gap:8px}input{flex:1;max-width:360px;padding:8px 10px;border:1px solid var(--line);border-radius:8px;background:var(--card);color:var(--ink)}
+.cols{display:grid;grid-auto-flow:column;grid-auto-columns:minmax(260px,1fr);gap:12px;padding:0 24px 24px;overflow-x:auto}
+.col h2{font-size:13px;text-transform:uppercase;letter-spacing:.04em;color:var(--mute);margin:4px 0 8px}
+.card{background:var(--card);border:1px solid var(--line);border-radius:10px;padding:10px 12px;margin-bottom:8px}
+.card h3{font-size:14px;margin:0 0 4px;word-break:break-word}.t{color:var(--mute);font-size:12.5px;margin:2px 0}
+.meta{display:flex;flex-wrap:wrap;gap:6px;margin-top:6px;font-size:12px;color:var(--mute)}
+.pill{border:1px solid var(--line);border-radius:999px;padding:0 7px}.risk{color:var(--bad);border-color:currentColor}.blk{color:var(--warn)}
+.bar{height:4px;background:var(--line);border-radius:2px;margin-top:6px}.bar i{display:block;height:4px;background:var(--acc);border-radius:2px}
+footer{padding:0 24px 24px;color:var(--mute);font-size:12px}
+</style></head><body>
+<header><h1>Board</h1><span class="stat" id="stats"></span></header>
+<div class="tools"><input id="q" placeholder="Filter projects" autofocus></div>
+<div class="cols" id="cols"></div>
+<footer id="foot"></footer>
+<script id="data" type="application/json">${data}</script>
+<script>
+const B=JSON.parse(document.getElementById('data').textContent);
+const esc=s=>String(s??'').replace(/[&<>"]/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c]));
+const S=B.summary;
+document.getElementById('stats').innerHTML=[['projects',S.total],['commits in 30 days',S.commits30d],['waiting on you',S.waiting],['stalled',S.stalled],['at risk',S.atRisk]].map(([k,v])=>'<b>'+v+'</b> '+k).join(' &middot; ');
+document.getElementById('foot').textContent='Generated '+new Date(B.generatedAt).toLocaleString()+' from '+B.root+' by director-kit. '+S.withCheckpoint+' of '+S.total+' projects keep a CHECKPOINT.md.';
+function card(p){
+  const g=p.git||{};const idle=p.idleDays==null?'':(p.idleDays===0?'today':p.idleDays+'d ago');
+  return '<div class="card" data-q="'+esc((p.name+' '+(p.title||'')+' '+(p.task||'')+' '+(p.next||'')).toLowerCase())+'">'
+   +'<h3>'+esc(p.name)+'</h3>'
+   +(p.task?'<div class="t">'+esc(p.task)+'</div>':(p.title&&p.title!==p.name?'<div class="t">'+esc(p.title)+'</div>':''))
+   +(p.next?'<div class="t"><b>Next:</b> '+esc(p.next)+'</div>':(p.lastAction?'<div class="t">Last: '+esc(p.lastAction)+'</div>':''))
+   +(p.blocker?'<div class="t blk"><b>Blocker:</b> '+esc(p.blocker)+'</div>':'')
+   +(p.progress!=null?'<div class="bar"><i style="width:'+p.progress+'%"></i></div>':'')
+   +'<div class="meta">'+(idle?'<span class="pill">'+idle+'</span>':'')+(g.commits30d?'<span class="pill">'+g.commits30d+' commits/30d</span>':'')
+   +(p.hasCheckpoint?'':'<span class="pill">no checkpoint</span>')+p.risks.map(r=>'<span class="pill risk">'+esc(r)+'</span>').join('')+'</div></div>';
+}
+function render(q){
+  q=(q||'').toLowerCase();
+  document.getElementById('cols').innerHTML=B.columns.map(c=>{
+    const ps=B.projects.filter(p=>p.status===c.id).sort((a,b)=>(a.idleDays??1e9)-(b.idleDays??1e9));
+    if(!ps.length)return '';
+    return '<section class="col"><h2>'+esc(c.label)+' ('+ps.length+')</h2>'+ps.map(card).join('')+'</section>';
+  }).join('');
+  if(q)document.querySelectorAll('.card').forEach(el=>{el.style.display=el.dataset.q.includes(q)?'':'none'});
+}
+document.getElementById('q').addEventListener('input',e=>render(e.target.value));render();
+</script></body></html>
+`;
+}

package/lib/checkpoint.mjs

@@ -0,0 +1,61 @@
+// CHECKPOINT.md protocol: plain "KEY: value" lines, first occurrence wins.
+// List fields (DO_NOT_REDO) collect the "- item" lines that follow them.
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const FIELDS = ['STATUS', 'TASK', 'DATE', 'LAST_ACTION', 'NEXT', 'BLOCKER', 'PROGRESS', 'STAGE', 'GOAL', 'METRIC', 'VERIFY_BEFORE_ACT'];
+const LIST_FIELDS = new Set(['DO_NOT_REDO']);
+
+export function parseCheckpoint(text) {
+  const fields = {};
+  const lists = {};
+  let list = null;
+  for (const raw of String(text).replace(/^/, '').split(/\r?\n/)) {
+    const m = /^([A-Z][A-Z_]{1,24}):[ \t]*(.*)$/.exec(raw);
+    if (m) {
+      list = LIST_FIELDS.has(m[1]) ? (lists[m[1]] ||= []) : null;
+      if (!(m[1] in fields)) fields[m[1]] = m[2].trim();
+      continue;
+    }
+    const item = /^\s*[-*]\s+(.+)$/.exec(raw);
+    if (list && item) list.push(item[1].trim());
+    else if (raw.trim()) list = null;
+  }
+  return { fields, lists };
+}
+
+export function readCheckpoint(dir) {
+  const p = path.join(dir, 'CHECKPOINT.md');
+  try {
+    const text = fs.readFileSync(p, 'utf8');
+    return { path: p, mtime: fs.statSync(p).mtimeMs, ...parseCheckpoint(text) };
+  } catch {
+    return null;
+  }
+}
+
+// Normalised status: done | waiting | active | paused | unknown
+export function statusOf(raw) {
+  const s = String(raw || '').trim().split(/[\s(|]/)[0].toUpperCase();
+  if (!s) return 'unknown';
+  if (/^(COMPLETED|DONE|SHIPPED|CLOSED)$/.test(s)) return 'done';
+  if (/^(AWAITING|WAITING|BLOCKED|NEEDS)/.test(s)) return 'waiting';
+  if (/^(IN_PROGRESS|ACTIVE|WIP|STARTED)$/.test(s)) return 'active';
+  if (/^(PAUSED|DEFERRED|IDLE|ON_HOLD|NOT_STARTED)$/.test(s)) return 'paused';
+  return 'unknown';
+}
+
+export function checkpointTemplate({ task = '<what this project is doing right now>', date = new Date().toISOString() } = {}) {
+  return [
+    'STATUS: IN_PROGRESS',
+    `TASK: ${task}`,
+    `DATE: ${date}`,
+    'LAST_ACTION: <the last thing that was actually done>',
+    'NEXT: <the next concrete step, or "await user input">',
+    'BLOCKER: none',
+    'DO_NOT_REDO:',
+    '- <idempotent steps that are already done and must not be repeated>',
+    'VERIFY_BEFORE_ACT: <commands that check the current state before deploy/migration/delete>',
+    '',
+  ].join('\n');
+}

package/lib/config.mjs

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const HOME = process.env.DIRECTOR_KIT_HOME || path.join(os.homedir(), '.director-kit');
+const CONFIG = path.join(HOME, 'config.json');
+
+export const DEFAULTS = {
+  root: null,
+  activeDays: 7, // no commits / checkpoint edits for longer than this: stalled
+  dormantDays: 30, // longer than this without a checkpoint: dormant
+  memoryIndexLimit: 6000, // chars, the "index floor" of the memory floors
+  backups: [], // [{ name, path, maxAgeHours }]
+  skip: ['node_modules', '.git', '.cache', '.tmp', 'tmp'],
+};
+
+export function loadConfig() {
+  try {
+    return { ...DEFAULTS, ...JSON.parse(fs.readFileSync(CONFIG, 'utf8').replace(/^/, '')) };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+
+export function saveConfig(cfg) {
+  fs.mkdirSync(HOME, { recursive: true });
+  fs.writeFileSync(CONFIG, JSON.stringify(cfg, null, 2) + '\n');
+  return CONFIG;
+}
+
+// First existing folder that looks like a projects root.
+export function guessRoot(cwd = process.cwd()) {
+  const h = os.homedir();
+  const candidates = ['Projects', 'projects', 'code', 'Code', 'dev', 'src', 'repos', 'work', 'Documents/GitHub', 'GitHub']
+    .map((d) => path.join(h, d));
+  for (const c of candidates) if (isDir(c) && subdirs(c).length) return c;
+  return cwd;
+}
+
+export const isDir = (p) => { try { return fs.statSync(p).isDirectory(); } catch { return false; } };
+export const subdirs = (p) => { try { return fs.readdirSync(p, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name); } catch { return []; } };
+export { CONFIG as CONFIG_PATH };

package/lib/demo.mjs

@@ -0,0 +1,37 @@
+// Sample data for screenshots and the screencast: no real names, paths or people.
+const DAY = 864e5;
+const SAMPLE = [
+  ['landing-page', 'waiting', 0, 14, 'Publish the pricing page', 'Approve the copy for the hero block', 'you: approve copy'],
+  ['invoice-bot', 'active', 0, 31, 'Telegram bot that drafts invoices', 'Add VAT field to the PDF', null],
+  ['podcast-clips', 'active', 1, 22, 'Cut 5 clips per episode automatically', 'Tune the silence threshold', null],
+  ['crm-lite', 'active', 2, 18, 'Own CRM instead of a SaaS seat', 'Import contacts from CSV', null],
+  ['newsletter', 'waiting', 1, 3, 'Weekly newsletter #12', 'Pick the cover image', 'you: choose image'],
+  ['tax-2026', 'stalled', 9, 0, 'Self-assessment return', 'Download bank statements', null],
+  ['course-ai-basics', 'stalled', 12, 2, 'Module 3: agents', 'Record lesson 3.2', null],
+  ['scraper-jobs', 'active', 0, 40, 'Daily job board digest', 'Deduplicate by company', null],
+  ['home-server', 'done', 3, 5, 'Backups to object storage', null, null],
+  ['portfolio-site', 'done', 6, 9, 'Move to static hosting', null, null],
+  ['family-photos', 'paused', 20, 0, 'Sort 2019 archive', 'Resume after holidays', null],
+  ['old-game-jam', 'dormant', 140, 0, null, null, null],
+  ['dotfiles', 'dormant', 61, 0, null, null, null],
+];
+
+export function demoScan(now = Date.now()) {
+  const projects = SAMPLE.map(([name, status, idle, commits, task, next, blocker], i) => ({
+    name,
+    title: null,
+    path: `~/Projects/${name}`,
+    status,
+    hasCheckpoint: !!task,
+    task,
+    next,
+    lastAction: task ? 'see CHECKPOINT.md' : 'initial commit',
+    blocker,
+    progress: status === 'done' ? 100 : task ? (i * 17) % 90 + 5 : null,
+    lastActivity: new Date(now - idle * DAY).toISOString(),
+    idleDays: idle,
+    git: { branch: 'main', commits30d: commits, dirtyFiles: 0, hasRemote: name !== 'tax-2026', unpushed: name === 'crm-lite' ? 3 : 0 },
+    risks: name === 'tax-2026' ? ['no remote: not backed up'] : name === 'crm-lite' ? ['3 unpushed commits'] : [],
+  }));
+  return { root: '~/Projects (demo)', folders: projects.length, projects };
+}

package/lib/scan.mjs

@@ -0,0 +1,125 @@
+// Walks a projects root: every subfolder with a CHECKPOINT.md or a .git is a project.
+// Works on day zero: without checkpoints the status comes from git activity.
+// Git is the slow part, so projects are scanned in parallel and each needs only 4 git calls.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { readCheckpoint, statusOf } from './checkpoint.mjs';
+import { isDir, subdirs } from './config.mjs';
+
+const DAY = 864e5;
+
+const git = (dir, args) => new Promise((resolve) => {
+  execFile('git', ['-C', dir, ...args], { encoding: 'utf8', timeout: 15000, maxBuffer: 64 << 20, windowsHide: true },
+    (err, out) => resolve(err ? null : out.trim()));
+});
+
+export async function gitInfo(dir) {
+  if (!fs.existsSync(path.join(dir, '.git'))) return null;
+  const [last, recent, status, remotes] = await Promise.all([
+    git(dir, ['log', '-1', '--format=%cI%x09%s']),
+    git(dir, ['log', '--no-merges', '--since=30.days', '--format=%H']),
+    git(dir, ['status', '--porcelain=v2', '--branch']), // branch, ahead of upstream and dirty files in one call
+    git(dir, ['remote']),
+  ]);
+  const hashes = recent ? recent.split('\n').filter(Boolean) : [];
+  const lines = status ? status.split('\n').filter(Boolean) : [];
+  const header = (k) => lines.find((l) => l.startsWith(`# branch.${k} `))?.slice(`# branch.${k} `.length) ?? null;
+  const ab = /^\+(\d+) -\d+$/.exec(header('ab') || '');
+  const [lastDate, lastSubject] = last ? last.split('\t') : [null, null];
+  return {
+    branch: header('head') === '(detached)' ? 'HEAD' : header('head'),
+    lastCommit: lastDate || null,
+    lastSubject: lastSubject || null,
+    commits30d: hashes.length,
+    worktree: fs.statSync(path.join(dir, '.git')).isFile(), // linked worktree or submodule
+    hashes, // dropped from the board; counts unique commits across worktrees
+    dirtyFiles: lines.filter((l) => !l.startsWith('#')).length,
+    hasRemote: !!(remotes && remotes.length),
+    unpushed: ab ? Number(ab[1]) : null,
+  };
+}
+
+function firstHeading(dir) {
+  for (const f of ['README.md', 'readme.md', 'README']) {
+    try {
+      const m = /^#\s+(.+)$/m.exec(fs.readFileSync(path.join(dir, f), 'utf8'));
+      if (m) return m[1].trim();
+    } catch {}
+  }
+  return null;
+}
+
+export async function scanProject(dir, cfg, now = Date.now()) {
+  const cp = readCheckpoint(dir);
+  const g = await gitInfo(dir);
+  if (!cp && !g) return null;
+
+  const times = [cp?.mtime, g?.lastCommit && Date.parse(g.lastCommit)].filter(Boolean);
+  if (g?.dirtyFiles) times.push(newestMtime(dir));
+  const lastActivity = times.length ? Math.max(...times) : null;
+  const idleDays = lastActivity ? Math.floor((now - lastActivity) / DAY) : null;
+
+  let status = cp ? statusOf(cp.fields.STATUS) : 'unknown';
+  // "NEXT: await user input" means the ball is with you, not that the project is stuck.
+  if (cp && status !== 'done' && /^(await|waiting for|blocked on)\b/i.test(cp.fields.NEXT || '')) status = 'waiting';
+  if (status === 'unknown') status = idleDays == null || idleDays > cfg.dormantDays ? 'dormant' : 'active';
+  if (status === 'active' && idleDays != null && idleDays > cfg.activeDays) status = idleDays > cfg.dormantDays && !cp ? 'dormant' : 'stalled';
+
+  const risks = [];
+  if (g && !g.hasRemote) risks.push('no remote: not backed up');
+  if (g?.unpushed) risks.push(`${g.unpushed} unpushed commit${g.unpushed > 1 ? 's' : ''}`);
+  if (g?.dirtyFiles && idleDays != null && idleDays > 2) risks.push(`${g.dirtyFiles} uncommitted file${g.dirtyFiles > 1 ? 's' : ''} for ${idleDays}d`);
+
+  const f = cp?.fields || {};
+  return {
+    name: path.basename(dir),
+    title: firstHeading(dir),
+    path: dir,
+    status,
+    hasCheckpoint: !!cp,
+    task: f.TASK || null,
+    next: f.NEXT || null,
+    lastAction: f.LAST_ACTION || g?.lastSubject || null,
+    blocker: f.BLOCKER && !/^(none|no|-|n\/a)$/i.test(f.BLOCKER) ? f.BLOCKER : null,
+    progress: /^\d{1,3}/.test(f.PROGRESS || '') ? Math.min(100, parseInt(f.PROGRESS, 10)) : null,
+    lastActivity: lastActivity ? new Date(lastActivity).toISOString() : null,
+    idleDays,
+    git: g,
+    risks,
+  };
+}
+
+// Newest mtime among top-level files (cheap proxy for "someone is editing right now").
+function newestMtime(dir) {
+  let max = 0;
+  for (const f of safeList(dir)) {
+    if (f.startsWith('.')) continue;
+    try { max = Math.max(max, fs.statSync(path.join(dir, f)).mtimeMs); } catch {}
+  }
+  return max || null;
+}
+const safeList = (d) => { try { return fs.readdirSync(d); } catch { return []; } };
+
+// Runs fn over items with at most `limit` in flight, keeps order.
+async function pool(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  const worker = async () => { while (next < items.length) { const i = next++; out[i] = await fn(items[i]); } };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return out;
+}
+
+export async function scanRoot(root, cfg, now = Date.now()) {
+  const skip = new Set(cfg.skip || []);
+  const dirs = subdirs(root).filter((name) => !skip.has(name) && !name.startsWith('.')).map((name) => path.join(root, name));
+  const limit = cfg.concurrency || Math.max(4, Math.min(16, (os.availableParallelism?.() || os.cpus().length) * 2));
+  const projects = (await pool(dirs, limit, (d) => scanProject(d, cfg, now))).filter(Boolean);
+  // A root that is itself a single repo.
+  if (!projects.length && isDir(root)) {
+    const p = await scanProject(root, cfg, now);
+    if (p) projects.push(p);
+  }
+  return { root, folders: dirs.length, projects };
+}

package/package.json

@@ -1,6 +1,16 @@
 {
   "name": "director-kit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.1",
+  "description": "One board over all your projects, plus the CHECKPOINT and memory protocol that keeps Claude Code sessions from redoing work.",
+  "type": "module",
+  "bin": { "director-kit": "bin/director-kit.mjs" },
+  "files": ["bin", "lib", "templates", "skills", "commands", "hooks", ".claude-plugin"],
+  "scripts": { "test": "node test/smoke.mjs" },
+  "engines": { "node": ">=18" },
+  "keywords": ["claude-code", "claude-code-plugin", "dashboard", "kanban", "projects", "ai-agents"],
+  "license": "MIT",
+  "author": "Vladislav Popov (https://github.com/devladpopov)",
+  "homepage": "https://github.com/devladpopov/director-kit",
+  "repository": { "type": "git", "url": "git+https://github.com/devladpopov/director-kit.git" },
+  "bugs": "https://github.com/devladpopov/director-kit/issues"
+}

package/skills/checkpoint-protocol/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: checkpoint-protocol
+description: Keep CHECKPOINT.md in the project root so any new session, compaction or crash resumes exactly where work stopped and never repeats finished steps. Use after finishing a significant task, before a risky action, after context compaction or "continue where you left off", and when the user asks what state a project is in.
+---
+
+# CHECKPOINT protocol
+
+One file, `CHECKPOINT.md` in the project root, plain `KEY: value` lines. It is the single source of truth about where the work is. The director-kit board and audit read it, and the SessionStart hook shows it to you at the start of every session.
+
+## Format
+
+```
+STATUS: IN_PROGRESS | AWAITING_USER | COMPLETED | PAUSED
+TASK: <one line: what this project is doing now>
+DATE: <ISO timestamp of this update>
+LAST_ACTION: <the last thing actually done, with evidence: commit, URL, file>
+NEXT: <the next concrete step, or "await user input">
+BLOCKER: none | you: <what the user must do> | external: <who we wait for>
+DO_NOT_REDO:
+- <idempotent steps already done: "migration 012 applied", "email to X sent 21.10">
+VERIFY_BEFORE_ACT: <commands that check real state: git log -1, curl /health, list migrations>
+```
+
+Optional: `PROGRESS: 40%`, `GOAL:`, `METRIC: name | target | fact`.
+
+## Rules
+
+1. **Read first.** At session start, after compaction, or on "continue", read CHECKPOINT.md before anything else. If `STATUS: COMPLETED`, do not redo the work: say it is done and wait for a new instruction.
+2. **Verify before acting.** Before any deploy, migration, payment, message or delete, run `VERIFY_BEFORE_ACT` and compare with `DO_NOT_REDO`. If the goal is already reached, log "already done" and skip.
+3. **Never duplicate a successful side effect** (sent email, posted message, charged card) without a new explicit reason.
+4. **Rewrite on milestones.** After each significant step, rewrite the file: new LAST_ACTION, new NEXT, append to DO_NOT_REDO. Rewrite, do not append history: history belongs in git or an archive file.
+5. **Waiting is a status.** When the next step needs the user, set `STATUS: AWAITING_USER`, `NEXT: await user input` and say exactly what is needed in BLOCKER. The board puts it in "Waiting on you".
+6. **No secrets.** Never write tokens, passwords or personal data into CHECKPOINT.md. Point to where they live instead.
+
+## Creating one
+
+`director-kit checkpoint <dir>` writes the template without overwriting an existing file. Fill TASK, LAST_ACTION and NEXT from what you actually know; leave nothing as a placeholder.

package/skills/memory-floors/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: memory-floors
+description: Keep project memory in three floors (a small index, topic files, an archive) so it stays cheap to load and nothing is lost. Use when CLAUDE.md, MEMORY.md or another memory file grows past about 6000 characters, when saving a new long-lived fact, or when the user asks to clean up, compress or reorganise memory.
+---
+
+# Memory floors
+
+Memory that is loaded into every session must stay small, or every session pays for it and the important rules drown. Split it into floors.
+
+| Floor | File | Loaded | Limit | Holds |
+|---|---|---|---|---|
+| 1. Index | `CLAUDE.md` or `MEMORY.md` | every session | 6000 chars | rules that apply to every task + a map "topic -> file" |
+| 2. Topics | `memory/<topic>.md` | when the topic comes up | none, keep focused | details: accounts, decisions, how-tos, people |
+| 3. Archive | `memory/archive/<YYYY-MM>.md` | only on request | none | history, superseded decisions, old logs |
+
+## Rules
+
+1. **Index is a map, not a diary.** One line per topic: `- deploy: memory/deploy.md (servers, order of steps, rollback)`. Rules stay in the index only if they apply to almost every task.
+2. **Never delete, move.** When the index is over the limit, move the details down a floor and leave a one-line pointer. Superseded facts go to the archive with a date, not to the bin.
+3. **One fact, one place.** Before adding, search the topic files; update the existing entry instead of duplicating it.
+4. **Dates are absolute.** Write "2026-10-23", never "yesterday".
+5. **Test before and after.** Before compressing memory, write 3 to 5 questions a session must still answer from it (e.g. "where is the deploy key?", "what is forbidden without approval?"). Answer them from the old version, compress, answer again from the new one. If any answer got worse, put the fact back into the index.
+6. **No secrets in memory.** Point to where a secret lives (a password manager entry, an env file name), never paste the value.
+
+`director-kit audit` lists every index file that is over the limit.

package/skills/project-audit/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: project-audit
+description: Audit all projects at once (what waits on the user, what stalled, what is not backed up, which memory outgrew its floor) and turn it into a short action list. Use when the user asks "what is going on across my projects", "what is stuck", "what do I need to do", for a weekly review, or to refresh the director-kit board.
+---
+
+# Project audit
+
+Run the audit (it also rebuilds the board):
+
+```
+node "${CLAUDE_PLUGIN_ROOT}/bin/director-kit.mjs" audit --no-open
+```
+
+If `CLAUDE_PLUGIN_ROOT` is not set, use `npx -y director-kit audit --no-open`. If it says there is no projects folder yet, ask the user for it and run `... --root=<folder>` once.
+
+Then report to the user, shortest useful form:
+
+1. **Waiting on you**: one line each, the concrete action (from BLOCKER or NEXT). These come first, they are the only items nobody else can move.
+2. **Stalled**: the 3 to 5 longest-silent projects that are not finished, with the last NEXT. Ask whether to resume, pause (`STATUS: PAUSED`) or close (`STATUS: COMPLETED`) each one.
+3. **Not safe**: repos without a remote, unpushed commits, old uncommitted work. Offer the exact command (`git push`, create remote), do not run it without a yes.
+4. **Memory over the floor** and **stale backups**, if any.
+
+Do not change other projects' files during an audit. Changing a project's CHECKPOINT.md status is fine only when the user decided it.
+
+The board is at `~/.director-kit/board.html`; the full report is saved to `~/.director-kit/audits/`.

package/templates/CHECKPOINT.md

@@ -0,0 +1,9 @@
+STATUS: IN_PROGRESS
+TASK: <what this project is doing right now>
+DATE: 2026-01-01T00:00:00Z
+LAST_ACTION: <the last thing that was actually done>
+NEXT: <the next concrete step, or "await user input">
+BLOCKER: none
+DO_NOT_REDO:
+- <idempotent steps that are already done and must not be repeated>
+VERIFY_BEFORE_ACT: <commands that check the current state before deploy/migration/delete>

package/templates/MEMORY.md

@@ -0,0 +1,9 @@
+# MEMORY.md: index (floor 1, keep under 6000 characters)
+
+Rules that apply to almost every task, then a map to topic files. Details live in memory/<topic>.md, history in memory/archive/.
+
+## Rules
+- <rule that applies to every session>
+
+## Map
+- <topic>: memory/<topic>.md (<what is inside, 5 to 10 words>)

package/templates/SOUL.md

@@ -0,0 +1,25 @@
+# SOUL.md: who the assistant is in this workspace
+
+Loaded into every session. Keep it under 2000 characters.
+
+## Role
+<One line. Example: senior developer and personal assistant to <name>, works across all projects in this folder.>
+
+## How to talk to me
+- Language: <English / Russian / ...>
+- Style: facts and actions first, explanation after. No preamble, no "certainly", no emoji.
+- Length: short. A table when comparing options, prose otherwise.
+
+## What you may do without asking
+- Read anything in the projects folder, run tests, create files and branches, write drafts.
+
+## What needs my explicit "yes"
+- Money: payments, subscriptions, upgrades.
+- Deleting: files, branches, databases, servers, force push.
+- Anything public or irreversible: posts, emails to clients, production deploys without a backup.
+- When unsure, it is a "yes" question.
+
+## Habits
+- Read CHECKPOINT.md first; never redo what DO_NOT_REDO lists.
+- Verify the real state before acting; report results with evidence, including failures.
+- Save long-lived facts to memory (see memory-floors), never secrets.

package/templates/VISION.md

@@ -0,0 +1,15 @@
+# VISION.md: why this project exists
+
+The stable header of the project. Every session reads it first, so keep it under 1500 characters and change it rarely.
+
+## Goal
+<One sentence: what changes in the world when this is done.>
+
+## Success criteria
+- <Measurable: "20 paying users by 2026-12-01", "page loads under 1 s">
+
+## Constraints
+- <Budget, deadline, stack, things that are off-limits>
+
+## Not doing
+- <Explicitly out of scope, so sessions do not wander>