@omerrgocmen/crewctl 1.0.0

package/orchestrator/src/skill-registry.js

@@ -0,0 +1,272 @@
+// skill-registry.js — yeniden kullanilabilir "beceri" (skill) dosyalarini yukler, ayristirir
+// ve operatore/uzmana verilecek bicime cevirir. Beceriler roles/*.md gibi Markdown'dir; farki
+// frontmatter tasimalari ve KULLANICI TARAFINDAN ETKINLESTIRILENLERIN operatore katalog olarak
+// sunulmasidir. Sifir bagimlilik: frontmatter'i kendi minimal ayristiricimizla okuruz.
+const fs = require("fs");
+const path = require("path");
+const store = require("./store");
+
+const SKILLS_DIR = path.join(store.ROOT, "skills");
+
+function ensureDir() {
+  try { fs.mkdirSync(SKILLS_DIR, { recursive: true }); } catch {}
+}
+
+function toList(value) {
+  if (Array.isArray(value)) return value.map(String).map((x) => x.trim()).filter(Boolean);
+  if (typeof value === "string" && value.trim()) return value.split(",").map((x) => x.trim()).filter(Boolean);
+  return [];
+}
+
+// `--- ... ---` bloğundan basit `key: value` ciftlerini okur. Deger `[a, b]` veya virgullu
+// liste ise diziye cevrilir. YAML'in tamamini desteklemeyiz; skill dosyalari icin bu yeterli.
+function parseFrontmatter(text) {
+  const raw = String(text || "");
+  const match = raw.match(/^?---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*\r?\n?([\s\S]*)$/);
+  if (!match) return { meta: {}, body: raw.trim() };
+  const meta = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const kv = line.match(/^([A-Za-z0-9_-]+)[ \t]*:[ \t]*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1].trim();
+    let value = kv[2].trim();
+    if (/^\[.*\]$/.test(value)) {
+      value = value.slice(1, -1).split(",").map((x) => x.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+    } else {
+      value = value.replace(/^["']|["']$/g, "");
+    }
+    meta[key] = value;
+  }
+  return { meta, body: match[2].trim() };
+}
+
+function fileNameFor(nameOrFile) {
+  const base = path.basename(String(nameOrFile || ""));
+  return base.toLowerCase().endsWith(".md") ? base : `${base}.md`;
+}
+
+function slugFor(file) {
+  return path.basename(String(file)).replace(/\.md$/i, "");
+}
+
+function listSkillFiles() {
+  ensureDir();
+  try { return fs.readdirSync(SKILLS_DIR).filter((f) => f.toLowerCase().endsWith(".md")).sort(); }
+  catch { return []; }
+}
+
+function loadSkill(nameOrFile) {
+  const file = fileNameFor(nameOrFile);
+  const p = path.join(SKILLS_DIR, file);
+  if (!fs.existsSync(p)) {
+    // Etkin liste dosya adi yerine frontmatter `name` slug'ini tutuyor olabilir.
+    const byName = listSkillFiles().map((f) => ({ f, s: parseFrontmatter(readRaw(f)) }))
+      .find(({ f, s }) => String(s.meta.name || slugFor(f)) === slugFor(nameOrFile));
+    if (!byName) return null;
+    return buildSkill(byName.f, byName.s);
+  }
+  return buildSkill(file, parseFrontmatter(fs.readFileSync(p, "utf8")));
+}
+
+function buildSkill(file, parsed) {
+  const { meta, body } = parsed;
+  return {
+    name: String(meta.name || slugFor(file)),
+    file,
+    description: String(meta.description || ""),
+    category: String(meta.category || "general"),
+    appliesTo: toList(meta.appliesTo),
+    match: toList(meta.match),
+    body,
+  };
+}
+
+function readRaw(nameOrFile) {
+  const p = path.join(SKILLS_DIR, fileNameFor(nameOrFile));
+  return fs.existsSync(p) ? fs.readFileSync(p, "utf8") : "";
+}
+
+function allSkills() {
+  return listSkillFiles().map((f) => buildSkill(f, parseFrontmatter(readRaw(f))));
+}
+
+function enabledNames(cfg) {
+  const list = cfg && cfg.skills && Array.isArray(cfg.skills.enabled) ? cfg.skills.enabled.map(String) : [];
+  return new Set(list);
+}
+
+function enabledSkills(cfg, installed = null) {
+  const enabled = enabledNames(cfg);
+  if (!enabled.size) return [];
+  const wildcard = enabled.has("*");
+  return (installed || allSkills()).filter((skill) => wildcard || enabled.has(skill.name));
+}
+
+function normalizeText(value) {
+  return String(value || "").toLocaleLowerCase("tr-TR").normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "").replace(/ı/g, "i").replace(/[^a-z0-9]+/g, " ").trim();
+}
+
+function scoreSkill(skill, context, kind = "") {
+  const haystack = ` ${normalizeText(context)} `;
+  if (!haystack.trim()) return 0;
+  const stopwords = new Set(["icin", "ile", "veya", "olan", "olarak", "yap", "yaz", "ekle", "kur", "kullan", "tasarla", "incele", "duzelt", "olustur", "guncelle", "planla", "create", "build", "write", "add", "use", "design", "review", "fix", "update", "implement"]);
+  const tokens = new Set(haystack.trim().split(/\s+/).filter((token) => token.length > 1 && !stopwords.has(token)));
+  let lexical = 0;
+  for (const rawPhrase of skill.match) {
+    const phrase = normalizeText(rawPhrase);
+    if (!phrase) continue;
+    if (!phrase.includes(" ") && stopwords.has(phrase)) continue;
+    if (haystack.includes(` ${phrase} `)) lexical += 18 + Math.min(8, phrase.split(" ").length * 2);
+    else if (phrase.split(" ").every((token) => tokens.has(token))) lexical += 10;
+  }
+  const nameParts = normalizeText(skill.name).split("-").filter((token) => token.length > 2);
+  lexical += nameParts.filter((token) => tokens.has(token)).length * 8;
+  const descriptionTokens = new Set(normalizeText(skill.description).split(" ").filter((token) => token.length > 3));
+  const descriptionHits = [...tokens].filter((token) => descriptionTokens.has(token));
+  if (descriptionHits.length > 1) lexical += descriptionHits.length * 2;
+  if (!lexical) return 0;
+  const kindFit = !kind || !skill.appliesTo.length || skill.appliesTo.includes(kind) ? 6 : -8;
+  return Math.max(1, lexical + kindFit);
+}
+
+function ranked(cfg, context = "", kind = "", installed = null) {
+  return enabledSkills(cfg, installed).map((skill) => ({ skill, score: scoreSkill(skill, context, kind) }))
+    .filter(({ score }) => !context || score > 0)
+    .sort((a, b) => b.score - a.score || a.skill.name.localeCompare(b.skill.name, "en"));
+}
+
+function compact(skill) {
+  const description = skill.description.length > 180 ? `${skill.description.slice(0, 177)}...` : skill.description;
+  return { name: skill.name, description, appliesTo: skill.appliesTo };
+}
+
+// Operatore tum govdeleri veya tum aciklamalari yuklemek yerine, gorev metnine gore en ilgili
+// etkin becerileri verir. Limit ve karakter butcesi katalog buyuse bile prompt maliyetini sabitler.
+function catalogFromRanked(cfg, rankedSkills) {
+  const limit = Math.max(1, Number(cfg?.skills?.catalogLimit) || 12);
+  const budget = Math.max(200, Number(cfg?.skills?.charBudget) || 2400);
+  const out = [];
+  for (const { skill } of rankedSkills) {
+    if (out.length >= limit) break;
+    let item = compact(skill);
+    let candidate = [...out, item];
+    if (JSON.stringify(candidate).length > budget) {
+      if (out.length) break;
+      const withoutDescription = { ...item, description: "" };
+      const fixedCost = JSON.stringify([withoutDescription]).length;
+      if (fixedCost > budget) break;
+      const room = Math.max(0, budget - fixedCost - 3);
+      item = { ...item, description: room ? `${item.description.slice(0, room)}...` : "" };
+      candidate = [item];
+    }
+    out.push(item);
+  }
+  return out;
+}
+
+function discover(cfg, context = "", kind = "") {
+  const installed = allSkills();
+  const enabled = enabledSkills(cfg, installed);
+  const matches = ranked(cfg, context, kind, installed);
+  return {
+    catalog: catalogFromRanked(cfg, matches),
+    stats: { installed: installed.length, enabled: enabled.length, matched: matches.length },
+  };
+}
+
+function catalog(cfg, context = "", kind = "") {
+  return discover(cfg, context, kind).catalog;
+}
+
+function catalogStats(cfg, context = "", kind = "") {
+  return discover(cfg, context, kind).stats;
+}
+
+function suggest(cfg, context, kind = "") {
+  const limit = Math.max(1, Number(cfg?.skills?.maxSkillsPerAssignment) || 3);
+  return ranked(cfg, context, kind).slice(0, limit).map(({ skill }) => skill.name);
+}
+
+// Bir delegasyona istenen beceri adlarini cozer; yalnizca hem var olan hem de kullanicinin
+// etkinlestirdigi beceriler donuir. Boylece operator, katalog disinda bir beceri iliştiremez.
+function resolveForAssignment(names, cfg) {
+  const enabled = enabledNames(cfg);
+  const wildcard = enabled.has("*");
+  const limit = Math.max(1, Number(cfg?.skills?.maxSkillsPerAssignment) || 3);
+  const out = [];
+  const seen = new Set();
+  for (const name of toList(names)) {
+    if (out.length >= limit) break;
+    if (seen.has(name) || (!wildcard && !enabled.has(name))) continue;
+    const skill = loadSkill(name);
+    if (skill) { out.push(skill); seen.add(name); }
+  }
+  return out;
+}
+
+// Progressive disclosure: uzmana becerinin TAM govdesini yigmadan, ad + kisa ozet + rehber dosya
+// yolunu verir. Uzman gercekten ihtiyac duyarsa dosyayi kendisi okur. Boylece prompt hafif kalir.
+function toPromptRefs(skills, charBudget = 1200) {
+  if (!Array.isArray(skills) || !skills.length) return "";
+  const lines = [];
+  for (const skill of skills) {
+    const location = path.join(SKILLS_DIR, skill.file);
+    let line = `- ${skill.name}: ${skill.description || "(aciklama yok)"}\n  Rehber: ${location}`;
+    if (charBudget && [...lines, line].join("\n").length > charBudget) {
+      if (lines.length) break;
+      line = `- ${skill.name}\n  Rehber: ${location}`;
+      if (line.length > charBudget) break;
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+
+function validateSkill(nameOrFile, content) {
+  const { meta, body } = parseFrontmatter(content);
+  const errors = [];
+  const name = String(meta.name || "");
+  const expected = slugFor(fileNameFor(nameOrFile));
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name) || name.length > 64) errors.push("name kucuk harfli kebab-case ve en fazla 64 karakter olmali");
+  if (name && name !== expected) errors.push("frontmatter name dosya adiyla ayni olmali");
+  const description = String(meta.description || "").trim();
+  if (!description || description.length > 1024) errors.push("description 1-1024 karakter olmali");
+  if (!body.trim()) errors.push("beceri govdesi bos olamaz");
+  const invalidKinds = toList(meta.appliesTo).filter((kind) => !["implement", "review", "plan", "research"].includes(kind));
+  if (invalidKinds.length) errors.push(`gecersiz appliesTo: ${invalidKinds.join(", ")}`);
+  return { ok: !errors.length, errors };
+}
+
+function writeSkill(nameOrFile, content) {
+  ensureDir();
+  const file = fileNameFor(nameOrFile);
+  fs.writeFileSync(path.join(SKILLS_DIR, file), String(content == null ? "" : content));
+  return file;
+}
+
+function deleteSkill(nameOrFile) {
+  const p = path.join(SKILLS_DIR, fileNameFor(nameOrFile));
+  if (fs.existsSync(p)) fs.rmSync(p);
+}
+
+module.exports = {
+  SKILLS_DIR,
+  parseFrontmatter,
+  listSkillFiles,
+  loadSkill,
+  allSkills,
+  enabledNames,
+  enabledSkills,
+  scoreSkill,
+  discover,
+  catalog,
+  catalogStats,
+  suggest,
+  resolveForAssignment,
+  toPromptRefs,
+  validateSkill,
+  readRaw,
+  writeSkill,
+  deleteSkill,
+};

package/orchestrator/src/store.js

@@ -0,0 +1,364 @@
+// store.js — dosya tabanli kuyruk, config, hafiza, butce (sifir bagimlilik)
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const os = require("os");
+
+const isWin = process.platform === "win32";
+// ASSETS: paket dizini (salt-okunur varlıklar: web/, config.default.json, varsayilan roles/+skills/).
+// __dirname/.. daima paketin gercek yeridir (npm global/npx onbellegi dahil).
+const ASSETS = path.join(__dirname, "..");
+// ROOT: yazilabilir VERI koku (config.json, queue/, state/, memory/, kullanicinin roles/+skills/).
+// Oncelik: CLI_TEAM_ROOT (izole test/CI) > CREWCTL_HOME (kullanici override) > mod tespiti.
+// Gelistirme kopyasinda test/ klasoru bulunur ve paket dizini yazilabilirdir; o zaman ROOT=ASSETS
+// (mevcut npm start/npm test davranisi aynen korunur). Yayinlanan pakette test/ gonderilmez, bu
+// yuzden kurulu modda veri ~/.crewctl'e yazilir (npm onbelleğine degil).
+const isDevCheckout = fs.existsSync(path.join(ASSETS, "test"));
+const ROOT = path.resolve(
+  process.env.CLI_TEAM_ROOT ||
+  process.env.CREWCTL_HOME ||
+  (isDevCheckout ? ASSETS : path.join(os.homedir(), ".crewctl"))
+);
+// WORK_BASE: agent'larin uzerinde calisacagi klasorun goreli cozumleme tabani. Kurulu modda
+// kullanici komutu nerede calistirdiysa orasidir (cwd); mutlak yol secilirse zaten o kullanilir.
+const WORK_BASE = process.cwd();
+const Q = path.join(ROOT, "queue");
+const STATES = ["pending", "done", "failed", "approval"];
+const MEM = path.join(ROOT, "memory");
+const STATE = path.join(ROOT, "state");
+const EVENTS = path.join(STATE, "events");
+const ROLES = path.join(ROOT, "roles");
+const SKILLS = path.join(ROOT, "skills");
+
+// Windows'ta rename/unlink; antivirus, arama dizinleyici veya kuyrugu ayni anda tarayan
+// canli sunucu dosyada kisa sureli bir handle tuttugunda gecici olarak EPERM/EACCES/EBUSY
+// verir. Tek seferlik cagri bu durumda tum gorevi coldururdu; kisa artan beklemelerle yeniden
+// deneriz. Bu kod yolu tum saveTask/saveConfig/addTask cagrilarinin sicak yolu.
+const TRANSIENT_FS_CODES = new Set(["EPERM", "EACCES", "EBUSY", "ENOENT", "EEXIST"]);
+function sleepSync(ms) {
+  try { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); } catch {}
+}
+function isTransientFsError(error) {
+  return isWin && error && TRANSIENT_FS_CODES.has(error.code);
+}
+
+function sweepStaleTemp(dir, maxAgeMs = 5 * 60 * 1000) {
+  // Kalici olarak yeniden adlandirilamamis eski .tmp dosyalarini birak birikmesin diye temizle.
+  let entries;
+  try { entries = fs.readdirSync(dir); } catch { return; }
+  const now = Date.now();
+  for (const name of entries) {
+    if (!name.endsWith(".tmp")) continue;
+    const full = path.join(dir, name);
+    try {
+      if (now - fs.statSync(full).mtimeMs > maxAgeMs) fs.rmSync(full, { force: true });
+    } catch {}
+  }
+}
+
+// Kurulu modda (ROOT != ASSETS) veri kokundeki roles/ ve skills/ bos ise paketle gelen
+// varsayilanlari BIR KEZ kopyala. Kullanicinin duzenlemeleri korunur (yalnizca bos dizine seed).
+let seededAssets = false;
+function seedDefaults() {
+  if (seededAssets) return;
+  seededAssets = true;
+  if (ROOT === ASSETS) return;
+  for (const [srcDir, dstDir] of [[path.join(ASSETS, "roles"), ROLES], [path.join(ASSETS, "skills"), SKILLS]]) {
+    try {
+      const existing = fs.existsSync(dstDir) ? fs.readdirSync(dstDir).filter((f) => f.toLowerCase().endsWith(".md")) : [];
+      if (existing.length) continue;
+      const defaults = fs.existsSync(srcDir) ? fs.readdirSync(srcDir).filter((f) => f.toLowerCase().endsWith(".md")) : [];
+      for (const f of defaults) fs.copyFileSync(path.join(srcDir, f), path.join(dstDir, f));
+    } catch {}
+  }
+}
+
+// ensureDirs, olay akisinda cok sik cagrilir; temizligi dakikada bir defayla sinirla ki
+// her stdout parcasinda dizin taramasi yapmayalim.
+let lastSweepAt = 0;
+function ensureDirs() {
+  const dirs = [...STATES.map((s) => path.join(Q, s)), MEM, STATE, EVENTS, ROLES, SKILLS];
+  dirs.forEach((d) => fs.mkdirSync(d, { recursive: true }));
+  seedDefaults();
+  if (Date.now() - lastSweepAt > 60 * 1000) {
+    lastSweepAt = Date.now();
+    for (const s of STATES) sweepStaleTemp(path.join(Q, s));
+  }
+}
+
+// Atomik yazma: once .tmp'ye yaz, sonra rename et. Rename ayni disk uzerinde atomiktir;
+// boylece surec ortasinda cokme olsa bile yarim/bozuk JSON dosyasi kalmaz (her PC'de guvenli).
+// Windows'ta rename gecici olarak kilitlenebildigi icin (bkz. TRANSIENT_FS_CODES) yeniden dener.
+function atomicWrite(file, data) {
+  const tmp = `${file}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+  fs.writeFileSync(tmp, data);
+  let lastError;
+  for (let attempt = 0; attempt < 10; attempt++) {
+    try {
+      fs.renameSync(tmp, file);
+      return;
+    } catch (error) {
+      lastError = error;
+      if (!isTransientFsError(error)) break;
+      sleepSync(20 * (attempt + 1));
+    }
+  }
+  // Rename kalici olarak basarisiz. Gorevi tamamen kaybetmektense hedefe dogrudan (atomik
+  // olmayan) yazmayi son care olarak dene; sonra gecici dosyayi temizle.
+  try {
+    fs.writeFileSync(file, data);
+    try { fs.rmSync(tmp, { force: true }); } catch {}
+    return;
+  } catch {}
+  try { fs.rmSync(tmp, { force: true }); } catch {}
+  throw lastError;
+}
+
+// ---- Config ----
+// Minimal geri-donus varsayilani (config.default.json de yoksa kullanilir) — sistem her
+// zaman calisir durumda acilsin diye.
+const FALLBACK_CONFIG = {
+  approvalMode: "auto", workingDir: "..", dailyCallBudget: 150,
+  autonomousConsentAcceptedAt: null,
+  pollSeconds: 15, memoryCharBudget: 8000, teamContextCharBudget: 30000, agentTimeoutSeconds: 900,
+  cliSilenceTimeoutSeconds: 300,
+  discoveryIgnoredAdapters: [],
+  liveDiff: true, liveDiffIntervalMs: 2500,
+  versioning: true, versioningRetention: 20,
+  operator: { roleFile: "roles/operator.md", maxRounds: 6, maxDelegationsPerRound: 8, maxInfrastructureRecoveryRounds: 2, protocolRetries: 1 },
+  cliSettings: {
+    codex: { model: "", reasoningEffort: "medium", serviceTier: "fast" },
+    opencode: { model: "" },
+  },
+  skills: { enabled: [], autoMatch: true, catalogLimit: 12, maxSkillsPerAssignment: 3, charBudget: 2400, referenceCharBudget: 1200 },
+  agents: {}, riskyPatterns: [], schedules: [],
+};
+// Eski sema, model ayarlarini operator altina gomuyordu (operator.codexSettings ve
+// operator.model). Yeni sema CLI bazlidir: cliSettings[adapter] o CLI'nin operator ve
+// uzman kullanimlarinin tumune uygulanir. Saf ve idempotent olmali; loadConfig sicak yoldur.
+function normalizeConfig(cfg) {
+  if (!cfg || typeof cfg !== "object") return cfg;
+  const current = cfg.cliSettings && typeof cfg.cliSettings === "object" ? cfg.cliSettings : {};
+  const legacyCodex = cfg.operator && typeof cfg.operator.codexSettings === "object" ? cfg.operator.codexSettings : {};
+  const legacyOpenCodeModel = typeof cfg.operator?.model === "string" ? cfg.operator.model : "";
+  const normalized = {
+    ...cfg,
+    skills: { enabled: [], autoMatch: true, catalogLimit: 12, maxSkillsPerAssignment: 3, charBudget: 2400, referenceCharBudget: 1200, ...(cfg.skills || {}) },
+    schedules: Array.isArray(cfg.schedules) ? cfg.schedules : [],
+    cliSettings: {
+      codex: { model: "", reasoningEffort: "medium", serviceTier: "fast", ...legacyCodex, ...(current.codex || {}) },
+      opencode: { model: legacyOpenCodeModel, ...(current.opencode || {}) },
+    },
+  };
+  if (cfg.operator && typeof cfg.operator === "object") {
+    normalized.operator = { ...cfg.operator };
+    delete normalized.operator.codexSettings;
+    delete normalized.operator.model;
+  }
+  return normalized;
+}
+// config.json kisiye ozeldir (gitignore). Yoksa config.default.json sablonundan uretilir;
+// boylece kullanici klonlayip `npm start` dedigi anda calisir ve kurulu CLI'lar keşifle eklenir.
+function loadConfig() {
+  const file = path.join(ROOT, "config.json");
+  if (!fs.existsSync(file)) {
+    const template = path.join(ASSETS, "config.default.json");
+    const seed = fs.existsSync(template) ? fs.readFileSync(template, "utf8") : JSON.stringify(FALLBACK_CONFIG, null, 2);
+    atomicWrite(file, seed);
+  }
+  return normalizeConfig(JSON.parse(fs.readFileSync(file, "utf8")));
+}
+function saveConfig(cfg) {
+  atomicWrite(path.join(ROOT, "config.json"), JSON.stringify(cfg, null, 2));
+}
+
+// ---- Roller ----
+function listRoles() {
+  if (!fs.existsSync(ROLES)) return [];
+  return fs.readdirSync(ROLES).filter((f) => f.endsWith(".md"));
+}
+function readRole(file) {
+  const p = path.join(ROLES, path.basename(file));
+  return fs.existsSync(p) ? fs.readFileSync(p, "utf8") : "";
+}
+function writeRole(file, content) {
+  fs.writeFileSync(path.join(ROLES, path.basename(file)), content);
+}
+function deleteRole(file) {
+  const p = path.join(ROLES, path.basename(file));
+  if (fs.existsSync(p)) fs.rmSync(p);
+}
+
+// ---- Gorevler ----
+function taskPath(state, id) {
+  return path.join(Q, state, `${id}.json`);
+}
+function listTasks(state) {
+  const dir = path.join(Q, state);
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir)
+    .filter((f) => f.endsWith(".json"))
+    .map((f) => {
+      try {
+        return JSON.parse(fs.readFileSync(path.join(dir, f), "utf8"));
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean)
+    .sort((a, b) => (a.id < b.id ? -1 : 1));
+}
+function nextPending() {
+  return listTasks("pending")[0] || null;
+}
+function addTask(prompt, targetDir, operatorCli, executionMode) {
+  const id =
+    new Date().toISOString().replace(/[-:T.]/g, "").slice(0, 15) +
+    "-" +
+    Math.floor(Math.random() * 9000 + 1000);
+  const task = { id, prompt, status: "pending", createdAt: new Date().toISOString() };
+  if (targetDir) task.targetDir = targetDir;
+  if (operatorCli) task.operatorCli = operatorCli;
+  if (executionMode) task.executionMode = executionMode;
+  atomicWrite(taskPath("pending", id), JSON.stringify(task, null, 2));
+  return task;
+}
+function addChatTask(parentTask, question) {
+  const task = addTask(question, parentTask.targetDir, parentTask.operatorCli, "chat");
+  task.kind = "operator-chat";
+  task.parentTaskId = parentTask.id;
+  saveTask("pending", task);
+  return task;
+}
+// Zamanlanmis bir gorevi kuyruga ekler. Normal gorevle ayni yolu kullanir; yalnizca kaynagini
+// isaretlemek icin scheduleId iliştirir (Pano bu görevi "zamanlanmis" rozetiyle gosterebilsin).
+function addScheduledTask(schedule) {
+  const task = addTask(schedule.prompt, schedule.targetDir, schedule.operatorCli, schedule.executionMode || "auto");
+  task.scheduleId = schedule.id;
+  saveTask("pending", task);
+  return task;
+}
+
+// ---- Kalici calisma olaylari ----
+function appendRunEvent(taskId, event) {
+  ensureDirs();
+  fs.appendFileSync(path.join(EVENTS, `${path.basename(taskId)}.jsonl`), JSON.stringify(event) + "\n");
+}
+function listRunEvents(taskId, limit = 1000) {
+  const file = path.join(EVENTS, `${path.basename(taskId)}.jsonl`);
+  if (!fs.existsSync(file)) return [];
+  return fs.readFileSync(file, "utf8").split(/\r?\n/).filter(Boolean).slice(-Math.max(1, limit)).map((line) => {
+    try { return JSON.parse(line); } catch { return null; }
+  }).filter(Boolean);
+}
+function hashText(text) {
+  return crypto.createHash("sha256").update(String(text)).digest("hex");
+}
+function saveTask(state, task) {
+  atomicWrite(taskPath(state, task.id), JSON.stringify(task, null, 2));
+}
+function findTask(id) {
+  for (const s of STATES) {
+    const p = taskPath(s, id);
+    if (fs.existsSync(p)) return { state: s, task: JSON.parse(fs.readFileSync(p, "utf8")) };
+  }
+  return null;
+}
+function moveTask(fromState, toState, task) {
+  const src = taskPath(fromState, task.id);
+  // Hedefi once atomik olarak yaz. Surec iki islem arasinda cokse bile gorev kaybolmaz.
+  saveTask(toState, task);
+  if (fromState !== toState && fs.existsSync(src)) fs.rmSync(src);
+}
+function removeTask(state, id) {
+  const p = taskPath(state, id);
+  if (fs.existsSync(p)) fs.rmSync(p);
+}
+
+function approveTask(id) {
+  const found = findTask(id);
+  if (!found) throw new Error(`Gorev bulunamadi: ${id}`);
+  if (found.state !== "approval") throw new Error(`Gorev onay beklemiyor: ${id}`);
+  const task = found.task;
+  if (task.planHash && task.planPreview && task.planHash !== hashText(task.planPreview)) {
+    throw new Error("Plan onay beklerken degismis; yeniden planlanmasi gerekiyor.");
+  }
+  task.approved = true;
+  task.status = "pending";
+  moveTask(found.state, "pending", task);
+  return task;
+}
+
+function rejectTask(id) {
+  const found = findTask(id);
+  if (!found) throw new Error(`Gorev bulunamadi: ${id}`);
+  if (found.state !== "approval") throw new Error(`Gorev onay beklemiyor: ${id}`);
+  found.task.status = "rejected";
+  found.task.finishedAt = new Date().toISOString();
+  moveTask(found.state, "failed", found.task);
+  return found.task;
+}
+
+// ---- Hafiza ----
+function getMemory(charBudget) {
+  if (!fs.existsSync(MEM)) return "(hafiza bos)";
+  const files = fs
+    .readdirSync(MEM)
+    .filter((f) => f.endsWith(".md"))
+    .map((f) => path.join(MEM, f));
+  if (!files.length) return "(hafiza bos)";
+  let text = files.map((f) => fs.readFileSync(f, "utf8")).join("\n\n");
+  if (charBudget && text.length > charBudget) text = text.slice(-charBudget);
+  return text;
+}
+function appendMemory(title, body) {
+  const stamp = new Date().toISOString().slice(0, 16).replace("T", " ");
+  fs.appendFileSync(path.join(MEM, "log.md"), `\n## ${stamp} — ${title}\n${body}\n`);
+}
+
+// ---- Gunluk cagri butcesi ----
+function callFile() {
+  return path.join(STATE, `calls-${new Date().toISOString().slice(0, 10)}.txt`);
+}
+function getCallCount() {
+  const f = callFile();
+  return fs.existsSync(f) ? parseInt(fs.readFileSync(f, "utf8"), 10) || 0 : 0;
+}
+function bumpCallCount() {
+  const n = getCallCount() + 1;
+  fs.writeFileSync(callFile(), String(n));
+  return n;
+}
+
+module.exports = {
+  ROOT,
+  ASSETS,
+  WORK_BASE,
+  ensureDirs,
+  loadConfig,
+  normalizeConfig,
+  saveConfig,
+  listRoles,
+  readRole,
+  writeRole,
+  deleteRole,
+  listTasks,
+  nextPending,
+  addTask,
+  addChatTask,
+  addScheduledTask,
+  saveTask,
+  findTask,
+  moveTask,
+  removeTask,
+  approveTask,
+  rejectTask,
+  getMemory,
+  appendMemory,
+  getCallCount,
+  bumpCallCount,
+  appendRunEvent,
+  listRunEvents,
+  hashText,
+};