taskover-mcp 1.0.1 → 1.2.0

package/data-store.json-backup.js

@@ -0,0 +1,1264 @@
+const fs = require("fs");
+const path = require("path");
+
+// Data lives next to the app
+const DATA_DIR = path.join(__dirname, "..", "data");
+const DATA_FILE = path.join(DATA_DIR, "tracker.json");
+
+const EMPTY = {
+  projects: [],
+  tasks: [],
+  systems: [],
+  sessions: [],
+  changelog: [],
+  bugs: [],
+  decisions: [],
+  blueprints: [],
+  notes: [],
+  backups: [],
+  levels: [],
+  plugins: [],
+  buildErrors: [],
+  optimizeItems: [],
+  perfBudget: [],
+  playtests: [],
+  milestones: [],
+  iterations: [],
+  dialogues: [],
+  sounds: [],
+  controls: [],
+  assets: [],
+  refs: [],
+  marketingItems: [],
+  wikiPages: [],
+  shipChecked: [],
+  openQuestions: [],
+};
+
+// ===== CORE I/O =====
+
+function ensureDir() {
+  if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true });
+}
+
+function load() {
+  ensureDir();
+  if (!fs.existsSync(DATA_FILE)) {
+    fs.writeFileSync(DATA_FILE, JSON.stringify(EMPTY, null, 2));
+    return JSON.parse(JSON.stringify(EMPTY));
+  }
+  try {
+    const raw = fs.readFileSync(DATA_FILE, "utf-8");
+    const d = JSON.parse(raw);
+    // Ensure every key exists
+    for (const k of Object.keys(EMPTY)) {
+      if (!d[k]) d[k] = [];
+    }
+    return d;
+  } catch (e) {
+    console.error("Data load error:", e.message);
+    return JSON.parse(JSON.stringify(EMPTY));
+  }
+}
+
+function save(data) {
+  ensureDir();
+  fs.writeFileSync(DATA_FILE, JSON.stringify(data, null, 2));
+}
+
+function id() {
+  return Date.now().toString(36) + Math.random().toString(36).substr(2, 6);
+}
+function now() { return new Date().toISOString(); }
+function today() { return now().split("T")[0]; }
+
+// ===== PROJECTS =====
+
+function listProjects() {
+  return load().projects;
+}
+
+function getProject(pid) {
+  return load().projects.find(p => p.id === pid) || null;
+}
+
+function addProject({ name, description, trelloBoardId, status, ...extra }) {
+  const d = load();
+  const p = {
+    id: name.toLowerCase().replace(/[^a-z0-9]+/g, "-") + "-" + Date.now().toString(36),
+    name, description: description || "", trelloBoardId: trelloBoardId || "",
+    status: status || "active", createdAt: now(), lastUpdated: now(),
+    currentFocus: "", deadline: "", engine: "", icon: "", color: "#6EE7A0",
+    useMcp: true, guideLevel: 3, onboardDone: [], activityLog: [],
+    ...extra,
+  };
+  d.projects.push(p);
+  save(d);
+  return p;
+}
+
+function updateProject(pid, updates) {
+  const d = load();
+  const i = d.projects.findIndex(p => p.id === pid);
+  if (i === -1) return null;
+  d.projects[i] = { ...d.projects[i], ...updates, lastUpdated: now() };
+  save(d);
+  return d.projects[i];
+}
+
+// ===== TASKS (replaces To Do / Doing / Done / Scrapped) =====
+
+function getTasks(pid, statusFilter, phaseFilter) {
+  const d = load();
+  let tasks = d.tasks.filter(t => t.projectId === pid);
+  if (statusFilter) tasks = tasks.filter(t => t.status === statusFilter);
+  if (phaseFilter) tasks = tasks.filter(t => t.phase === phaseFilter);
+  return tasks;
+}
+
+function getTask(taskId) {
+  return load().tasks.find(t => t.id === taskId) || null;
+}
+
+function addTask({ projectId, title, description, status, phase, priority, tags, checklist }) {
+  const d = load();
+  const t = {
+    id: id(), projectId, title,
+    description: description || "",
+    status: status || "todo", // todo, doing, done, scrapped
+    phase: phase || "",       // "Phase 1 — Foundation", etc.
+    priority: priority || "medium",
+    tags: tags || [],
+    checklist: checklist || [], // [{text, done}]
+    comments: [],
+    createdAt: now(), lastUpdated: now(),
+  };
+  d.tasks.push(t);
+  save(d);
+  return t;
+}
+
+function updateTask(taskId, updates) {
+  const d = load();
+  const i = d.tasks.findIndex(t => t.id === taskId);
+  if (i === -1) return null;
+  d.tasks[i] = { ...d.tasks[i], ...updates, lastUpdated: now() };
+  save(d);
+  return d.tasks[i];
+}
+
+function moveTask(taskId, newStatus) {
+  return updateTask(taskId, { status: newStatus });
+}
+
+function addTaskComment(taskId, text) {
+  const d = load();
+  const i = d.tasks.findIndex(t => t.id === taskId);
+  if (i === -1) return null;
+  const comment = { id: id(), text, createdAt: now() };
+  d.tasks[i].comments.push(comment);
+  d.tasks[i].lastUpdated = now();
+  save(d);
+  return comment;
+}
+
+function updateChecklist(taskId, checklist) {
+  return updateTask(taskId, { checklist });
+}
+
+// ===== SYSTEMS (replaces Claude Memory documentation cards) =====
+
+function getSystems(pid) {
+  return load().systems.filter(s => s.projectId === pid);
+}
+
+function getSystem(sid) {
+  return load().systems.find(s => s.id === sid) || null;
+}
+
+function addSystem({ projectId, name, description, status, keyFiles, notes, criticalRules }) {
+  const d = load();
+  const s = {
+    id: id(), projectId, name,
+    description: description || "",
+    status: status || "planned", // working, wip, broken, planned
+    keyFiles: keyFiles || "",
+    notes: notes || "",
+    criticalRules: criticalRules || "",
+    createdAt: now(), lastUpdated: today(),
+  };
+  d.systems.push(s);
+  save(d);
+  return s;
+}
+
+function updateSystem(sid, updates) {
+  const d = load();
+  const i = d.systems.findIndex(s => s.id === sid);
+  if (i === -1) return null;
+  d.systems[i] = { ...d.systems[i], ...updates, lastUpdated: today() };
+  save(d);
+  return d.systems[i];
+}
+
+function deleteSystem(sid) {
+  const d = load();
+  d.systems = d.systems.filter(s => s.id !== sid);
+  save(d);
+  return true;
+}
+
+// ===== SESSIONS (replaces Claude Chat Memory) =====
+
+function getSessions(pid, limit) {
+  const d = load();
+  let s = d.sessions.filter(s => s.projectId === pid).sort((a, b) => b.date.localeCompare(a.date));
+  if (limit) s = s.slice(0, limit);
+  return s;
+}
+
+function getLastSession(pid) {
+  return getSessions(pid, 1)[0] || null;
+}
+
+function logSession({ projectId, title, summary, whatWeDid, whereWeLeftOff, nextSteps, systemsWorkedOn }) {
+  const d = load();
+  const s = {
+    id: id(), projectId, date: today(), timestamp: now(),
+    title, summary: summary || "",
+    whatWeDid: whatWeDid || [],
+    whereWeLeftOff: whereWeLeftOff || "",
+    nextSteps: nextSteps || [],
+    systemsWorkedOn: systemsWorkedOn || [],
+  };
+  d.sessions.push(s);
+  save(d);
+  return s;
+}
+
+function updateSession(sid, updates) {
+  const d = load();
+  const i = d.sessions.findIndex(s => s.id === sid);
+  if (i === -1) return null;
+  d.sessions[i] = { ...d.sessions[i], ...updates };
+  save(d);
+  return d.sessions[i];
+}
+
+// ===== CHANGELOG =====
+
+function getChangelog(pid, limit) {
+  const d = load();
+  let c = d.changelog.filter(c => c.projectId === pid).sort((a, b) => b.date.localeCompare(a.date));
+  if (limit) c = c.slice(0, limit);
+  return c;
+}
+
+function addChangelog({ projectId, title, changes, systemsAffected }) {
+  const d = load();
+  const c = {
+    id: id(), projectId, date: today(), timestamp: now(),
+    title, changes: changes || [], systemsAffected: systemsAffected || [],
+  };
+  d.changelog.push(c);
+  save(d);
+  return c;
+}
+
+// ===== BUGS =====
+
+function getBugs(pid, statusFilter) {
+  const d = load();
+  let bugs = d.bugs.filter(b => b.projectId === pid);
+  if (statusFilter) bugs = bugs.filter(b => b.status === statusFilter);
+  return bugs;
+}
+
+function addBug({ projectId, systemId, title, description, priority, stepsToReproduce }) {
+  const d = load();
+  const b = {
+    id: id(), projectId, systemId: systemId || "",
+    title, description: description || "",
+    priority: priority || "medium", status: "open",
+    stepsToReproduce: stepsToReproduce || "",
+    dateFound: today(), dateFixed: null, fixDescription: "",
+  };
+  d.bugs.push(b);
+  save(d);
+  return b;
+}
+
+function updateBug(bid, updates) {
+  const d = load();
+  const i = d.bugs.findIndex(b => b.id === bid);
+  if (i === -1) return null;
+  if (updates.status === "fixed" && !d.bugs[i].dateFixed) updates.dateFixed = today();
+  d.bugs[i] = { ...d.bugs[i], ...updates };
+  save(d);
+  return d.bugs[i];
+}
+
+function fixBug(bid, fixDescription) {
+  return updateBug(bid, { status: "fixed", fixDescription, dateFixed: today() });
+}
+
+// ===== DECISIONS =====
+
+function getDecisions(pid) {
+  return load().decisions.filter(d => d.projectId === pid).sort((a, b) => b.date.localeCompare(a.date));
+}
+
+function logDecision({ projectId, decision, context, systemId, alternatives }) {
+  const d = load();
+  const dec = {
+    id: id(), projectId, date: today(), timestamp: now(),
+    decision, context: context || "", systemId: systemId || "", alternatives: alternatives || "",
+  };
+  d.decisions.push(dec);
+  save(d);
+  return dec;
+}
+
+// ===== BLUEPRINTS =====
+
+function getBlueprints(pid) {
+  return load().blueprints.filter(b => b.projectId === pid);
+}
+
+function addBlueprint({ projectId, name, path, parentClass, systemId, description, variables, keyFunctions }) {
+  const d = load();
+  const bp = {
+    id: id(), projectId, name, path: path || "", parentClass: parentClass || "",
+    systemId: systemId || "", description: description || "",
+    variables: variables || [], keyFunctions: keyFunctions || [],
+    lastUpdated: today(),
+  };
+  d.blueprints.push(bp);
+  save(d);
+  return bp;
+}
+
+function updateBlueprint(bpid, updates) {
+  const d = load();
+  const i = d.blueprints.findIndex(b => b.id === bpid);
+  if (i === -1) return null;
+  d.blueprints[i] = { ...d.blueprints[i], ...updates, lastUpdated: today() };
+  save(d);
+  return d.blueprints[i];
+}
+
+// ===== BLUEPRINT GRAPHS =====
+
+function getBlueprintGraphs(bpid) {
+  const d = load();
+  const bp = d.blueprints.find(b => b.id === bpid);
+  if (!bp) return null;
+  return bp.graphs || [];
+}
+
+function setBlueprintGraph(bpid, { name, type, nodes, connections }) {
+  const d = load();
+  const i = d.blueprints.findIndex(b => b.id === bpid);
+  if (i === -1) return null;
+  if (!d.blueprints[i].graphs) d.blueprints[i].graphs = [];
+  const gIdx = d.blueprints[i].graphs.findIndex(g => g.name === name);
+  const graph = {
+    id: gIdx >= 0 ? d.blueprints[i].graphs[gIdx].id : id(),
+    name,
+    type: type || "event",
+    nodes: nodes || [],
+    connections: connections || [],
+    viewport: gIdx >= 0 ? d.blueprints[i].graphs[gIdx].viewport : { x: 0, y: 0, zoom: 1 },
+  };
+  if (gIdx >= 0) {
+    d.blueprints[i].graphs[gIdx] = graph;
+  } else {
+    d.blueprints[i].graphs.push(graph);
+  }
+  d.blueprints[i].lastUpdated = today();
+  save(d);
+  return graph;
+}
+
+function addGraphNodes(bpid, graphName, { nodes, connections }) {
+  const d = load();
+  const i = d.blueprints.findIndex(b => b.id === bpid);
+  if (i === -1) return null;
+  if (!d.blueprints[i].graphs) d.blueprints[i].graphs = [];
+  const gIdx = d.blueprints[i].graphs.findIndex(g => g.name === graphName);
+  if (gIdx === -1) return null;
+  if (nodes && nodes.length > 0) d.blueprints[i].graphs[gIdx].nodes.push(...nodes);
+  if (connections && connections.length > 0) d.blueprints[i].graphs[gIdx].connections.push(...connections);
+  d.blueprints[i].lastUpdated = today();
+  save(d);
+  return d.blueprints[i].graphs[gIdx];
+}
+
+// ===== NOTES (replaces Trello comments / general docs) =====
+
+function getNotes(pid, parentType, parentId) {
+  const d = load();
+  let notes = d.notes.filter(n => n.projectId === pid);
+  if (parentType) notes = notes.filter(n => n.parentType === parentType);
+  if (parentId) notes = notes.filter(n => n.parentId === parentId);
+  return notes.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+
+function addNote({ projectId, parentType, parentId, title, content }) {
+  const d = load();
+  const n = {
+    id: id(), projectId,
+    parentType: parentType || "project", // project, system, task, blueprint
+    parentId: parentId || projectId,
+    title: title || "", content: content || "",
+    createdAt: now(),
+  };
+  d.notes.push(n);
+  save(d);
+  return n;
+}
+
+// ===== BACKUPS =====
+
+function getBackups(pid) {
+  return load().backups.filter(b => b.projectId === pid).sort((a, b) => b.date.localeCompare(a.date));
+}
+
+function logBackup({ projectId, title, description }) {
+  const d = load();
+  const b = {
+    id: id(), projectId, date: today(), timestamp: now(),
+    title: title || `Backup — ${today()}`,
+    description: description || "",
+  };
+  d.backups.push(b);
+  save(d);
+  return b;
+}
+
+// ===== LEVELS =====
+
+function getLevels(pid) {
+  return load().levels.filter(l => l.projectId === pid);
+}
+
+function addLevel({ projectId, name, map, actorCount, status }) {
+  const d = load();
+  const l = {
+    id: id(), projectId, name,
+    map: map || "",
+    actorCount: actorCount || 0,
+    status: status || "planned", // wip, done, planned
+    actors: [],
+    createdAt: now(), lastUpdated: now(),
+  };
+  d.levels.push(l);
+  save(d);
+  return l;
+}
+
+function updateLevel(lid, updates) {
+  const d = load();
+  const i = d.levels.findIndex(l => l.id === lid);
+  if (i === -1) return null;
+  d.levels[i] = { ...d.levels[i], ...updates, lastUpdated: now() };
+  save(d);
+  return d.levels[i];
+}
+
+function addActor(lid, { name, x, y, z, notes }) {
+  const d = load();
+  const i = d.levels.findIndex(l => l.id === lid);
+  if (i === -1) return null;
+  const actor = { name, x: x || 0, y: y || 0, z: z || 0, notes: notes || "" };
+  d.levels[i].actors.push(actor);
+  d.levels[i].lastUpdated = now();
+  save(d);
+  return actor;
+}
+
+function removeActor(lid, actorIndex) {
+  const d = load();
+  const i = d.levels.findIndex(l => l.id === lid);
+  if (i === -1) return null;
+  if (actorIndex < 0 || actorIndex >= d.levels[i].actors.length) return null;
+  const removed = d.levels[i].actors.splice(actorIndex, 1)[0];
+  d.levels[i].lastUpdated = now();
+  save(d);
+  return removed;
+}
+
+// ===== PLUGINS =====
+
+function getPlugins(pid) {
+  return load().plugins.filter(p => p.projectId === pid);
+}
+
+function addPlugin({ projectId, name, version, source, dependents }) {
+  const d = load();
+  const pl = {
+    id: id(), projectId, name,
+    version: version || "",
+    source: source || "",
+    dependents: dependents || [],
+    createdAt: now(), lastUpdated: now(),
+  };
+  d.plugins.push(pl);
+  save(d);
+  return pl;
+}
+
+function updatePlugin(plid, updates) {
+  const d = load();
+  const i = d.plugins.findIndex(p => p.id === plid);
+  if (i === -1) return null;
+  d.plugins[i] = { ...d.plugins[i], ...updates, lastUpdated: now() };
+  save(d);
+  return d.plugins[i];
+}
+
+function deletePlugin(plid) {
+  const d = load();
+  d.plugins = d.plugins.filter(p => p.id !== plid);
+  save(d);
+  return true;
+}
+
+// ===== BUILD ERRORS =====
+
+function getBuildErrors(pid, statusFilter) {
+  const d = load();
+  let errors = d.buildErrors.filter(e => e.projectId === pid);
+  if (statusFilter) errors = errors.filter(e => e.status === statusFilter);
+  return errors;
+}
+
+function addBuildError({ projectId, error, bp }) {
+  const d = load();
+  const e = {
+    id: id(), projectId,
+    error: error || "",
+    bp: bp || "",
+    status: "open", // open, fixed
+    fix: "",
+    date: today(),
+    createdAt: now(),
+  };
+  d.buildErrors.push(e);
+  save(d);
+  return e;
+}
+
+function fixBuildError(eid, fix) {
+  const d = load();
+  const i = d.buildErrors.findIndex(e => e.id === eid);
+  if (i === -1) return null;
+  d.buildErrors[i].status = "fixed";
+  d.buildErrors[i].fix = fix || "";
+  save(d);
+  return d.buildErrors[i];
+}
+
+// ===== OPTIMIZE ITEMS =====
+
+function getOptimizeItems(pid) {
+  return load().optimizeItems.filter(o => o.projectId === pid);
+}
+
+function addOptimizeItem({ projectId, title, category, status, savings }) {
+  const d = load();
+  const o = {
+    id: id(), projectId, title,
+    category: category || "",
+    status: status || "open", // open, fixed, ok
+    savings: savings || "",
+    date: today(),
+    createdAt: now(),
+  };
+  d.optimizeItems.push(o);
+  save(d);
+  return o;
+}
+
+function updateOptimizeItem(oid, updates) {
+  const d = load();
+  const i = d.optimizeItems.findIndex(o => o.id === oid);
+  if (i === -1) return null;
+  d.optimizeItems[i] = { ...d.optimizeItems[i], ...updates };
+  save(d);
+  return d.optimizeItems[i];
+}
+
+// ===== PERF BUDGET =====
+
+function getPerfBudget(pid) {
+  return load().perfBudget.filter(p => p.projectId === pid);
+}
+
+function addPerfBudget({ projectId, scene, fps, gpu, memory, notes }) {
+  const d = load();
+  const pb = {
+    id: id(), projectId,
+    scene: scene || "",
+    fps: fps || 0,
+    gpu: gpu || 0,
+    memory: memory || 0,
+    date: today(),
+    notes: notes || "",
+    createdAt: now(),
+  };
+  d.perfBudget.push(pb);
+  save(d);
+  return pb;
+}
+
+function updatePerfBudget(pbid, updates) {
+  const d = load();
+  const i = d.perfBudget.findIndex(p => p.id === pbid);
+  if (i === -1) return null;
+  d.perfBudget[i] = { ...d.perfBudget[i], ...updates };
+  save(d);
+  return d.perfBudget[i];
+}
+
+// ===== PLAYTESTS =====
+
+function getPlaytests(pid) {
+  return load().playtests.filter(p => p.projectId === pid);
+}
+
+function addPlaytest({ projectId, duration, issues, rating, notes, tester, buildVersion }) {
+  const d = load();
+  const pt = {
+    id: id(), projectId,
+    date: today(),
+    duration: duration || "",
+    issues: issues || [],
+    rating: rating || 0,
+    notes: notes || "",
+    tester: tester || "",
+    buildVersion: buildVersion || "",
+    createdAt: now(),
+  };
+  d.playtests.push(pt);
+  save(d);
+  return pt;
+}
+
+// ===== MILESTONES =====
+
+function getMilestones(pid) {
+  return load().milestones.filter(m => m.projectId === pid);
+}
+
+function addMilestone({ projectId, title, date, status, notes }) {
+  const d = load();
+  const m = {
+    id: id(), projectId, title,
+    date: date || today(),
+    status: status || "upcoming", // upcoming, active, done, missed
+    notes: notes || "",
+    createdAt: now(),
+  };
+  d.milestones.push(m);
+  save(d);
+  return m;
+}
+
+function updateMilestone(mid, updates) {
+  const d = load();
+  const i = d.milestones.findIndex(m => m.id === mid);
+  if (i === -1) return null;
+  d.milestones[i] = { ...d.milestones[i], ...updates };
+  save(d);
+  return d.milestones[i];
+}
+
+// ===== ITERATIONS =====
+
+function getIterations(pid) {
+  return load().iterations.filter(it => it.projectId === pid);
+}
+
+function addIteration({ projectId, feature, version, change, reason }) {
+  const d = load();
+  const it = {
+    id: id(), projectId,
+    feature: feature || "",
+    version: version || "",
+    change: change || "",
+    reason: reason || "",
+    date: today(),
+    createdAt: now(),
+  };
+  d.iterations.push(it);
+  save(d);
+  return it;
+}
+
+// ===== DIALOGUES =====
+
+function getDialogues(pid) {
+  return load().dialogues.filter(dl => dl.projectId === pid);
+}
+
+function addDialogue({ projectId, npc, line, choices, nextNode, notes }) {
+  const d = load();
+  const dl = {
+    id: id(), projectId,
+    npc: npc || "",
+    line: line || "",
+    choices: choices || [],
+    nextNode: nextNode || "",
+    notes: notes || "",
+    createdAt: now(),
+  };
+  d.dialogues.push(dl);
+  save(d);
+  return dl;
+}
+
+function updateDialogue(did, updates) {
+  const d = load();
+  const i = d.dialogues.findIndex(dl => dl.id === did);
+  if (i === -1) return null;
+  d.dialogues[i] = { ...d.dialogues[i], ...updates };
+  save(d);
+  return d.dialogues[i];
+}
+
+// ===== SOUNDS =====
+
+function getSounds(pid) {
+  return load().sounds.filter(s => s.projectId === pid);
+}
+
+function addSound({ projectId, name, actor, trigger, spatial, attenuation, notes }) {
+  const d = load();
+  const s = {
+    id: id(), projectId, name,
+    actor: actor || "",
+    trigger: trigger || "",
+    spatial: spatial || false,
+    attenuation: attenuation || "",
+    notes: notes || "",
+    createdAt: now(),
+  };
+  d.sounds.push(s);
+  save(d);
+  return s;
+}
+
+function updateSound(sid, updates) {
+  const d = load();
+  const i = d.sounds.findIndex(s => s.id === sid);
+  if (i === -1) return null;
+  d.sounds[i] = { ...d.sounds[i], ...updates };
+  save(d);
+  return d.sounds[i];
+}
+
+// ===== CONTROLS =====
+
+function getControls(pid) {
+  return load().controls.filter(c => c.projectId === pid);
+}
+
+function addControl({ projectId, key, action, context, condition }) {
+  const d = load();
+  const c = {
+    id: id(), projectId,
+    key: key || "",
+    action: action || "",
+    context: context || "",
+    condition: condition || "",
+    createdAt: now(),
+  };
+  d.controls.push(c);
+  save(d);
+  return c;
+}
+
+function updateControl(cid, updates) {
+  const d = load();
+  const i = d.controls.findIndex(c => c.id === cid);
+  if (i === -1) return null;
+  d.controls[i] = { ...d.controls[i], ...updates };
+  save(d);
+  return d.controls[i];
+}
+
+// ===== ASSETS =====
+
+function getAssets(pid) {
+  return load().assets.filter(a => a.projectId === pid);
+}
+
+function addAsset({ projectId, name, type, path, size, status, usedBy }) {
+  const d = load();
+  const a = {
+    id: id(), projectId, name,
+    type: type || "",
+    path: path || "",
+    size: size || "",
+    status: status || "concept", // concept, imported, integrated, tested, final
+    usedBy: usedBy || "",
+    createdAt: now(), lastUpdated: now(),
+  };
+  d.assets.push(a);
+  save(d);
+  return a;
+}
+
+function updateAsset(aid, updates) {
+  const d = load();
+  const i = d.assets.findIndex(a => a.id === aid);
+  if (i === -1) return null;
+  d.assets[i] = { ...d.assets[i], ...updates, lastUpdated: now() };
+  save(d);
+  return d.assets[i];
+}
+
+// ===== REFERENCES =====
+
+function getRefs(pid) {
+  return load().refs.filter(r => r.projectId === pid);
+}
+
+function addRef({ projectId, title, type, url, notes }) {
+  const d = load();
+  const r = {
+    id: id(), projectId,
+    title: title || "",
+    type: type || "Article", // Game, Art, Video, Article
+    url: url || "",
+    notes: notes || "",
+    createdAt: now(),
+  };
+  d.refs.push(r);
+  save(d);
+  return r;
+}
+
+// ===== MARKETING ITEMS =====
+
+function getMarketingItems(pid) {
+  return load().marketingItems.filter(m => m.projectId === pid);
+}
+
+function addMarketingItem({ projectId, item, category, status, notes }) {
+  const d = load();
+  const m = {
+    id: id(), projectId,
+    item: item || "",
+    category: category || "Steam", // Steam, Trailer, Social, Press
+    status: status || "todo", // todo, doing, done
+    notes: notes || "",
+    createdAt: now(),
+  };
+  d.marketingItems.push(m);
+  save(d);
+  return m;
+}
+
+function updateMarketingItem(mid, updates) {
+  const d = load();
+  const i = d.marketingItems.findIndex(m => m.id === mid);
+  if (i === -1) return null;
+  d.marketingItems[i] = { ...d.marketingItems[i], ...updates };
+  save(d);
+  return d.marketingItems[i];
+}
+
+// ===== WIKI PAGES =====
+
+function getWikiPages(pid) {
+  return load().wikiPages.filter(w => w.projectId === pid);
+}
+
+function addWikiPage({ projectId, title, category, content }) {
+  const d = load();
+  const w = {
+    id: id(), projectId,
+    title: title || "",
+    category: category || "Reference", // Systems, Workflows, Guides, Reference
+    content: content || "",
+    createdAt: now(), lastUpdated: now(),
+  };
+  d.wikiPages.push(w);
+  save(d);
+  return w;
+}
+
+function updateWikiPage(wid, updates) {
+  const d = load();
+  const i = d.wikiPages.findIndex(w => w.id === wid);
+  if (i === -1) return null;
+  d.wikiPages[i] = { ...d.wikiPages[i], ...updates, lastUpdated: now() };
+  save(d);
+  return d.wikiPages[i];
+}
+
+// ===== SHIP CHECKED =====
+
+function getShipChecked(pid) {
+  return load().shipChecked.filter(s => s.projectId === pid).map(s => s.stepId);
+}
+
+function toggleShipCheck(pid, stepId) {
+  const d = load();
+  const i = d.shipChecked.findIndex(s => s.projectId === pid && s.stepId === stepId);
+  if (i >= 0) {
+    d.shipChecked.splice(i, 1);
+    save(d);
+    return { checked: false, stepId };
+  } else {
+    d.shipChecked.push({ projectId: pid, stepId });
+    save(d);
+    return { checked: true, stepId };
+  }
+}
+
+// ===== OPEN QUESTIONS =====
+
+function getOpenQuestions(pid) {
+  return load().openQuestions.filter(q => q.projectId === pid);
+}
+
+function addOpenQuestion({ projectId, text }) {
+  const d = load();
+  const q = {
+    id: id(), projectId,
+    text: text || "",
+    resolved: false,
+    date: today(),
+    createdAt: now(),
+  };
+  d.openQuestions.push(q);
+  save(d);
+  return q;
+}
+
+function toggleQuestion(qid) {
+  const d = load();
+  const i = d.openQuestions.findIndex(q => q.id === qid);
+  if (i === -1) return null;
+  d.openQuestions[i].resolved = !d.openQuestions[i].resolved;
+  save(d);
+  return d.openQuestions[i];
+}
+
+// ===== HELPER FUNCTIONS =====
+
+function updateProjectField(pid, field, value) {
+  const d = load();
+  const i = d.projects.findIndex(p => p.id === pid);
+  if (i === -1) return null;
+  d.projects[i][field] = value;
+  d.projects[i].lastUpdated = now();
+  save(d);
+  return d.projects[i];
+}
+
+function logActivity(pid, action, detail) {
+  const d = load();
+  const i = d.projects.findIndex(p => p.id === pid);
+  if (i === -1) return null;
+  if (!d.projects[i].activityLog) d.projects[i].activityLog = [];
+  const entry = { action, detail: detail || "", timestamp: now() };
+  d.projects[i].activityLog.push(entry);
+  d.projects[i].lastUpdated = now();
+  save(d);
+  return entry;
+}
+
+// ===== SEARCH =====
+
+function search(pid, query) {
+  const d = load();
+  const q = query.toLowerCase();
+  const results = [];
+
+  const match = (text) => text && text.toLowerCase().includes(q);
+
+  d.tasks.filter(t => t.projectId === pid).forEach(t => {
+    if (match(t.title) || match(t.description)) results.push({ type: "task", id: t.id, title: t.title, status: t.status });
+  });
+  d.systems.filter(s => s.projectId === pid).forEach(s => {
+    if (match(s.name) || match(s.description) || match(s.notes) || match(s.criticalRules))
+      results.push({ type: "system", id: s.id, title: s.name, status: s.status });
+  });
+  d.sessions.filter(s => s.projectId === pid).forEach(s => {
+    if (match(s.title) || match(s.summary) || match(s.whereWeLeftOff))
+      results.push({ type: "session", id: s.id, title: s.title, date: s.date });
+  });
+  d.bugs.filter(b => b.projectId === pid).forEach(b => {
+    if (match(b.title) || match(b.description))
+      results.push({ type: "bug", id: b.id, title: b.title, status: b.status });
+  });
+  d.blueprints.filter(b => b.projectId === pid).forEach(b => {
+    if (match(b.name) || match(b.description) || match(b.path))
+      results.push({ type: "blueprint", id: b.id, title: b.name, path: b.path });
+  });
+  d.notes.filter(n => n.projectId === pid).forEach(n => {
+    if (match(n.title) || match(n.content))
+      results.push({ type: "note", id: n.id, title: n.title || "(untitled)" });
+  });
+
+  // Search across new collections
+  d.levels.filter(l => l.projectId === pid).forEach(l => {
+    if (match(l.name) || match(l.map))
+      results.push({ type: "level", id: l.id, title: l.name, status: l.status });
+  });
+  d.plugins.filter(p => p.projectId === pid).forEach(p => {
+    if (match(p.name) || match(p.source))
+      results.push({ type: "plugin", id: p.id, title: p.name, version: p.version });
+  });
+  d.buildErrors.filter(e => e.projectId === pid).forEach(e => {
+    if (match(e.error) || match(e.bp) || match(e.fix))
+      results.push({ type: "buildError", id: e.id, title: e.error, status: e.status });
+  });
+  d.optimizeItems.filter(o => o.projectId === pid).forEach(o => {
+    if (match(o.title) || match(o.category) || match(o.savings))
+      results.push({ type: "optimizeItem", id: o.id, title: o.title, status: o.status });
+  });
+  d.perfBudget.filter(p => p.projectId === pid).forEach(p => {
+    if (match(p.scene) || match(p.notes))
+      results.push({ type: "perfBudget", id: p.id, title: p.scene, date: p.date });
+  });
+  d.playtests.filter(p => p.projectId === pid).forEach(p => {
+    if (match(p.notes) || match(p.tester) || match(p.buildVersion))
+      results.push({ type: "playtest", id: p.id, title: `Playtest ${p.date}`, date: p.date });
+  });
+  d.milestones.filter(m => m.projectId === pid).forEach(m => {
+    if (match(m.title) || match(m.notes))
+      results.push({ type: "milestone", id: m.id, title: m.title, status: m.status });
+  });
+  d.iterations.filter(it => it.projectId === pid).forEach(it => {
+    if (match(it.feature) || match(it.change) || match(it.reason))
+      results.push({ type: "iteration", id: it.id, title: it.feature, version: it.version });
+  });
+  d.dialogues.filter(dl => dl.projectId === pid).forEach(dl => {
+    if (match(dl.npc) || match(dl.line) || match(dl.notes))
+      results.push({ type: "dialogue", id: dl.id, title: dl.npc + ": " + (dl.line || "").substring(0, 50) });
+  });
+  d.sounds.filter(s => s.projectId === pid).forEach(s => {
+    if (match(s.name) || match(s.actor) || match(s.trigger) || match(s.notes))
+      results.push({ type: "sound", id: s.id, title: s.name });
+  });
+  d.controls.filter(c => c.projectId === pid).forEach(c => {
+    if (match(c.key) || match(c.action) || match(c.context))
+      results.push({ type: "control", id: c.id, title: c.key + " → " + c.action });
+  });
+  d.assets.filter(a => a.projectId === pid).forEach(a => {
+    if (match(a.name) || match(a.type) || match(a.path))
+      results.push({ type: "asset", id: a.id, title: a.name, status: a.status });
+  });
+  d.refs.filter(r => r.projectId === pid).forEach(r => {
+    if (match(r.title) || match(r.url) || match(r.notes))
+      results.push({ type: "ref", id: r.id, title: r.title, type: r.type });
+  });
+  d.marketingItems.filter(m => m.projectId === pid).forEach(m => {
+    if (match(m.item) || match(m.category) || match(m.notes))
+      results.push({ type: "marketingItem", id: m.id, title: m.item, status: m.status });
+  });
+  d.wikiPages.filter(w => w.projectId === pid).forEach(w => {
+    if (match(w.title) || match(w.content))
+      results.push({ type: "wikiPage", id: w.id, title: w.title, category: w.category });
+  });
+  d.openQuestions.filter(oq => oq.projectId === pid).forEach(oq => {
+    if (match(oq.text))
+      results.push({ type: "openQuestion", id: oq.id, title: oq.text, resolved: oq.resolved });
+  });
+
+  return results;
+}
+
+// ===== CONTEXT EXPORT =====
+
+function contextExport(pid) {
+  const d = load();
+  const proj = d.projects.find(p => p.id === pid);
+  if (!proj) return "Project not found.";
+
+  const systems = d.systems.filter(s => s.projectId === pid);
+  const openBugs = d.bugs.filter(b => b.projectId === pid && b.status === "open");
+  const sessions = d.sessions.filter(s => s.projectId === pid).sort((a, b) => b.date.localeCompare(a.date));
+  const decisions = d.decisions.filter(dd => dd.projectId === pid);
+  const bps = d.blueprints.filter(b => b.projectId === pid);
+  const doingTasks = d.tasks.filter(t => t.projectId === pid && t.status === "doing");
+  const last = sessions[0];
+
+  const levels = d.levels.filter(l => l.projectId === pid);
+  const plugins = d.plugins.filter(p => p.projectId === pid);
+  const openQuestions = d.openQuestions.filter(q => q.projectId === pid && !q.resolved);
+  const optimizeItems = d.optimizeItems.filter(o => o.projectId === pid && o.status === "open");
+
+  let out = `PROJECT: ${proj.name} — ${proj.description}\n`;
+  if (proj.trelloBoardId) out += `Trello Board ID: ${proj.trelloBoardId}\n`;
+  if (proj.engine) out += `Engine: ${proj.engine}\n`;
+  if (proj.currentFocus) out += `Current Focus: ${proj.currentFocus}\n`;
+  if (proj.deadline) out += `Deadline: ${proj.deadline}\n`;
+
+  if (doingTasks.length > 0) {
+    out += `\n=== CURRENTLY WORKING ON ===\n`;
+    doingTasks.forEach(t => { out += `• ${t.title}${t.description ? " — " + t.description : ""}\n`; });
+  }
+
+  out += `\n=== SYSTEMS (${systems.length}) ===\n`;
+  systems.forEach(s => {
+    out += `[${(s.status || "unknown").toUpperCase()}] ${s.name} — ${s.description || ""}\n`;
+    if (s.keyFiles) out += `  Files: ${s.keyFiles}\n`;
+    if (s.criticalRules) out += `  RULES: ${s.criticalRules}\n`;
+    if (s.notes) out += `  Notes: ${s.notes}\n`;
+  });
+
+  if (bps.length > 0) {
+    out += `\n=== BLUEPRINTS (${bps.length}) ===\n`;
+    bps.forEach(b => {
+      out += `${b.name}${b.path ? " — " + b.path : ""}\n`;
+      if (b.parentClass) out += `  Parent: ${b.parentClass}\n`;
+      if (b.description) out += `  ${b.description}\n`;
+    });
+  }
+
+  if (levels.length > 0) {
+    out += `\n=== LEVELS (${levels.length}) ===\n`;
+    levels.forEach(l => {
+      out += `[${(l.status || "planned").toUpperCase()}] ${l.name}${l.map ? " — " + l.map : ""} (${l.actorCount || 0} actors)\n`;
+    });
+  }
+
+  if (plugins.length > 0) {
+    out += `\n=== PLUGINS (${plugins.length}) ===\n`;
+    plugins.forEach(p => {
+      out += `${p.name} v${p.version}${p.source ? " (" + p.source + ")" : ""}\n`;
+    });
+  }
+
+  if (openBugs.length > 0) {
+    out += `\n=== OPEN BUGS (${openBugs.length}) ===\n`;
+    openBugs.forEach(b => {
+      const sys = systems.find(s => s.id === b.systemId);
+      out += `[${b.priority.toUpperCase()}] ${b.title}${sys ? " (" + sys.name + ")" : ""}\n`;
+    });
+  }
+
+  if (optimizeItems.length > 0) {
+    out += `\n=== OPEN OPTIMIZE ITEMS (${optimizeItems.length}) ===\n`;
+    optimizeItems.forEach(o => {
+      out += `[${o.category || "general"}] ${o.title}${o.savings ? " — savings: " + o.savings : ""}\n`;
+    });
+  }
+
+  if (openQuestions.length > 0) {
+    out += `\n=== OPEN QUESTIONS (${openQuestions.length}) ===\n`;
+    openQuestions.forEach(q => {
+      out += `• ${q.text}\n`;
+    });
+  }
+
+  if (last) {
+    out += `\n=== LAST SESSION (${last.date}) ===\n`;
+    out += `${last.title}\n`;
+    if (last.summary) out += `${last.summary}\n`;
+    if (last.whereWeLeftOff) out += `LEFT OFF: ${last.whereWeLeftOff}\n`;
+    if (last.nextSteps?.length) {
+      out += `NEXT:\n`;
+      last.nextSteps.forEach(s => out += `  - ${s}\n`);
+    }
+  }
+
+  if (decisions.length > 0) {
+    out += `\n=== DECISIONS (${decisions.length}) ===\n`;
+    decisions.slice(0, 10).forEach(dd => {
+      out += `[${dd.date}] ${dd.decision}${dd.context ? " — " + dd.context : ""}\n`;
+    });
+  }
+
+  return out;
+}
+
+// ===== DASHBOARD =====
+
+function dashboard(pid) {
+  const d = load();
+  const proj = d.projects.find(p => p.id === pid);
+  if (!proj) return null;
+
+  const systems = d.systems.filter(s => s.projectId === pid);
+  const tasks = d.tasks.filter(t => t.projectId === pid);
+  const openBugs = d.bugs.filter(b => b.projectId === pid && b.status === "open");
+  const sessions = d.sessions.filter(s => s.projectId === pid).sort((a, b) => b.date.localeCompare(a.date));
+  const last = sessions[0];
+
+  const sc = { working: 0, wip: 0, broken: 0, planned: 0 };
+  systems.forEach(s => { if (sc[s.status] !== undefined) sc[s.status]++; });
+
+  const tc = { todo: 0, doing: 0, done: 0, scrapped: 0 };
+  tasks.forEach(t => { if (tc[t.status] !== undefined) tc[t.status]++; });
+
+  const levels = d.levels.filter(l => l.projectId === pid);
+  const plugins = d.plugins.filter(p => p.projectId === pid);
+  const buildErrors = d.buildErrors.filter(e => e.projectId === pid);
+  const optimizeItems = d.optimizeItems.filter(o => o.projectId === pid);
+  const playtests = d.playtests.filter(p => p.projectId === pid);
+  const milestones = d.milestones.filter(m => m.projectId === pid);
+  const openQuestions = d.openQuestions.filter(q => q.projectId === pid && !q.resolved);
+  const shipChecked = d.shipChecked.filter(s => s.projectId === pid);
+
+  return {
+    project: proj,
+    systems: { total: systems.length, ...sc },
+    tasks: { total: tasks.length, ...tc },
+    openBugs: openBugs.length,
+    sessions: sessions.length,
+    lastSession: last || null,
+    openBugsList: openBugs,
+    doingTasks: tasks.filter(t => t.status === "doing"),
+    levels: levels.length,
+    plugins: plugins.length,
+    buildErrors: { total: buildErrors.length, open: buildErrors.filter(e => e.status === "open").length },
+    optimizeItems: { total: optimizeItems.length, open: optimizeItems.filter(o => o.status === "open").length },
+    playtests: playtests.length,
+    milestones: { total: milestones.length, active: milestones.filter(m => m.status === "active").length, upcoming: milestones.filter(m => m.status === "upcoming").length },
+    openQuestions: openQuestions.length,
+    shipChecked: shipChecked.length,
+  };
+}
+
+module.exports = {
+  load, save,
+  listProjects, getProject, addProject, updateProject,
+  getTasks, getTask, addTask, updateTask, moveTask, addTaskComment, updateChecklist,
+  getSystems, getSystem, addSystem, updateSystem, deleteSystem,
+  getSessions, getLastSession, logSession, updateSession,
+  getChangelog, addChangelog,
+  getBugs, addBug, updateBug, fixBug,
+  getDecisions, logDecision,
+  getBlueprints, addBlueprint, updateBlueprint, getBlueprintGraphs, setBlueprintGraph, addGraphNodes,
+  getNotes, addNote,
+  getBackups, logBackup,
+  // New collection functions
+  getLevels, addLevel, updateLevel, addActor, removeActor,
+  getPlugins, addPlugin, updatePlugin, deletePlugin,
+  getBuildErrors, addBuildError, fixBuildError,
+  getOptimizeItems, addOptimizeItem, updateOptimizeItem,
+  getPerfBudget, addPerfBudget, updatePerfBudget,
+  getPlaytests, addPlaytest,
+  getMilestones, addMilestone, updateMilestone,
+  getIterations, addIteration,
+  getDialogues, addDialogue, updateDialogue,
+  getSounds, addSound, updateSound,
+  getControls, addControl, updateControl,
+  getAssets, addAsset, updateAsset,
+  getRefs, addRef,
+  getMarketingItems, addMarketingItem, updateMarketingItem,
+  getWikiPages, addWikiPage, updateWikiPage,
+  getShipChecked, toggleShipCheck,
+  getOpenQuestions, addOpenQuestion, toggleQuestion,
+  // Helper functions
+  updateProjectField, logActivity,
+  // Aggregation functions
+  search, contextExport, dashboard,
+};