fifony 0.1.42 → 0.1.43

package/dist/chunk-E2EWEYA4.js

@@ -0,0 +1,1302 @@
+import {
+  computeMetrics
+} from "./chunk-MVTGAKQK.js";
+import {
+  markEventDirty,
+  markIssueDirty,
+  normalizeAgentProvider
+} from "./chunk-FJNH3G2Z.js";
+import {
+  logger
+} from "./chunk-DVU3CXWA.js";
+import {
+  COMPLETED_STATES,
+  PERSIST_EVENTS_MAX,
+  TARGET_ROOT,
+  TERMINAL_STATES,
+  clamp,
+  fail,
+  isoWeek,
+  normalizeState,
+  now,
+  parseEnvNumber,
+  parseIntArg,
+  parseIssueState,
+  parsePositiveIntEnv,
+  toBooleanValue,
+  toNumberValue,
+  toStringArray,
+  toStringValue,
+  withRetryBackoff
+} from "./chunk-42AMQAJG.js";
+
+// src/domains/tokens.ts
+var EMPTY = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+var overall = { ...EMPTY };
+var byPhase = /* @__PURE__ */ new Map();
+var byModel = /* @__PURE__ */ new Map();
+var daily = /* @__PURE__ */ new Map();
+var dailyByPhase = /* @__PURE__ */ new Map();
+var dailyByModel = /* @__PURE__ */ new Map();
+var byIssue = /* @__PURE__ */ new Map();
+var dailyEvents = /* @__PURE__ */ new Map();
+var hourly = /* @__PURE__ */ new Map();
+var HOURLY_RETENTION = 48;
+function todayDate() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function currentHour() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 13);
+}
+function pruneOldHours() {
+  if (hourly.size <= HOURLY_RETENTION) return;
+  const cutoff = new Date(Date.now() - HOURLY_RETENTION * 36e5).toISOString().slice(0, 13);
+  for (const key of hourly.keys()) {
+    if (key < cutoff) hourly.delete(key);
+  }
+}
+function addTo(target, usage) {
+  target.inputTokens += usage.inputTokens;
+  target.outputTokens += usage.outputTokens;
+  target.totalTokens += usage.totalTokens;
+}
+function getOrCreate(map, key) {
+  let bucket = map.get(key);
+  if (!bucket) {
+    bucket = { ...EMPTY };
+    map.set(key, bucket);
+  }
+  return bucket;
+}
+function mapToDailyArray(map, prefix) {
+  const result = [];
+  for (const [key, bucket] of map) {
+    if (!key.startsWith(prefix)) continue;
+    const date = key.slice(prefix.length);
+    result.push({ ...bucket, date });
+  }
+  result.sort((a, b) => a.date.localeCompare(b.date));
+  return result;
+}
+function record(issue, usage, role) {
+  if (!usage || usage.totalTokens === 0) return;
+  const date = todayDate();
+  const hour = currentHour();
+  const model = usage.model || "unknown";
+  addTo(overall, usage);
+  addTo(getOrCreate(daily, date), usage);
+  addTo(getOrCreate(hourly, hour), usage);
+  pruneOldHours();
+  if (role) {
+    addTo(getOrCreate(byPhase, role), usage);
+    addTo(getOrCreate(dailyByPhase, `${role}:${date}`), usage);
+  }
+  addTo(getOrCreate(byModel, model), usage);
+  addTo(getOrCreate(dailyByModel, `${model}:${date}`), usage);
+  const prev = byIssue.get(issue.id);
+  if (prev) {
+    prev.inputTokens += usage.inputTokens;
+    prev.outputTokens += usage.outputTokens;
+    prev.totalTokens += usage.totalTokens;
+    if (typeof usage.costUsd === "number") {
+      prev.costUsd = (prev.costUsd || 0) + usage.costUsd;
+    }
+    prev.title = issue.title;
+  } else {
+    byIssue.set(issue.id, {
+      identifier: issue.identifier,
+      title: issue.title,
+      inputTokens: usage.inputTokens,
+      outputTokens: usage.outputTokens,
+      totalTokens: usage.totalTokens,
+      costUsd: usage.costUsd,
+      byPhase: {}
+    });
+  }
+  if (role) {
+    const summary = byIssue.get(issue.id);
+    if (summary) {
+      const phaseBucket = summary.byPhase[role] ?? { ...EMPTY };
+      addTo(phaseBucket, usage);
+      summary.byPhase[role] = phaseBucket;
+    }
+  }
+}
+function recordEvent() {
+  const date = todayDate();
+  dailyEvents.set(date, (dailyEvents.get(date) || 0) + 1);
+}
+function getHourlySnapshot(hours = 24) {
+  const now2 = Date.now();
+  const tokensPerHour = [];
+  for (let i = hours - 1; i >= 0; i--) {
+    const h = new Date(now2 - i * 36e5).toISOString().slice(0, 13);
+    const tokenBucket = hourly.get(h);
+    tokensPerHour.push({
+      hour: h,
+      inputTokens: tokenBucket?.inputTokens || 0,
+      outputTokens: tokenBucket?.outputTokens || 0,
+      totalTokens: tokenBucket?.totalTokens || 0
+    });
+  }
+  return { tokensPerHour };
+}
+function hydrate(issues) {
+  overall = { ...EMPTY };
+  byPhase.clear();
+  byModel.clear();
+  daily.clear();
+  dailyByPhase.clear();
+  dailyByModel.clear();
+  byIssue.clear();
+  dailyEvents.clear();
+  for (const issue of issues) {
+    const issueSummary = {
+      identifier: issue.identifier,
+      title: issue.title,
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      costUsd: 0,
+      byPhase: {}
+    };
+    if (issue.tokenUsage && issue.tokenUsage.totalTokens > 0) {
+      issueSummary.inputTokens = issue.tokenUsage.inputTokens;
+      issueSummary.outputTokens = issue.tokenUsage.outputTokens;
+      issueSummary.totalTokens = issue.tokenUsage.totalTokens;
+      issueSummary.costUsd = issue.tokenUsage.costUsd || 0;
+      addTo(overall, issue.tokenUsage);
+    }
+    if (issue.tokensByPhase) {
+      for (const [phase, pu] of Object.entries(issue.tokensByPhase)) {
+        if (pu.totalTokens > 0) {
+          addTo(getOrCreate(byPhase, phase), pu);
+          issueSummary.byPhase[phase] = {
+            inputTokens: pu.inputTokens,
+            outputTokens: pu.outputTokens,
+            totalTokens: pu.totalTokens
+          };
+          if (issueSummary.totalTokens === 0) {
+            issueSummary.inputTokens += pu.inputTokens;
+            issueSummary.outputTokens += pu.outputTokens;
+            issueSummary.totalTokens += pu.totalTokens;
+            issueSummary.costUsd += pu.costUsd || 0;
+          }
+        }
+      }
+    }
+    if (issueSummary.totalTokens > 0) {
+      byIssue.set(issue.id, {
+        identifier: issueSummary.identifier,
+        title: issueSummary.title,
+        inputTokens: issueSummary.inputTokens,
+        outputTokens: issueSummary.outputTokens,
+        totalTokens: issueSummary.totalTokens,
+        costUsd: issueSummary.costUsd || void 0,
+        byPhase: issueSummary.byPhase
+      });
+    }
+    if (issue.tokensByModel) {
+      for (const [model, mu] of Object.entries(issue.tokensByModel)) {
+        if (mu.totalTokens > 0) addTo(getOrCreate(byModel, model), mu);
+      }
+    }
+    const date = issue.completedAt?.slice(0, 10);
+    if (date && issue.tokenUsage && issue.tokenUsage.totalTokens > 0) {
+      addTo(getOrCreate(daily, date), issue.tokenUsage);
+    }
+    if (date && issue.tokensByPhase) {
+      for (const [phase, pu] of Object.entries(issue.tokensByPhase)) {
+        if (pu.totalTokens > 0) addTo(getOrCreate(dailyByPhase, `${phase}:${date}`), pu);
+      }
+    }
+    if (date && issue.tokensByModel) {
+      for (const [model, mu] of Object.entries(issue.tokensByModel)) {
+        if (mu.totalTokens > 0) addTo(getOrCreate(dailyByModel, `${model}:${date}`), mu);
+      }
+    }
+  }
+}
+function getAnalytics(topN = 20) {
+  const allDates = /* @__PURE__ */ new Set([...daily.keys(), ...dailyEvents.keys()]);
+  const dailyArray = [];
+  for (const date of allDates) {
+    const bucket = daily.get(date) ?? { ...EMPTY };
+    const events = dailyEvents.get(date) || 0;
+    dailyArray.push({ ...bucket, date, ...events > 0 ? { events } : {} });
+  }
+  dailyArray.sort((a, b) => a.date.localeCompare(b.date));
+  const dailyByPhaseResult = {};
+  for (const phase of byPhase.keys()) {
+    dailyByPhaseResult[phase] = mapToDailyArray(dailyByPhase, `${phase}:`);
+  }
+  const dailyByModelResult = {};
+  for (const model of byModel.keys()) {
+    dailyByModelResult[model] = mapToDailyArray(dailyByModel, `${model}:`);
+  }
+  const topIssues = [...byIssue.entries()].map(([id, data]) => ({
+    id,
+    ...data,
+    byPhase: Object.keys(data.byPhase).length > 0 ? Object.fromEntries(
+      Object.entries(data.byPhase).map(([phase, bucket]) => [phase, { ...bucket }])
+    ) : void 0
+  })).sort((a, b) => b.totalTokens - a.totalTokens).slice(0, topN);
+  const byPhaseResult = {};
+  for (const [k, v] of byPhase) byPhaseResult[k] = { ...v };
+  const byModelResult = {};
+  for (const [k, v] of byModel) byModelResult[k] = { ...v };
+  return {
+    overall: { ...overall },
+    byPhase: byPhaseResult,
+    byModel: byModelResult,
+    daily: dailyArray,
+    dailyByPhase: dailyByPhaseResult,
+    dailyByModel: dailyByModelResult,
+    topIssues
+  };
+}
+
+// src/domains/project.ts
+import { execFileSync } from "child_process";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { basename, dirname, join, relative as relativePath, resolve } from "path";
+
+// src/shared/project-meta.ts
+var PROJECT_NAME_SETTING_ID = "system.projectName";
+function normalizeProjectName(value) {
+  return typeof value === "string" ? value.trim().replace(/\s+/g, " ") : "";
+}
+function detectProjectNameFromPath(path) {
+  const normalizedPath = typeof path === "string" ? path.trim().replace(/[\\/]+$/, "") : "";
+  if (!normalizedPath) return "";
+  const segments = normalizedPath.split(/[\\/]+/).filter(Boolean);
+  return normalizeProjectName(segments.at(-1) || "");
+}
+function readSavedProjectName(settings) {
+  const list = Array.isArray(settings) ? settings : [];
+  return normalizeProjectName(list.find((setting) => setting?.id === PROJECT_NAME_SETTING_ID)?.value);
+}
+function buildQueueTitle(projectName) {
+  const normalizedProjectName = normalizeProjectName(projectName);
+  return normalizedProjectName ? `fifony: ${normalizedProjectName}` : "fifony";
+}
+function buildProjectDraft({
+  savedProjectName = "",
+  detectedProjectName = ""
+} = {}) {
+  const saved = normalizeProjectName(savedProjectName);
+  const detected = normalizeProjectName(detectedProjectName);
+  const projectName = saved || detected;
+  return {
+    projectName,
+    detectedProjectName: detected,
+    source: saved ? "saved" : detected ? "detected" : "missing",
+    requiresManualEntry: !projectName
+  };
+}
+
+// src/domains/project.ts
+var SETTING_ID_PROJECT_NAME = PROJECT_NAME_SETTING_ID;
+function detectProjectName(targetRoot) {
+  return detectProjectNameFromPath(targetRoot);
+}
+function resolveProjectMetadata(settings, targetRoot) {
+  const draft = buildProjectDraft({
+    savedProjectName: readSavedProjectName(settings),
+    detectedProjectName: detectProjectName(targetRoot)
+  });
+  return {
+    projectName: draft.projectName,
+    detectedProjectName: draft.detectedProjectName,
+    projectNameSource: draft.source,
+    queueTitle: buildQueueTitle(draft.projectName)
+  };
+}
+function scanProjectFiles(targetRoot) {
+  const check = (rel) => existsSync(join(targetRoot, rel));
+  const files = {
+    claudeMd: check("CLAUDE.md"),
+    claudeDir: check(".claude"),
+    codexDir: check(".codex"),
+    readmeMd: check("README.md"),
+    packageJson: check("package.json"),
+    cargoToml: check("Cargo.toml"),
+    pyprojectToml: check("pyproject.toml"),
+    goMod: check("go.mod"),
+    buildGradle: check("build.gradle") || check("build.gradle.kts"),
+    gemfile: check("Gemfile"),
+    dockerfile: check("Dockerfile"),
+    agentsMd: check("AGENTS.md"),
+    claudeAgentsDir: check(".claude/agents"),
+    claudeSkillsDir: check(".claude/skills"),
+    codexAgentsDir: check(".codex/agents"),
+    codexSkillsDir: check(".codex/skills")
+  };
+  const existingAgents = [];
+  for (const agentDir of [".claude/agents", ".codex/agents"]) {
+    const fullPath = join(targetRoot, agentDir);
+    if (!existsSync(fullPath)) continue;
+    try {
+      const entries = readdirSync(fullPath);
+      for (const entry of entries) {
+        if (entry.endsWith(".md")) {
+          existingAgents.push(basename(entry, ".md"));
+        }
+      }
+    } catch {
+    }
+  }
+  const existingSkills = [];
+  for (const skillDir of [".claude/skills", ".codex/skills"]) {
+    const fullPath = join(targetRoot, skillDir);
+    if (!existsSync(fullPath)) continue;
+    try {
+      const entries = readdirSync(fullPath);
+      for (const entry of entries) {
+        const skillFile = join(fullPath, entry, "SKILL.md");
+        if (existsSync(skillFile)) {
+          existingSkills.push(entry);
+        }
+      }
+    } catch {
+    }
+  }
+  let readmeExcerpt = "";
+  const readmePath = join(targetRoot, "README.md");
+  if (existsSync(readmePath)) {
+    try {
+      const content = readFileSync(readmePath, "utf8");
+      readmeExcerpt = content.slice(0, 200).trim();
+    } catch {
+    }
+  }
+  let packageName = "";
+  let packageDescription = "";
+  const pkgPath = join(targetRoot, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      packageName = typeof pkg.name === "string" ? pkg.name : "";
+      packageDescription = typeof pkg.description === "string" ? pkg.description : "";
+    } catch {
+    }
+  }
+  return {
+    root: targetRoot,
+    files,
+    existingAgents: [...new Set(existingAgents)],
+    existingSkills: [...new Set(existingSkills)],
+    readmeExcerpt,
+    packageName,
+    packageDescription
+  };
+}
+var DEFAULT_REFERENCE_REPOSITORIES = [
+  {
+    id: "ring",
+    name: "LerianStudio/ring",
+    url: "https://github.com/LerianStudio/ring.git",
+    description: "Massive reference library for agents, skills, commands, and engineering standards.",
+    fallbackUrls: ["git@github.com:LerianStudio/ring.git"]
+  },
+  {
+    id: "agency-agents",
+    name: "msitarzewski/agency-agents",
+    url: "https://github.com/msitarzewski/agency-agents.git",
+    description: "Reference agent set focused on frontend, backend, QA, and review roles."
+  },
+  {
+    id: "impeccable",
+    name: "pbakaus/impeccable",
+    url: "https://github.com/pbakaus/impeccable.git",
+    description: "Frontend polish and impeccable-style quality workflows."
+  },
+  {
+    id: "everything-claude-code",
+    name: "affaan-m/everything-claude-code",
+    url: "https://github.com/affaan-m/everything-claude-code.git",
+    description: "28 specialized agents, 116 skills, and 59 commands \u2014 agent harness performance system."
+  }
+];
+var REPOSITORY_ROOT = resolve(homedir(), ".fifony", "repositories");
+var MAX_SCAN_DEPTH = 8;
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".github",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  "tmp",
+  "temp"
+]);
+var AGENCY_AGENTS_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  "examples",
+  "strategy"
+]);
+var REFERENCE_REPOSITORY_PARSERS = {
+  ring: collectStandardArtifacts,
+  "agency-agents": collectAgencyArtifacts,
+  impeccable: collectImpeccableArtifacts,
+  "everything-claude-code": collectStandardArtifacts
+};
+function runGit(args, cwd) {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: "pipe",
+    timeout: 12e4
+  }).toString().trim();
+}
+function slugify(value) {
+  const safe = value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/(^-|-$)/g, "");
+  return safe || "reference-item";
+}
+function uniqueSuffix(base, used) {
+  if (!used.has(base)) {
+    used.add(base);
+    return base;
+  }
+  let i = 0;
+  while (true) {
+    const candidate = `${base}-${++i}`;
+    if (!used.has(candidate)) {
+      used.add(candidate);
+      return candidate;
+    }
+  }
+}
+function collectDirectoryEntries(path) {
+  try {
+    return readdirSync(path, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function readRepositoryLine(path) {
+  try {
+    return runGit(["-C", path, "remote", "get-url", "origin"]);
+  } catch {
+    return void 0;
+  }
+}
+function readCurrentBranch(path) {
+  try {
+    return runGit(["-C", path, "rev-parse", "--abbrev-ref", "HEAD"]);
+  } catch {
+    return void 0;
+  }
+}
+function isMarkdownFile(value, expectedName) {
+  const lower = value.toLowerCase();
+  return lower.endsWith(".md") && lower !== expectedName;
+}
+function isReferenceFrontMatterFile(filePath) {
+  let source;
+  try {
+    source = readFileSync(filePath, "utf8");
+  } catch {
+    return false;
+  }
+  const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) {
+    return false;
+  }
+  const header = match[1];
+  return /^name:\s*.+/im.test(header) && /^description:\s*.+/im.test(header);
+}
+function buildRelativeArtifactName(repoPath, sourcePath) {
+  const relative = sourcePath.startsWith(repoPath) ? relativePath(repoPath, sourcePath) : sourcePath;
+  const parent = dirname(relative);
+  const parentSlug = parent === "." ? "" : parent.split(/[/\\]/).map((segment) => slugify(segment)).filter(Boolean).join("__");
+  const baseName = slugify(basename(relative, ".md"));
+  return parentSlug ? `${parentSlug}__${baseName}` : baseName;
+}
+function collectAgentArtifacts(agentsDir, usedNames, out) {
+  const parent = slugify(basename(dirname(agentsDir)));
+  const entries = collectDirectoryEntries(agentsDir);
+  for (const entry of entries) {
+    const itemPath = join(agentsDir, entry.name);
+    if (entry.isDirectory()) {
+      const nestedAgentSpec = join(itemPath, "AGENT.md");
+      if (existsSync(nestedAgentSpec)) {
+        const name2 = uniqueSuffix(`${parent}__${slugify(entry.name)}`, usedNames);
+        out.push({ kind: "agent", sourcePath: nestedAgentSpec, targetName: name2 });
+      }
+      continue;
+    }
+    if (!isMarkdownFile(entry.name, "readme.md")) {
+      continue;
+    }
+    const baseName = basename(entry.name, ".md");
+    if (baseName.trim().length === 0 || baseName.toLowerCase() === "changelog") {
+      continue;
+    }
+    const name = uniqueSuffix(`${parent}__${slugify(baseName)}`, usedNames);
+    out.push({ kind: "agent", sourcePath: itemPath, targetName: name });
+  }
+}
+function collectSkillArtifacts(skillsDir, usedNames, out) {
+  const parent = slugify(basename(dirname(skillsDir)));
+  const entries = collectDirectoryEntries(skillsDir);
+  for (const entry of entries) {
+    const itemPath = join(skillsDir, entry.name);
+    if (entry.isDirectory()) {
+      const skillFile = join(itemPath, "SKILL.md");
+      if (existsSync(skillFile)) {
+        const name = uniqueSuffix(`${parent}__${slugify(entry.name)}`, usedNames);
+        out.push({ kind: "skill", sourcePath: skillFile, targetName: name });
+      }
+      continue;
+    }
+    if (entry.isFile() && entry.name.toLowerCase() === "skill.md") {
+      const name = uniqueSuffix(`${parent}__skill`, usedNames);
+      out.push({ kind: "skill", sourcePath: itemPath, targetName: name });
+    }
+  }
+}
+function collectStandardArtifacts(repoPath) {
+  const agentsUsed = /* @__PURE__ */ new Set();
+  const skillsUsed = /* @__PURE__ */ new Set();
+  const artifacts = [];
+  const queue = [{ path: repoPath, depth: 0 }];
+  while (queue.length > 0) {
+    const state = queue.shift();
+    if (!state) break;
+    if (state.depth > MAX_SCAN_DEPTH) {
+      continue;
+    }
+    const entries = collectDirectoryEntries(state.path);
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (SKIP_DIRS.has(entry.name)) continue;
+      const childPath = join(state.path, entry.name);
+      if (entry.name === "agents") {
+        collectAgentArtifacts(childPath, agentsUsed, artifacts);
+      }
+      if (entry.name === "skills") {
+        collectSkillArtifacts(childPath, skillsUsed, artifacts);
+      }
+      queue.push({ path: childPath, depth: state.depth + 1 });
+    }
+  }
+  return artifacts;
+}
+function collectAgencyArtifacts(repoPath) {
+  const agentsUsed = /* @__PURE__ */ new Set();
+  const artifacts = [];
+  const queue = [{ path: repoPath, depth: 0 }];
+  while (queue.length > 0) {
+    const state = queue.shift();
+    if (!state) break;
+    if (state.depth > MAX_SCAN_DEPTH) {
+      continue;
+    }
+    const entries = collectDirectoryEntries(state.path);
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name) || AGENCY_AGENTS_EXCLUDED_DIRS.has(entry.name)) {
+          continue;
+        }
+        queue.push({ path: join(state.path, entry.name), depth: state.depth + 1 });
+        continue;
+      }
+      if (!isMarkdownFile(entry.name, "readme.md") || !isReferenceFrontMatterFile(join(state.path, entry.name))) {
+        continue;
+      }
+      const itemPath = join(state.path, entry.name);
+      const targetName = uniqueSuffix(buildRelativeArtifactName(repoPath, itemPath), agentsUsed);
+      artifacts.push({
+        kind: "agent",
+        sourcePath: itemPath,
+        targetName
+      });
+    }
+  }
+  return artifacts;
+}
+function collectImpeccableArtifacts(repoPath) {
+  const skillsUsed = /* @__PURE__ */ new Set();
+  const artifacts = [];
+  const sourceSkills = join(repoPath, "source", "skills");
+  if (existsSync(sourceSkills)) {
+    collectSkillArtifacts(sourceSkills, skillsUsed, artifacts);
+    return artifacts;
+  }
+  const claudeSkills = join(repoPath, ".claude", "skills");
+  if (existsSync(claudeSkills)) {
+    collectSkillArtifacts(claudeSkills, skillsUsed, artifacts);
+  }
+  return artifacts;
+}
+function collectArtifacts(repoPath, repositoryId) {
+  const parser = repositoryId && REFERENCE_REPOSITORY_PARSERS[repositoryId] ? REFERENCE_REPOSITORY_PARSERS[repositoryId] : collectStandardArtifacts;
+  return parser(repoPath);
+}
+function countArtifactKinds(artifacts) {
+  let agents = 0;
+  let skills = 0;
+  for (const artifact of artifacts) {
+    if (artifact.kind === "agent") {
+      agents += 1;
+    } else {
+      skills += 1;
+    }
+  }
+  return { agents, skills };
+}
+function getReferenceRepositoriesRoot() {
+  return REPOSITORY_ROOT;
+}
+function listReferenceRepositories() {
+  return DEFAULT_REFERENCE_REPOSITORIES.map((repo) => {
+    const path = join(REPOSITORY_ROOT, repo.id);
+    const status = {
+      id: repo.id,
+      name: repo.name,
+      url: repo.url,
+      path,
+      present: existsSync(path),
+      synced: false
+    };
+    if (!status.present) {
+      return status;
+    }
+    if (!existsSync(join(path, ".git"))) {
+      status.error = "Path exists but is not a git repo";
+      return status;
+    }
+    status.remote = readRepositoryLine(path);
+    status.branch = readCurrentBranch(path);
+    status.synced = typeof status.remote === "string";
+    if (status.synced) {
+      const artifacts = collectArtifacts(path, repo.id);
+      status.artifactCounts = countArtifactKinds(artifacts);
+    }
+    return status;
+  });
+}
+function resolveReferenceRepository(query) {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) return void 0;
+  const normalizedWithoutGit = normalized.endsWith(".git") ? normalized.slice(0, -4) : normalized;
+  return DEFAULT_REFERENCE_REPOSITORIES.find(
+    (repo) => repo.id.toLowerCase() === normalizedWithoutGit || repo.name.toLowerCase() === normalizedWithoutGit || repo.url.toLowerCase() === normalized || repo.url.toLowerCase() === normalizedWithoutGit || repo.url.toLowerCase().endsWith(`/${normalizedWithoutGit}.git`) || repo.url.toLowerCase().endsWith(`/${normalizedWithoutGit}`)
+  );
+}
+function syncReferenceRepositories(repositoryId) {
+  const root = REPOSITORY_ROOT;
+  mkdirSync(root, { recursive: true });
+  const repos = repositoryId ? [resolveReferenceRepository(repositoryId)] : DEFAULT_REFERENCE_REPOSITORIES;
+  const selected = repos.filter((repo) => Boolean(repo));
+  if (repositoryId && selected.length === 0) {
+    throw new Error(`Unknown reference repository: ${repositoryId}`);
+  }
+  const results = [];
+  for (const repo of selected) {
+    const target = join(root, repo.id);
+    const candidates = [repo.url, ...repo.fallbackUrls ?? []];
+    if (!existsSync(target)) {
+      let cloneError;
+      for (const candidate of candidates) {
+        try {
+          runGit(["clone", "--depth", "1", candidate, target]);
+          results.push({
+            id: repo.id,
+            path: target,
+            action: "cloned",
+            message: `Cloned ${candidate}`
+          });
+          cloneError = void 0;
+          break;
+        } catch (error) {
+          cloneError = error instanceof Error ? error.message : String(error);
+        }
+      }
+      if (cloneError) {
+        results.push({
+          id: repo.id,
+          path: target,
+          action: "failed",
+          message: cloneError
+        });
+      }
+      continue;
+    }
+    if (!existsSync(join(target, ".git"))) {
+      results.push({
+        id: repo.id,
+        path: target,
+        action: "failed",
+        message: "Path exists but is not a git repository"
+      });
+      continue;
+    }
+    try {
+      runGit(["-C", target, "fetch", "--all", "--prune"]);
+      runGit(["-C", target, "pull", "--ff-only"]);
+      results.push({
+        id: repo.id,
+        path: target,
+        action: "updated",
+        message: "Updated from remote"
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      results.push({
+        id: repo.id,
+        path: target,
+        action: "failed",
+        message
+      });
+    }
+  }
+  return results;
+}
+function importReferenceArtifacts(repositoryId, workspaceRoot, options) {
+  const repository = resolveReferenceRepository(repositoryId);
+  if (!repository) {
+    throw new Error(`Unknown reference repository: ${repositoryId}`);
+  }
+  const localPath = join(REPOSITORY_ROOT, repository.id);
+  if (!existsSync(localPath)) {
+    throw new Error(`Repository not synced yet: ${repository.id}. Run 'fifony onboarding sync --repository ${repository.id}' first.`);
+  }
+  const basePath = resolve(workspaceRoot);
+  const targetBase = options.importToGlobal ? join(homedir(), ".codex") : join(basePath, ".codex");
+  const agentsDir = join(targetBase, "agents");
+  const skillsDir = join(targetBase, "skills");
+  const artifacts = collectArtifacts(localPath, repository.id);
+  const filtered = options.kind === "all" ? artifacts : artifacts.filter((artifact) => artifact.kind === options.kind.slice(0, -1));
+  const summary = {
+    repositoryId: repository.id,
+    localPath,
+    requestedKind: options.kind,
+    dryRun: options.dryRun,
+    importedAgents: [],
+    importedSkills: [],
+    skippedAgents: [],
+    skippedSkills: [],
+    errors: []
+  };
+  if (filtered.length === 0) {
+    return summary;
+  }
+  if (!options.dryRun) {
+    mkdirSync(targetBase, { recursive: true });
+    mkdirSync(agentsDir, { recursive: true });
+    mkdirSync(skillsDir, { recursive: true });
+  }
+  for (const artifact of filtered) {
+    try {
+      const source = readFileSync(artifact.sourcePath, "utf8");
+      if (artifact.kind === "agent") {
+        const target = join(agentsDir, `${artifact.targetName}.md`);
+        if (!options.overwrite && existsSync(target)) {
+          summary.skippedAgents.push(artifact.targetName);
+          continue;
+        }
+        if (options.dryRun) {
+          summary.importedAgents.push(artifact.targetName);
+          continue;
+        }
+        writeFileSync(target, source, "utf8");
+        summary.importedAgents.push(artifact.targetName);
+      } else {
+        const targetDir = join(skillsDir, artifact.targetName);
+        const target = join(targetDir, "SKILL.md");
+        if (!options.overwrite && existsSync(target)) {
+          summary.skippedSkills.push(artifact.targetName);
+          continue;
+        }
+        if (options.dryRun) {
+          summary.importedSkills.push(artifact.targetName);
+          continue;
+        }
+        mkdirSync(targetDir, { recursive: true });
+        writeFileSync(target, source, "utf8");
+        summary.importedSkills.push(artifact.targetName);
+      }
+    } catch (error) {
+      summary.errors.push({
+        kind: artifact.kind,
+        targetName: artifact.targetName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return summary;
+}
+
+// src/domains/config.ts
+import { env } from "process";
+var VALID_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "extra-high"]);
+function parseEffortValue(value) {
+  const str = typeof value === "string" ? value.trim().toLowerCase() : "";
+  return VALID_EFFORTS.has(str) ? str : void 0;
+}
+function parseEffortConfig(value) {
+  if (!value || typeof value !== "object") {
+    const simple = parseEffortValue(value);
+    return simple ? { default: simple } : void 0;
+  }
+  const obj = value;
+  const config = {};
+  const d = parseEffortValue(obj.default);
+  const p = parseEffortValue(obj.planner);
+  const e = parseEffortValue(obj.executor);
+  const r = parseEffortValue(obj.reviewer);
+  if (d) config.default = d;
+  if (p) config.planner = p;
+  if (e) config.executor = e;
+  if (r) config.reviewer = r;
+  return Object.keys(config).length > 0 ? config : void 0;
+}
+function deriveConfig(args) {
+  const parsedConcurrency = parsePositiveIntEnv("FIFONY_WORKER_CONCURRENCY", 3);
+  let pollIntervalMs = parseEnvNumber("FIFONY_POLL_INTERVAL_MS", 1200);
+  let workerConcurrency = parsedConcurrency;
+  let maxAttemptsDefault = parseEnvNumber("FIFONY_MAX_ATTEMPTS", 3);
+  let commandTimeoutMs = parseEnvNumber("FIFONY_AGENT_TIMEOUT_MS", 18e5);
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--poll") {
+      const value = args[i + 1] ?? "";
+      if (!/^\d+$/.test(value)) fail(`Invalid value for --poll: ${value}`);
+      pollIntervalMs = parseIntArg(value, pollIntervalMs);
+    }
+    if (arg === "--concurrency") {
+      const value = args[i + 1] ?? "";
+      if (!/^\d+$/.test(value)) fail(`Invalid value for --concurrency: ${value}`);
+      workerConcurrency = parseIntArg(value, workerConcurrency);
+    }
+    if (arg === "--attempts") {
+      const value = args[i + 1] ?? "";
+      if (!/^\d+$/.test(value)) fail(`Invalid value for --attempts: ${value}`);
+      maxAttemptsDefault = parseIntArg(value, maxAttemptsDefault);
+    }
+    if (arg === "--timeout") {
+      const value = args[i + 1] ?? "";
+      if (!/^\d+$/.test(value)) fail(`Invalid value for --timeout: ${value}`);
+      commandTimeoutMs = parseIntArg(value, commandTimeoutMs);
+    }
+  }
+  return {
+    pollIntervalMs: clamp(pollIntervalMs, 200, 1e4),
+    workerConcurrency: clamp(workerConcurrency, 1, 10),
+    commandTimeoutMs: clamp(commandTimeoutMs, 1e3, 36e5),
+    maxAttemptsDefault: clamp(maxAttemptsDefault, 1, 10),
+    maxTurns: clamp(parseEnvNumber("FIFONY_AGENT_MAX_TURNS", 4), 1, 50),
+    retryDelayMs: parseEnvNumber("FIFONY_RETRY_DELAY_MS", 3e3),
+    staleInProgressTimeoutMs: parseEnvNumber("FIFONY_STALE_IN_PROGRESS_MS", 24e5),
+    logLinesTail: parseEnvNumber("FIFONY_LOG_TAIL_CHARS", 12e3),
+    maxPreviousOutputChars: parseEnvNumber("FIFONY_PREVIOUS_OUTPUT_CHARS", 2e4),
+    agentProvider: normalizeAgentProvider(env.FIFONY_AGENT_PROVIDER ?? "codex"),
+    agentCommand: toStringValue(env.FIFONY_AGENT_COMMAND, ""),
+    defaultEffort: {
+      default: parseEffortValue(env.FIFONY_REASONING_EFFORT),
+      planner: parseEffortValue(env.FIFONY_PLANNER_EFFORT),
+      executor: parseEffortValue(env.FIFONY_EXECUTOR_EFFORT),
+      reviewer: parseEffortValue(env.FIFONY_REVIEWER_EFFORT)
+    },
+    maxConcurrentByState: {},
+    runMode: "filesystem",
+    autoReviewApproval: true,
+    dockerExecution: false,
+    dockerImage: "fifony-agent:latest",
+    adaptiveHarnessSelection: toStringValue(env.FIFONY_ADAPTIVE_HARNESS_SELECTION, "true") !== "false",
+    adaptiveReviewRouting: toStringValue(env.FIFONY_ADAPTIVE_REVIEW_ROUTING, "true") !== "false",
+    adaptivePolicyMinSamples: clamp(parseEnvNumber("FIFONY_ADAPTIVE_POLICY_MIN_SAMPLES", 3), 1, 10),
+    afterCreateHook: env.FIFONY_AFTER_CREATE_HOOK ?? "",
+    beforeRunHook: env.FIFONY_BEFORE_RUN_HOOK ?? "",
+    afterRunHook: env.FIFONY_AFTER_RUN_HOOK ?? "",
+    beforeRemoveHook: env.FIFONY_BEFORE_REMOVE_HOOK ?? "",
+    serviceEnv: {}
+  };
+}
+function applyWorkflowConfig(config, port) {
+  return {
+    ...config,
+    dashboardPort: port ? String(port) : config.dashboardPort
+  };
+}
+function validateConfig(config) {
+  const errors = [];
+  if (config.pollIntervalMs < 200) errors.push(`pollIntervalMs too low: ${config.pollIntervalMs} (min 200)`);
+  if (config.workerConcurrency < 1 || config.workerConcurrency > 10) errors.push(`workerConcurrency out of range: ${config.workerConcurrency} (1-10)`);
+  if (config.maxAttemptsDefault < 1 || config.maxAttemptsDefault > 10) errors.push(`maxAttemptsDefault out of range: ${config.maxAttemptsDefault} (1-10)`);
+  if (config.maxTurns < 1 || config.maxTurns > 50) errors.push(`maxTurns out of range: ${config.maxTurns} (1-50)`);
+  if (config.commandTimeoutMs < 1e3) errors.push(`commandTimeoutMs too low: ${config.commandTimeoutMs} (min 1000)`);
+  if (config.retryDelayMs < 0) errors.push(`retryDelayMs negative: ${config.retryDelayMs}`);
+  if (config.adaptivePolicyMinSamples !== void 0 && (config.adaptivePolicyMinSamples < 1 || config.adaptivePolicyMinSamples > 10)) {
+    errors.push(`adaptivePolicyMinSamples out of range: ${config.adaptivePolicyMinSamples} (1-10)`);
+  }
+  for (const [stateKey, limit] of Object.entries(config.maxConcurrentByState)) {
+    if (limit < 1) errors.push(`maxConcurrentByState[${stateKey}] must be >= 1, got ${limit}`);
+  }
+  return errors;
+}
+
+// src/domains/milestones.ts
+function slugifyMilestoneName(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "milestone";
+}
+function normalizeMilestone(raw) {
+  const id = toStringValue(raw.id, "");
+  if (!id) return null;
+  const createdAt = toStringValue(raw.createdAt, now());
+  const updatedAt = toStringValue(raw.updatedAt, createdAt);
+  const name = toStringValue(raw.name, "").trim();
+  if (!name) return null;
+  return {
+    id,
+    slug: toStringValue(raw.slug, slugifyMilestoneName(name)),
+    name,
+    description: toStringValue(raw.description) || void 0,
+    status: normalizeMilestoneStatus(raw.status),
+    createdAt,
+    updatedAt,
+    progress: { scopeCount: 0, completedCount: 0, progressPercent: 0 },
+    issueCount: 0
+  };
+}
+function normalizeMilestoneStatus(value) {
+  const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
+  return normalized === "planned" || normalized === "active" || normalized === "paused" || normalized === "done" || normalized === "cancelled" ? normalized : "planned";
+}
+function createMilestoneFromPayload(payload) {
+  const createdAt = now();
+  const name = toStringValue(payload.name, "").trim();
+  if (!name) {
+    throw new Error("Milestone name is required.");
+  }
+  return {
+    id: toStringValue(payload.id, `milestone-${crypto.randomUUID()}`),
+    slug: toStringValue(payload.slug, slugifyMilestoneName(name)),
+    name,
+    description: toStringValue(payload.description) || void 0,
+    status: normalizeMilestoneStatus(payload.status),
+    createdAt,
+    updatedAt: createdAt,
+    progress: { scopeCount: 0, completedCount: 0, progressPercent: 0 },
+    issueCount: 0
+  };
+}
+function findMilestone(state, milestoneId) {
+  return state.milestones.find((milestone) => milestone.id === milestoneId || milestone.slug === milestoneId);
+}
+function deriveMilestoneProgressSummary(issues) {
+  const scopedIssues = issues.filter((issue) => issue.state !== "Cancelled" && issue.state !== "Archived");
+  const completedCount = scopedIssues.filter((issue) => COMPLETED_STATES.has(issue.state) && issue.state !== "Cancelled" && issue.state !== "Archived").length;
+  const scopeCount = scopedIssues.length;
+  return {
+    scopeCount,
+    completedCount,
+    progressPercent: scopeCount === 0 ? 0 : Math.floor(completedCount / scopeCount * 100)
+  };
+}
+function refreshMilestoneSummaries(state) {
+  state.milestones = state.milestones.map((milestone) => {
+    const linkedIssues = state.issues.filter((issue) => issue.milestoneId === milestone.id);
+    return {
+      ...milestone,
+      progress: deriveMilestoneProgressSummary(linkedIssues),
+      issueCount: linkedIssues.length
+    };
+  });
+}
+
+// src/domains/issues.ts
+var issueTransitionExecutor = null;
+function setIssueTransitionExecutor(executor) {
+  issueTransitionExecutor = executor;
+}
+function getIssueTransitionExecutor() {
+  return issueTransitionExecutor;
+}
+function normalizeIssue(raw) {
+  const id = toStringValue(raw.id, "");
+  if (!id) return null;
+  const createdAt = toStringValue(raw.createdAt, now());
+  const updatedAt = toStringValue(raw.updatedAt, createdAt);
+  const milestoneId = toStringValue(raw.milestoneId) || toStringValue(raw["projectId"]) || void 0;
+  const issue = {
+    id,
+    identifier: toStringValue(raw.identifier, id),
+    title: toStringValue(raw.title, `Issue ${id}`),
+    description: toStringValue(raw.description, ""),
+    state: normalizeState(raw.state, raw.plan && typeof raw.plan === "object" ? "PendingApproval" : "Planning"),
+    milestoneId,
+    branchName: toStringValue(raw.branchName),
+    url: toStringValue(raw.url),
+    assigneeId: toStringValue(raw.assigneeId),
+    labels: toStringArray(raw.labels),
+    paths: toStringArray(raw.paths),
+    blockedBy: toStringArray(raw.blockedBy),
+    assignedToWorker: toBooleanValue(raw.assignedToWorker, true),
+    createdAt,
+    updatedAt,
+    history: [],
+    attempts: toNumberValue(raw.attempts, 0),
+    maxAttempts: toNumberValue(raw.maxAttempts, 3),
+    nextRetryAt: toStringValue(raw.nextRetryAt),
+    planVersion: 0,
+    executeAttempt: 0,
+    reviewAttempt: 0,
+    checkpointAttempt: 0,
+    contractNegotiationAttempt: 0,
+    planHistory: [],
+    contractNegotiationRuns: [],
+    reviewRuns: [],
+    reviewFailureHistory: [],
+    policyDecisions: [],
+    contextReportsByRole: {},
+    memoryFlushCount: 0
+  };
+  return issue;
+}
+function nextLocalIssueId(issues) {
+  const maxId = issues.reduce((current, issue) => {
+    const match = issue.identifier.match(/^#(\d+)$/);
+    if (!match) return current;
+    const parsed = Number.parseInt(match[1], 10);
+    return Number.isFinite(parsed) ? Math.max(current, parsed) : current;
+  }, 0);
+  return `#${maxId + 1}`;
+}
+function createIssueFromPayload(payload, issues, defaultBranch) {
+  const identifier = toStringValue(payload.identifier, nextLocalIssueId(issues));
+  const id = toStringValue(payload.id, identifier.replace(/^#/, "issue-"));
+  logger.info({ id, identifier, title: toStringValue(payload.title, "").slice(0, 80) }, "[Issues] Creating new issue");
+  const createdAt = now();
+  const blockedBy = toStringArray(payload.blockedBy);
+  const paths = toStringArray(payload.paths);
+  const images = toStringArray(payload.images);
+  const initialState = parseIssueState(payload.state) ?? (payload.plan ? "PendingApproval" : "Planning");
+  const issue = {
+    id,
+    identifier,
+    title: toStringValue(payload.title, `Issue ${identifier}`),
+    description: toStringValue(payload.description, ""),
+    state: initialState,
+    milestoneId: toStringValue(payload.milestoneId) || void 0,
+    branchName: toStringValue(payload.branchName),
+    baseBranch: toStringValue(payload.baseBranch) || defaultBranch,
+    url: toStringValue(payload.url),
+    assigneeId: toStringValue(payload.assigneeId),
+    labels: toStringArray(payload.labels),
+    paths,
+    blockedBy,
+    assignedToWorker: true,
+    createdAt,
+    updatedAt: createdAt,
+    history: [`[${createdAt}] Issue created via API.`],
+    attempts: 0,
+    maxAttempts: clamp(toNumberValue(payload.maxAttempts, 3), 1, 10),
+    terminalWeek: "",
+    images: images.length ? images : void 0,
+    issueType: toStringValue(payload.issueType) || void 0,
+    effort: parseEffortConfig(payload.effort),
+    plan: payload.plan && typeof payload.plan === "object" ? payload.plan : void 0,
+    planVersion: payload.plan ? 1 : 0,
+    executeAttempt: 0,
+    reviewAttempt: 0,
+    checkpointAttempt: 0,
+    contractNegotiationAttempt: 0,
+    planHistory: [],
+    contractNegotiationRuns: [],
+    reviewRuns: [],
+    reviewFailureHistory: [],
+    policyDecisions: [],
+    contextReportsByRole: {},
+    memoryFlushCount: 0
+  };
+  if (issue.plan) {
+    if (issue.plan.suggestedPaths?.length && !issue.paths?.length) {
+      issue.paths = issue.plan.suggestedPaths;
+    }
+    if (issue.plan.suggestedEffort && !issue.effort) {
+      issue.effort = issue.plan.suggestedEffort;
+    }
+  }
+  return issue;
+}
+function dedupHistoryEntries(issues) {
+  for (const issue of issues) {
+    const seen = /* @__PURE__ */ new Set();
+    issue.history = issue.history.filter((entry) => {
+      const key = entry.toLowerCase();
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+}
+function buildRuntimeState(previous, config, projectMetadata = resolveProjectMetadata([], TARGET_ROOT), persistedMilestones = []) {
+  const mergedIssues = (previous?.issues ?? []).reduce((issues, rawIssue) => {
+    if (!rawIssue || typeof rawIssue !== "object") return issues;
+    const existing = rawIssue;
+    const existingRecord = rawIssue;
+    issues.push({
+      ...existing,
+      id: toStringValue(existing.id, ""),
+      identifier: toStringValue(existing.identifier, existing.id),
+      title: toStringValue(existing.title, `Issue ${toStringValue(existing.identifier, existing.id)}`),
+      description: toStringValue(existing.description, ""),
+      state: normalizeState(existing.state, existing.plan ? "PendingApproval" : "Planning"),
+      milestoneId: toStringValue(existing.milestoneId) || toStringValue(existingRecord["projectId"]) || void 0,
+      paths: toStringArray(existing.paths),
+      labels: toStringArray(existing.labels),
+      blockedBy: toStringArray(existing.blockedBy),
+      history: Array.isArray(existing.history) ? existing.history : [],
+      attempts: clamp(toNumberValue(existing.attempts, 0), 0, config.maxAttemptsDefault),
+      maxAttempts: clamp(toNumberValue(existing.maxAttempts, config.maxAttemptsDefault), 1, config.maxAttemptsDefault),
+      nextRetryAt: toStringValue(existing.nextRetryAt),
+      updatedAt: toStringValue(existing.updatedAt, now()),
+      createdAt: toStringValue(existing.createdAt, now()),
+      planVersion: toNumberValue(existing.planVersion, existing.plan ? 1 : 0),
+      executeAttempt: toNumberValue(existing.executeAttempt, toNumberValue(existing.attempts, 0)),
+      reviewAttempt: toNumberValue(existing.reviewAttempt, toNumberValue(existing.attempts, 0)),
+      checkpointAttempt: toNumberValue(existing.checkpointAttempt, 0),
+      contractNegotiationAttempt: toNumberValue(existing.contractNegotiationAttempt, 0),
+      checkpointStatus: toStringValue(existing.checkpointStatus),
+      checkpointPassedAt: toStringValue(existing.checkpointPassedAt) || void 0,
+      contractNegotiationStatus: toStringValue(existing.contractNegotiationStatus),
+      planHistory: Array.isArray(existing.planHistory) ? existing.planHistory : [],
+      contractNegotiationRuns: Array.isArray(existing.contractNegotiationRuns) ? existing.contractNegotiationRuns : [],
+      reviewRuns: Array.isArray(existing.reviewRuns) ? existing.reviewRuns : [],
+      reviewFailureHistory: Array.isArray(existing.reviewFailureHistory) ? existing.reviewFailureHistory : [],
+      policyDecisions: Array.isArray(existing.policyDecisions) ? existing.policyDecisions : [],
+      contextReportsByRole: existing.contextReportsByRole && typeof existing.contextReportsByRole === "object" ? existing.contextReportsByRole : {},
+      memoryFlushAt: toStringValue(existing.memoryFlushAt) || void 0,
+      memoryFlushCount: toNumberValue(existing.memoryFlushCount, 0)
+    });
+    return issues;
+  }, []).filter((issue) => issue.id);
+  for (const issue of mergedIssues) {
+    if (TERMINAL_STATES.has(issue.state) && !issue.terminalWeek) {
+      issue.terminalWeek = isoWeek(issue.completedAt || issue.updatedAt);
+    } else if (!TERMINAL_STATES.has(issue.state)) {
+      issue.terminalWeek = "";
+    }
+  }
+  dedupHistoryEntries(mergedIssues);
+  const metrics = computeMetrics(mergedIssues);
+  const mergedMilestones = (previous?.milestones ?? persistedMilestones).map((milestone) => normalizeMilestone(milestone)).filter((milestone) => Boolean(milestone));
+  const state = {
+    startedAt: previous?.startedAt ?? now(),
+    updatedAt: now(),
+    trackerKind: "filesystem",
+    sourceRepoUrl: TARGET_ROOT,
+    sourceRef: "workspace",
+    projectName: projectMetadata.projectName,
+    detectedProjectName: projectMetadata.detectedProjectName,
+    projectNameSource: projectMetadata.projectNameSource,
+    queueTitle: projectMetadata.queueTitle,
+    config: {
+      ...config,
+      dashboardPort: previous?.config.dashboardPort
+    },
+    milestones: mergedMilestones,
+    issues: mergedIssues,
+    events: previous?.events ?? [],
+    metrics,
+    notes: previous?.notes ?? [
+      "Local TypeScript runtime bootstrapped.",
+      "Codex-only execution path enabled.",
+      "No external tracker dependency (filesystem-backed local mode)."
+    ],
+    variables: previous?.variables ?? []
+  };
+  refreshMilestoneSummaries(state);
+  return state;
+}
+function addEvent(state, issueId, kind, message) {
+  const event = {
+    id: `${Date.now()}-${state.events.length + 1}`,
+    issueId,
+    kind,
+    message,
+    at: now()
+  };
+  state.events = [event, ...state.events].slice(0, PERSIST_EVENTS_MAX);
+  markEventDirty(event.id);
+  try {
+    recordEvent();
+  } catch {
+  }
+  if (issueId) {
+    const issue = state.issues.find((i) => i.id === issueId);
+    if (issue) {
+      issue.eventsCount = (issue.eventsCount || 0) + 1;
+      markIssueDirty(issue.id);
+    }
+  }
+  logger.info({ issueId, kind }, message);
+}
+async function transitionIssue(issue, event, context = {}) {
+  logger.debug({ issueId: issue.id, identifier: issue.identifier, from: issue.state, event, context }, "[State] Issue transition");
+  if (!issueTransitionExecutor) {
+    const { executeTransition } = await import("./fsm-issue-YGGF7SIL.js");
+    await executeTransition(issue, event, { ...context, issue });
+    return;
+  }
+  await issueTransitionExecutor(issue, event, { ...context, issue });
+}
+function issueDependenciesResolved(issue, allIssues) {
+  if (issue.blockedBy.length === 0) return true;
+  const map = new Map(allIssues.map((entry) => [entry.id, entry]));
+  return issue.blockedBy.every((dependencyId) => {
+    const dep = map.get(dependencyId);
+    return dep?.state === "Approved" || dep?.state === "Merged";
+  });
+}
+function getNextRetryAt(issue, baseMs) {
+  const nextAttempt = issue.attempts + 1;
+  const nextDelay = withRetryBackoff(nextAttempt, baseMs);
+  return new Date(Date.now() + nextDelay).toISOString();
+}
+
+export {
+  buildQueueTitle,
+  SETTING_ID_PROJECT_NAME,
+  detectProjectName,
+  resolveProjectMetadata,
+  scanProjectFiles,
+  collectArtifacts,
+  getReferenceRepositoriesRoot,
+  listReferenceRepositories,
+  syncReferenceRepositories,
+  importReferenceArtifacts,
+  record,
+  getHourlySnapshot,
+  hydrate,
+  getAnalytics,
+  deriveConfig,
+  applyWorkflowConfig,
+  validateConfig,
+  normalizeMilestone,
+  normalizeMilestoneStatus,
+  createMilestoneFromPayload,
+  findMilestone,
+  refreshMilestoneSummaries,
+  setIssueTransitionExecutor,
+  getIssueTransitionExecutor,
+  normalizeIssue,
+  nextLocalIssueId,
+  createIssueFromPayload,
+  dedupHistoryEntries,
+  buildRuntimeState,
+  addEvent,
+  transitionIssue,
+  issueDependenciesResolved,
+  getNextRetryAt
+};
+//# sourceMappingURL=chunk-E2EWEYA4.js.map