@desplega.ai/agent-swarm 1.110.0 → 1.112.0

package/src/be/memory/usefulness-stats.ts

@@ -0,0 +1,259 @@
+/**
+ * Windowed usefulness analytics over the memory measurement tables.
+ *
+ * Answers "is memory useful, per source and per retrieval arm" by reading the
+ * plumbing that Phases 1–2 of the memory-enhancements track already write:
+ *   - `memory_retrieval` — one row per memory surfaced to a task
+ *     (051 base + 096 contextKey/intent/eventType + 097 retrievalId/rank +
+ *     100 retrievalSource).
+ *   - `memory_rating`    — append-only RatingEvent audit (051 + 096
+ *     contextKey); `source='implicit-citation'` rows are the citation signal.
+ *   - `agent_memory.alpha/beta` — Beta-Binomial usefulness posteriors (051).
+ *
+ * Served by `GET /api/memory/usefulness` (src/http/memory.ts) as a sibling of
+ * the cheap `/api/memory/health` probe. Server-side only (owns SQL via
+ * `getDb()`); plan: thoughts/taras/plans/2026-07-02-memory-retrieval-v2-graph-and-measurement.md
+ * Phase 1.
+ */
+import { getDb } from "@/be/db";
+
+// ─── Shapes ──────────────────────────────────────────────────────────────────
+
+export interface UsefulnessVolume {
+  /** memory_retrieval rows inside the window. */
+  retrievals: number;
+  /** Distinct memories surfaced inside the window. */
+  distinctMemories: number;
+  /** Distinct retrievalId groups (one per search/get call; pre-097 rows have NULL and are not counted). */
+  retrievalGroups: number;
+  /** Window rows split by eventType (CHECK: 'search' | 'get'). */
+  byEventType: { search: number; get: number };
+}
+
+export interface UsefulnessArmStats {
+  /** memory_retrieval.retrievalSource — 'vec' | 'fts' | 'hybrid' | 'fallback' ('graph' after DES-639a); NULL = pre-100 legacy rows. */
+  retrievalSource: string | null;
+  retrievals: number;
+  distinctMemories: number;
+  /** Window rows whose (taskId, memoryId) got a positive implicit-citation rating. */
+  citedRetrievals: number;
+  /** citedRetrievals / retrievals. */
+  citationRate: number;
+}
+
+export interface UsefulnessSourceCitation {
+  /** agent_memory.source — 'manual' | 'file_index' | 'session_summary' | 'task_completion'. */
+  source: string;
+  /** implicit-citation rating rows inside the window. */
+  ratings: number;
+  /** Ratings with signal > 0 (memory was cited in task evidence). */
+  positive: number;
+  /** positive / ratings — a true rate in [0, 1] (implicit-citation signals are ±1). */
+  citationRate: number;
+  /** AVG(signal) over the window's implicit-citation ratings — in [-1, 1]. */
+  avgSignal: number;
+}
+
+export interface UsefulnessPosteriorStats {
+  totalMemories: number;
+  /** Memories whose posterior moved off the Beta(1,1) prior. */
+  movedFromPrior: number;
+  /** AVG(alpha / (alpha + beta)) across all memories; null when the store is empty. */
+  avgPosteriorMean: number | null;
+  /** Same average restricted to moved memories; null when none moved. */
+  avgPosteriorMeanMoved: number | null;
+  /** Memories with posterior mean above `threshold`. */
+  aboveThreshold: number;
+}
+
+export interface UsefulnessSanity {
+  /** All-time memory_retrieval row count — "is anything flowing". */
+  totalRetrievalRows: number;
+  /** All-time memory_rating row count. */
+  totalRatingRows: number;
+  /** All-time memory_rating rows grouped by rater source. */
+  ratingsBySource: { source: string; count: number }[];
+}
+
+export interface UsefulnessStats {
+  windowDays: number;
+  threshold: number;
+  /** ISO cutoff — rows strictly newer than this are inside the window. */
+  cutoff: string;
+  volume: UsefulnessVolume;
+  byArm: UsefulnessArmStats[];
+  citationBySource: UsefulnessSourceCitation[];
+  posterior: UsefulnessPosteriorStats;
+  sanity: UsefulnessSanity;
+}
+
+export interface UsefulnessStatsOptions {
+  /** Window size in days (default 30). */
+  days?: number;
+  /** Posterior-mean threshold for the aboveThreshold count (default 0.6). */
+  threshold?: number;
+}
+
+// ─── Query ───────────────────────────────────────────────────────────────────
+
+export function getUsefulnessStats(options: UsefulnessStatsOptions = {}): UsefulnessStats {
+  const days = options.days ?? 30;
+  const threshold = options.threshold ?? 0.6;
+  const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+  const db = getDb();
+
+  // Volume — window rows, distinct memories, per-call groups, eventType split.
+  // SUM(CASE …) instead of COUNT(*) FILTER for maximum SQLite compatibility.
+  const volumeRow = db
+    .prepare<
+      {
+        retrievals: number;
+        distinctMemories: number;
+        retrievalGroups: number;
+        searchEvents: number | null;
+        getEvents: number | null;
+      },
+      [string]
+    >(
+      `SELECT COUNT(*)                                                AS retrievals,
+              COUNT(DISTINCT memoryId)                                AS distinctMemories,
+              COUNT(DISTINCT retrievalId)                             AS retrievalGroups,
+              SUM(CASE WHEN eventType = 'search' THEN 1 ELSE 0 END)   AS searchEvents,
+              SUM(CASE WHEN eventType = 'get' THEN 1 ELSE 0 END)      AS getEvents
+         FROM memory_retrieval
+        WHERE retrievedAt > ?`,
+    )
+    .get(cutoff)!;
+
+  // Per-arm breakdown — retrieval provenance plus "did this surfaced memory
+  // get cited in the same task". EXISTS keeps multi-rating (task, memory)
+  // pairs from inflating the count. Restricted to search events: memory-get
+  // rows carry no retrievalSource and would otherwise pollute the NULL
+  // ("legacy") arm. NULL eventType = pre-096 rows, kept (they were searches).
+  const armRows = db
+    .prepare<
+      {
+        retrievalSource: string | null;
+        retrievals: number;
+        distinctMemories: number;
+        citedRetrievals: number | null;
+      },
+      [string]
+    >(
+      `SELECT mr.retrievalSource            AS retrievalSource,
+              COUNT(*)                      AS retrievals,
+              COUNT(DISTINCT mr.memoryId)   AS distinctMemories,
+              SUM(CASE WHEN EXISTS (
+                    SELECT 1
+                      FROM memory_rating rt
+                     WHERE rt.taskId = mr.taskId
+                       AND rt.memoryId = mr.memoryId
+                       AND rt.source = 'implicit-citation'
+                       AND rt.signal > 0
+                  ) THEN 1 ELSE 0 END)      AS citedRetrievals
+         FROM memory_retrieval mr
+        WHERE mr.retrievedAt > ?
+          AND (mr.eventType IS NULL OR mr.eventType = 'search')
+        GROUP BY mr.retrievalSource
+        ORDER BY retrievals DESC`,
+    )
+    .all(cutoff);
+
+  // Citation rate per memory-source — the reconstructed R4 §A.2 query.
+  const sourceRows = db
+    .prepare<
+      {
+        source: string;
+        ratings: number;
+        positive: number | null;
+        avgSignal: number | null;
+      },
+      [string]
+    >(
+      `SELECT am.source                                       AS source,
+              COUNT(*)                                        AS ratings,
+              SUM(CASE WHEN mr.signal > 0 THEN 1 ELSE 0 END)  AS positive,
+              AVG(mr.signal)                                  AS avgSignal
+         FROM memory_rating mr
+         JOIN agent_memory am ON am.id = mr.memoryId
+        WHERE mr.source = 'implicit-citation'
+          AND mr.createdAt > ?
+        GROUP BY am.source
+        ORDER BY ratings DESC`,
+    )
+    .all(cutoff);
+
+  // Posterior movement — how far the Beta(1,1) priors have drifted.
+  const posteriorRow = db
+    .prepare<
+      {
+        totalMemories: number;
+        movedFromPrior: number | null;
+        avgPosteriorMean: number | null;
+        avgPosteriorMeanMoved: number | null;
+        aboveThreshold: number | null;
+      },
+      [number]
+    >(
+      `SELECT COUNT(*)                                                   AS totalMemories,
+              SUM(CASE WHEN alpha <> 1.0 OR beta <> 1.0 THEN 1 ELSE 0 END) AS movedFromPrior,
+              AVG(alpha / (alpha + beta))                                AS avgPosteriorMean,
+              AVG(CASE WHEN alpha <> 1.0 OR beta <> 1.0
+                       THEN alpha / (alpha + beta) END)                  AS avgPosteriorMeanMoved,
+              SUM(CASE WHEN alpha / (alpha + beta) > ? THEN 1 ELSE 0 END) AS aboveThreshold
+         FROM agent_memory`,
+    )
+    .get(threshold)!;
+
+  // Sanity — all-time totals, unwindowed: "is anything flowing at all".
+  const totalRetrievalRows = db
+    .prepare<{ n: number }, []>("SELECT COUNT(*) AS n FROM memory_retrieval")
+    .get()!.n;
+  const ratingsBySource = db
+    .prepare<{ source: string; count: number }, []>(
+      "SELECT source, COUNT(*) AS count FROM memory_rating GROUP BY source ORDER BY count DESC",
+    )
+    .all();
+  const totalRatingRows = ratingsBySource.reduce((sum, row) => sum + row.count, 0);
+
+  return {
+    windowDays: days,
+    threshold,
+    cutoff,
+    volume: {
+      retrievals: volumeRow.retrievals,
+      distinctMemories: volumeRow.distinctMemories,
+      retrievalGroups: volumeRow.retrievalGroups,
+      byEventType: {
+        search: volumeRow.searchEvents ?? 0,
+        get: volumeRow.getEvents ?? 0,
+      },
+    },
+    byArm: armRows.map((row) => ({
+      retrievalSource: row.retrievalSource,
+      retrievals: row.retrievals,
+      distinctMemories: row.distinctMemories,
+      citedRetrievals: row.citedRetrievals ?? 0,
+      citationRate: row.retrievals > 0 ? (row.citedRetrievals ?? 0) / row.retrievals : 0,
+    })),
+    citationBySource: sourceRows.map((row) => ({
+      source: row.source,
+      ratings: row.ratings,
+      positive: row.positive ?? 0,
+      citationRate: row.ratings > 0 ? (row.positive ?? 0) / row.ratings : 0,
+      avgSignal: row.avgSignal ?? 0,
+    })),
+    posterior: {
+      totalMemories: posteriorRow.totalMemories,
+      movedFromPrior: posteriorRow.movedFromPrior ?? 0,
+      avgPosteriorMean: posteriorRow.avgPosteriorMean,
+      avgPosteriorMeanMoved: posteriorRow.avgPosteriorMeanMoved,
+      aboveThreshold: posteriorRow.aboveThreshold ?? 0,
+    },
+    sanity: {
+      totalRetrievalRows,
+      totalRatingRows,
+      ratingsBySource,
+    },
+  };
+}

package/src/be/migrations/107_memory_usefulness_indexes.sql

@@ -0,0 +1,12 @@
+-- Supporting indexes for the usefulness readout (GET /api/memory/usefulness)
+-- and the per-arm citation EXISTS probe. Prior to this, the windowed volume
+-- query scanned memory_retrieval (no retrievedAt index) and the citation
+-- EXISTS probed memory_rating via the single-column taskId index only.
+
+CREATE INDEX IF NOT EXISTS idx_memret_retrieved_at ON memory_retrieval(retrievedAt);
+
+-- Per-arm citation probe: EXISTS (taskId, memoryId, source, signal).
+CREATE INDEX IF NOT EXISTS idx_memrat_task_memory_source ON memory_rating(taskId, memoryId, source);
+
+-- Citation-by-source window: WHERE source = ? AND createdAt > ?.
+CREATE INDEX IF NOT EXISTS idx_memrat_source_created_at ON memory_rating(source, createdAt);

package/src/be/scripts/typecheck.ts

@@ -137,6 +137,8 @@ export interface SwarmSdk {
   slack_startThread(args: { channelId: string; message: string }): Promise<unknown>;
   slack_uploadFile(args: Record<string, unknown>): Promise<unknown>;
   slack_downloadFile(args: { url: string }): Promise<unknown>;
+  slack_delete(args: { channelId: string; messageTs: string }): Promise<unknown>;
+  slack_update(args: { channelId: string; messageTs: string; message: string }): Promise<unknown>;
 
   // --- write: messaging (internal) ---
   message_post(args: { channel?: string; content: string; to?: string }): Promise<unknown>;

package/src/be/seed-scripts/catalog/smart-recall.ts

@@ -15,17 +15,13 @@ export const argsSchema = z.object({
     .positive()
     .optional()
     .describe("Max results per query (default 10)"),
-  dedupThreshold: z
-    .number()
-    .optional()
-    .describe("Similarity threshold for dedup — memories above this are merged (default 0.92)"),
 });
 
 /** Multi-query fan-out memory recall with dedup and composite reranking. */
 export default async function smartRecall(args: any, ctx: any) {
   const parsed = argsSchema.safeParse(args);
   if (!parsed.success) return { error: "invalid args: " + parsed.error.message };
-  const { queries, scope = "all", limit = 10, dedupThreshold = 0.92 } = parsed.data;
+  const { queries, scope = "all", limit = 10 } = parsed.data;
 
   const allResults: any[] = [];
   for (const q of queries) {

package/src/commands/runner.ts

@@ -196,9 +196,111 @@ async function listSwarmAutostashes(clonePath: string, role: string): Promise<Sw
   }
 }
 
+/**
+ * Continuation task types that must NEVER take the destructive hard-reset path,
+ * even though they are not `taskType === "resume"`. Each of these ingress paths
+ * creates a NEW task that CONTINUES/cooperates with existing work — often on the
+ * same worker/reused clone — rather than starting genuinely fresh coding work:
+ *  - "follow-up" / "reroute-decision": lead-owned continuations created by
+ *    src/tasks/worker-follow-up.ts after a task completes/fails or needs
+ *    re-delegation; they inherit the parent's vcsRepo/branch context via
+ *    createTaskExtended's parentTaskId inheritance (src/be/db.ts).
+ *  - "agentmail-reply": AgentMail follow-up on an EXISTING thread
+ *    (src/agentmail/handlers.ts) — always carries `parentTaskId` pointing at
+ *    the task it's continuing (as opposed to "agentmail-message", which fires
+ *    only when no existing task was found for the thread).
+ *  - "github-comment" / "github-review" / "gitlab-comment" / "gitlab-ci":
+ *    tracker feedback on an ALREADY-OPEN PR/MR (review comments, review
+ *    verdicts, CI failures) — the point is to keep working on the existing
+ *    feature branch, not reset back to the default branch.
+ */
+const CONTINUATION_TASK_TYPES = new Set([
+  "resume",
+  "follow-up",
+  "reroute-decision",
+  "agentmail-reply",
+  "github-comment",
+  "github-review",
+  "gitlab-comment",
+  "gitlab-ci",
+]);
+
+/**
+ * Task statuses under which a task may have already mutated the shared clone
+ * (checked out a feature branch, left uncommitted/unpushed work) — or could
+ * still be doing so concurrently, e.g. with `maxTasks > 1` on the same worker.
+ * Mirrors the ACTIVE_TASK_STATUSES / getInProgressTasksByContextKey status
+ * sets already used server-side (src/agentmail/handlers.ts, src/be/db.ts) for
+ * the same "is this task still doing live work" question.
+ */
+const ACTIVE_PARENT_STATUSES = new Set<string>(["pending", "in_progress", "offered", "paused"]);
+
+/**
+ * A task is a "first kickoff" (safe to hard-reset the base branch) only when it
+ * is BOTH (a) not an explicit continuation task-type and (b) not parent-linked
+ * to a still-active task.
+ *
+ * `parentTaskId` alone is NOT a resume signal — send-task/trackers set it on
+ * ~every dispatched child task (verified 395/395 real coding tasks carried one;
+ * 0 were typed "resume"), so gating on its mere presence made the reset a no-op
+ * in production (see git history on this function). But the *opposite*
+ * over-correction — treating every non-"resume" task as a safe root kickoff —
+ * is also wrong: several ingress paths create parent-linked NON-resume tasks
+ * specifically to CONTINUE existing work, often on the same worker/reused
+ * clone:
+ *  - Slack follow-ups (src/slack/handlers.ts) wire `parentTaskId:
+ *    latestTask?.id` with NO distinguishing taskType at all.
+ *  - Sibling-awareness (src/tasks/sibling-awareness.ts, applied to every
+ *    ingress via createTaskWithSiblingAwareness) wires `parentTaskId` to an
+ *    in-progress same-agent sibling for session continuity — again with no
+ *    reserved taskType.
+ *  - AgentMail replies, tracker comments/reviews/CI events — see
+ *    CONTINUATION_TASK_TYPES.
+ * Since the first two carry no reserved taskType, a taskType denylist alone
+ * cannot catch them — we ALSO check whether `parentTaskId` currently points at
+ * a still-active task (ACTIVE_PARENT_STATUSES). If so, that parent/sibling may
+ * hold a checked-out feature branch or unpushed/uncommitted work in the SAME
+ * shared clone (especially with `maxTasks > 1`), so a hard reset there would
+ * destroy it — take the non-destructive merge path instead.
+ *
+ * `fetchParentTaskStatus` is injected so this stays a pure, unit-testable
+ * function; the real call site fetches `GET /api/tasks/{id}` (same pattern as
+ * fetchProviderSessionInfo below).
+ */
+export async function isFirstKickoffTask(
+  task?: { taskType?: string; parentTaskId?: string } | null,
+  fetchParentTaskStatus?: (parentTaskId: string) => Promise<string | null | undefined>,
+): Promise<boolean> {
+  if (task?.taskType && CONTINUATION_TASK_TYPES.has(task.taskType)) return false;
+  if (task?.parentTaskId && fetchParentTaskStatus) {
+    const parentStatus = await fetchParentTaskStatus(task.parentTaskId);
+    if (parentStatus && ACTIVE_PARENT_STATUSES.has(parentStatus)) return false;
+  }
+  return true;
+}
+
+/** Fetch a task's current status by id. Returns null on any failure (not-found, network, etc). */
+async function fetchTaskStatus(
+  apiUrl: string,
+  apiKey: string,
+  taskId: string,
+): Promise<string | null> {
+  const headers: Record<string, string> = {};
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  try {
+    const response = await fetch(`${apiUrl}/api/tasks/${taskId}`, { headers });
+    if (!response.ok) return null;
+    const data = (await response.json()) as { status?: string };
+    return data.status ?? null;
+  } catch {
+    return null;
+  }
+}
+
 async function refreshExistingRepoForTask(
   repoConfig: { name: string; clonePath: string; defaultBranch: string },
   role: string,
+  isFirstKickoff: boolean,
 ): Promise<string | null> {
   const { name, clonePath, defaultBranch } = repoConfig;
   const statusResult =
@@ -219,13 +321,36 @@ async function refreshExistingRepoForTask(
     }
   }
 
+  const fetchSpec = `${defaultBranch}:refs/remotes/origin/${defaultBranch}`;
+  const remoteRef = `refs/remotes/origin/${defaultBranch}`;
+
   try {
-    console.log(`[${role}] Refreshing ${name} from origin/${defaultBranch}...`);
-    const fetchSpec = `${defaultBranch}:refs/remotes/origin/${defaultBranch}`;
-    const remoteRef = `refs/remotes/origin/${defaultBranch}`;
     await Bun.$`env -u GIT_DIR -u GIT_WORK_TREE -u GIT_INDEX_FILE -u GIT_PREFIX git -C ${clonePath} fetch origin ${fetchSpec}`.quiet();
-    await Bun.$`env -u GIT_DIR -u GIT_WORK_TREE -u GIT_INDEX_FILE -u GIT_PREFIX git -C ${clonePath} merge --no-edit --no-stat ${remoteRef}`.quiet();
-    console.log(`[${role}] Refreshed ${name}`);
+
+    // First-kickoff guarantee (see call sites): the clone is REUSED task-to-task,
+    // so a leftover feature branch from a prior task can still be checked out here.
+    // On a genuine first kickoff (no parentTaskId / not a resume) we force the base
+    // branch back to a clean, current state before the caller creates a work branch
+    // off it — otherwise a diverged leftover branch would abort the merge below and
+    // leave the repo stale (only a warning was emitted). Resumes and follow-up/child
+    // tasks (which may legitimately still have that feature branch checked out with
+    // in-progress work) must NEVER take this path — merge is the safe default there.
+    if (isFirstKickoff) {
+      console.log(`[${role}] First kickoff for ${name} — resetting to ${remoteRef}...`);
+      try {
+        await Bun.$`env -u GIT_DIR -u GIT_WORK_TREE -u GIT_INDEX_FILE -u GIT_PREFIX git -C ${clonePath} checkout ${defaultBranch}`.quiet();
+      } catch {
+        // Local branch may be missing (e.g. deleted by a prior task) — recreate it
+        // tracking the remote instead of failing the whole refresh.
+        await Bun.$`env -u GIT_DIR -u GIT_WORK_TREE -u GIT_INDEX_FILE -u GIT_PREFIX git -C ${clonePath} checkout -B ${defaultBranch} ${remoteRef}`.quiet();
+      }
+      await Bun.$`env -u GIT_DIR -u GIT_WORK_TREE -u GIT_INDEX_FILE -u GIT_PREFIX git -C ${clonePath} reset --hard ${remoteRef}`.quiet();
+      console.log(`[${role}] Reset ${name} to ${remoteRef}`);
+    } else {
+      console.log(`[${role}] Refreshing ${name} from ${remoteRef}...`);
+      await Bun.$`env -u GIT_DIR -u GIT_WORK_TREE -u GIT_INDEX_FILE -u GIT_PREFIX git -C ${clonePath} merge --no-edit --no-stat ${remoteRef}`.quiet();
+      console.log(`[${role}] Refreshed ${name}`);
+    }
     return null;
   } catch (err) {
     const errorMsg = scrubSecrets((err as Error).message);
@@ -278,6 +403,13 @@ export async function ensureRepoForTask(
     hooks?: { enabled: boolean } | null;
   },
   role: string,
+  /**
+   * True only for a genuine first kickoff (a brand-new task, not a resume and
+   * not a follow-up/child task continuing prior work). Defaults to false —
+   * when in doubt, do NOT force-reset the base branch, since the clone is
+   * reused task-to-task and may hold another task's in-progress branch.
+   */
+  isFirstKickoff = false,
 ): Promise<{
   clonePath: string;
   claudeMd: string | null;
@@ -308,7 +440,11 @@ export async function ensureRepoForTask(
       console.log(`[${role}] Cloned ${name}`);
     } else {
       console.log(`[${role}] Repo ${name} already cloned at ${clonePath}`);
-      warning = await refreshExistingRepoForTask({ name, clonePath, defaultBranch }, role);
+      warning = await refreshExistingRepoForTask(
+        { name, clonePath, defaultBranch },
+        role,
+        isFirstKickoff,
+      );
     }
 
     await installRepoHooksForTask(repoConfig, role);
@@ -4794,7 +4930,9 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
             clonePath: `/workspace/personal/repos/${task.vcsRepo.split("/").pop() || task.vcsRepo}`,
             defaultBranch: "main",
           };
-          const repoContext = await ensureRepoForTask(effectiveConfig, role);
+          // This is the paused-task-resume-after-restart path — never a first
+          // kickoff, so never force-reset the base branch here.
+          const repoContext = await ensureRepoForTask(effectiveConfig, role, false);
           if (repoContext?.clonePath) {
             resumeCwd = repoContext.clonePath;
           }
@@ -5187,7 +5325,15 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
             clonePath: `/workspace/personal/repos/${taskVcsRepo.split("/").pop() || taskVcsRepo}`,
             defaultBranch: "main",
           };
-          const repoResult = await ensureRepoForTask(effectiveConfig, role);
+          // First kickoff = a genuinely new root task: not a continuation
+          // task-type, and not parent-linked to a still-active task (Slack
+          // follow-ups / sibling-awareness wire parentTaskId with no
+          // reserved taskType). See isFirstKickoffTask() for the full
+          // reasoning and CONTINUATION_TASK_TYPES for the denylist.
+          const isFirstKickoff = await isFirstKickoffTask(taskObj, (parentTaskId) =>
+            fetchTaskStatus(apiUrl, apiKey, parentTaskId),
+          );
+          const repoResult = await ensureRepoForTask(effectiveConfig, role, isFirstKickoff);
           currentRepoContext = {
             ...repoResult,
             guidelines: repoConfig?.guidelines ?? null,