@desplega.ai/agent-swarm 1.158.0 → 1.159.0

package/src/be/db/tasks/write.ts

@@ -15,7 +15,17 @@ import { scrubSecrets } from "../../../utils/secret-scrubber";
 import { emitTaskStarted } from "../../task-lifecycle-events";
 import { getAgentById, isAgentEligibleForTask } from "../agents";
 import { getDbClient } from "../runtime";
-import { type AgentTaskRow, getTaskById, rowToAgentTask } from "./read";
+import {
+  classifyTaskHumanFree,
+  reclassifyTaskHumanFree,
+  tagWriteChangesHumanFree,
+} from "./human-free";
+import {
+  type AgentTaskRow,
+  getTaskById,
+  NEVER_STARTED_TASK_STATUSES,
+  rowToAgentTask,
+} from "./read";
 
 type TaskWriteDependencies = {
   createLogEntry: (entry: {
@@ -68,9 +78,10 @@ export async function createTask(
 ): Promise<AgentTask> {
   const id = crypto.randomUUID();
   const source = options?.source ?? "mcp";
+  const isHumanFree = await classifyTaskHumanFree({ source });
   const row = await getDbClient().get<AgentTaskRow>(
-    `INSERT INTO agent_tasks (id, "key", agentId, task, status, source, slackChannelId, slackThreadTs, slackUserId, swarmVersion, createdAt, lastUpdatedAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) RETURNING *`,
+    `INSERT INTO agent_tasks (id, "key", agentId, task, status, source, slackChannelId, slackThreadTs, slackUserId, swarmVersion, isHumanFree, createdAt, lastUpdatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) RETURNING *`,
     [
       id,
       defaultAssetKey("task", id),
@@ -82,6 +93,7 @@ export async function createTask(
       options?.slackThreadTs ?? null,
       options?.slackUserId ?? null,
       pkg.version,
+      isHumanFree ? 1 : 0,
     ],
   );
   if (!row) throw new Error("Failed to create task");
@@ -359,10 +371,17 @@ export async function completeTask(
     if (completed && options?.addTags?.length) {
       const existingTags: string[] = completed.tags ? JSON.parse(completed.tags) : [];
       const nextTags = Array.from(new Set([...existingTags, ...options.addTags]));
+      const previousTagsJson = completed.tags;
+      const nextTagsJson = JSON.stringify(nextTags);
       completed = await getDbClient().get<AgentTaskRow>(
         "UPDATE agent_tasks SET tags = ?, lastUpdatedAt = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ? RETURNING *",
-        [JSON.stringify(nextTags), id],
+        [nextTagsJson, id],
       );
+      // Only a tag the classifier reads (e.g. "heartbeat") can flip the flag;
+      // a "deferred" write must not walk the task's whole subtree.
+      if (tagWriteChangesHumanFree(previousTagsJson, nextTagsJson)) {
+        await reclassifyTaskHumanFree([id]);
+      }
     }
     if (completed && options?.deferredAt) {
       completed = await getDbClient().get<AgentTaskRow>(
@@ -752,20 +771,88 @@ export async function supersedeTask(
         );
     });
 
-    try {
-      await dependencies.cascadeFailDependents(id, "superseded");
-    } catch (err) {
-      console.error("[supersedeTask] cascade-fail dependents error:", err);
-    }
+    // Without a resume id the dependents wait: every caller supersedes first,
+    // creates the resume, then calls `backfillSupersedeTaskResumeTaskId`, which
+    // settles them. Cascading here would fail work the resume is about to carry.
+    // A caller whose resume is not created settles with `null`; heartbeat
+    // repair settles whatever a crash left in between.
+    if (args.resumeTaskId) await settleSupersededTaskDependents(id, args.resumeTaskId);
   }
 
   return row ? rowToAgentTask(row) : null;
 }
 
+/**
+ * Settle the dependents of a superseded task. With a resume id, every
+ * never-started dependent has the superseded id in `dependsOn` replaced by the
+ * resume id, so it waits on the resume instead of dying with
+ * `Blocked dependency … was superseded`. Anything still depending on the
+ * superseded task afterwards (a dependent that already started, or every
+ * dependent when there is no resume) cascade-fails. Idempotent.
+ */
+export async function settleSupersededTaskDependents(
+  supersededId: string,
+  resumeTaskId: string | null,
+): Promise<void> {
+  try {
+    if (resumeTaskId) {
+      const placeholders = NEVER_STARTED_TASK_STATUSES.map(() => "?").join(", ");
+      // One statement: the new array is built from the row's current
+      // `dependsOn`, so settlements of a shared dependent compose, and the
+      // status predicate is evaluated at write time, so a claim into
+      // `in_progress` is skipped while offered -> reviewing/pending is not.
+      const repointed = await getDbClient().query<{ id: string; agentId: string | null }>(
+        `UPDATE agent_tasks
+            SET dependsOn = (
+                  SELECT json_group_array(value ORDER BY k) FROM (
+                    SELECT CASE WHEN j.value = ? THEN ? ELSE j.value END AS value,
+                           MIN(j.key) AS k
+                      FROM json_each(agent_tasks.dependsOn) AS j
+                     GROUP BY 1)),
+                lastUpdatedAt = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+          WHERE status IN (${placeholders})
+            AND EXISTS (SELECT 1 FROM json_each(agent_tasks.dependsOn) WHERE value = ?)
+          RETURNING id, agentId`,
+        [supersededId, resumeTaskId, ...NEVER_STARTED_TASK_STATUSES, supersededId],
+      );
+      for (const dep of repointed) {
+        try {
+          await dependencies.createLogEntry({
+            eventType: "task_dependency_repointed",
+            taskId: dep.id,
+            agentId: dep.agentId ?? undefined,
+            oldValue: supersededId,
+            newValue: resumeTaskId,
+            metadata: { reason: "supersede_resume" },
+          });
+        } catch {}
+      }
+      // Repair can settle onto a resume that already failed; its own cascade
+      // ran before these dependents pointed at it.
+      const resume = await getTaskById(resumeTaskId);
+      if (repointed.length > 0 && (resume?.status === "failed" || resume?.status === "cancelled")) {
+        await dependencies.cascadeFailDependents(resumeTaskId, resume.status);
+      }
+    }
+    await dependencies.cascadeFailDependents(supersededId, "superseded");
+  } catch (err) {
+    console.error("[supersedeTask] settling dependents error:", err);
+  }
+}
+
+/**
+ * Attach the resume id to the task's `task_superseded` log entry, then settle
+ * the dependents `supersedeTask` left waiting (re-point to the resume, cascade
+ * the rest).
+ */
 export async function backfillSupersedeTaskResumeTaskId(
   taskId: string,
   resumeTaskId: string,
 ): Promise<boolean> {
+  if ((await getTaskById(taskId))?.status === "superseded") {
+    await settleSupersededTaskDependents(taskId, resumeTaskId);
+  }
+
   const row = await getDbClient().get<{ id: string; metadata: string | null }>(
     `SELECT id, metadata
        FROM agent_log
@@ -960,8 +1047,17 @@ export async function getRecentlyCancelledTasksForAgent(agentId: string): Promis
 }
 
 export async function deleteTask(id: string): Promise<boolean> {
-  const result = await getDbClient().run("DELETE FROM agent_tasks WHERE id = ?", [id]);
-  return result.changes > 0;
+  return await getDbClient().transaction(async (tx) => {
+    // `parentTaskId` has no foreign key, so children survive with a dangling
+    // parent. The human-free rule reads the parent row, so they are reclassified
+    // once it is gone.
+    const childIds = (
+      await tx.query<{ id: string }>("SELECT id FROM agent_tasks WHERE parentTaskId = ?", [id])
+    ).map((row) => row.id);
+    const result = await tx.run("DELETE FROM agent_tasks WHERE id = ?", [id]);
+    await reclassifyTaskHumanFree(childIds);
+    return result.changes > 0;
+  });
 }
 
 export async function updateTaskProgress(id: string, progress: string): Promise<AgentTask | null> {

package/src/be/db.ts

@@ -161,6 +161,7 @@ import {
   getLatestContextVersion,
 } from "./db/context-versions";
 import { getDb, getDbClient } from "./db/runtime";
+import { classifyTaskHumanFree, reclassifyTaskHumanFree } from "./db/tasks/human-free";
 import {
   type AgentTaskRow,
   configureTaskReadDependencies,
@@ -187,6 +188,7 @@ export {
   getAgentById,
   getAgentDailyTaskCounts,
   getAgentHarnessProviders,
+  getAgentStatusCounts,
   getAllAgents,
   getLeadAgent,
   getRemainingCapacity,
@@ -260,6 +262,7 @@ export {
   getRecentlyFinishedWorkerTasks,
   getSlackTasksMissingTree,
   getSupersededTasksWithoutResume,
+  getSupersededTasksWithUnsettledDependents,
   getTaskById,
   getTaskStats,
   getTasksByAgentId,
@@ -291,6 +294,7 @@ export {
   pauseTask,
   resetOrphanedInProgressTasksForAgent,
   resumeTask,
+  settleSupersededTaskDependents,
   startTask,
   supersedeTask,
   updateTaskClaudeSessionId,
@@ -2703,6 +2707,16 @@ export async function createTaskExtended(
       logRoutingDecisionFailure(id, "capture", error);
     }
 
+    const isHumanFree = await classifyTaskHumanFree({
+      taskType: options?.taskType,
+      tags: JSON.stringify(options?.tags ?? []),
+      source: options?.source ?? "mcp",
+      requestedByUserId: options?.requestedByUserId,
+      requestedByUserIdInherited,
+      parentTaskId: options?.parentTaskId,
+      workflowRunId: options?.workflowRunId,
+    });
+
     const inserted = await getDbClient().get<AgentTaskRow>(
       `INSERT INTO agent_tasks (
         id, "key", agentId, creatorAgentId, task, status, source, routing_reason, routing_source, routing_note,
@@ -2712,8 +2726,8 @@ export async function createTaskExtended(
         vcsInstallationId, vcsNodeId,
         agentmailInboxId, agentmailMessageId, agentmailThreadId,
         mentionMessageId, mentionChannelId, dir, parentTaskId, model, modelTier, effort, scheduleId,
-        workflowRunId, workflowRunStepId, outputSchema, followUpConfig, requestedByUserId, requestedByUserIdInherited, contextKey, routingAffinity, swarmVersion, createdAt, lastUpdatedAt, created_by, updated_by
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
+        workflowRunId, workflowRunStepId, outputSchema, followUpConfig, requestedByUserId, requestedByUserIdInherited, contextKey, routingAffinity, swarmVersion, createdAt, lastUpdatedAt, created_by, updated_by, isHumanFree
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
       [
         id,
         assetKey,
@@ -2768,6 +2782,7 @@ export async function createTaskExtended(
         now,
         auditUserId,
         auditUserId,
+        isHumanFree ? 1 : 0,
       ],
     );
     if (!inserted) throw new Error("Failed to create task");
@@ -4893,60 +4908,12 @@ export interface SessionCostByUserRow {
 /** `opts.userId` sentinel selecting spend with no human requester. */
 export const UNATTRIBUTED_USER_ID = "unattributed";
 
-// Structurally-human-free tasks and their descendants. An explicitly supplied
-// requester is a human handoff and stops propagation; a requester copied from
-// the parent does not.
-const HUMAN_FREE_TASKS_CTE = `human_free_tasks(id) AS (
-        SELECT task.id
-        FROM agent_tasks task
-        LEFT JOIN agent_tasks parent ON parent.id = task.parentTaskId
-        WHERE COALESCE(task.taskType, '') IN ('heartbeat', 'heartbeat-checklist', 'boot-triage')
-          OR COALESCE(task.tags, '[]') LIKE '%"heartbeat"%'
-          OR (COALESCE(task.source, '') = 'schedule' AND task.requestedByUserId IS NULL)
-          OR (
-            task.parentTaskId IS NULL
-            AND COALESCE(task.source, '') = 'workflow'
-            AND task.requestedByUserId IS NULL
-            AND EXISTS (
-              SELECT 1
-              FROM workflow_runs run
-              WHERE run.id = task.workflowRunId
-                AND run.triggerType = 'schedule'
-                AND run.created_by IS NULL
-            )
-          )
-          OR (
-            COALESCE(task.source, '') = 'system'
-            AND parent.id IS NOT NULL
-            AND parent.requestedByUserId IS NULL
-          )
-
-        UNION
-
-        SELECT child.id
-        FROM agent_tasks child
-        JOIN human_free_tasks parent ON child.parentTaskId = parent.id
-        WHERE child.requestedByUserId IS NULL
-          OR child.requestedByUserIdInherited = 1
-      )`;
-/** True on rows joined through `human_free_tasks hf` (see `getSessionCostSummary`). */
-const HUMAN_FREE_SQL = "hf.id IS NOT NULL";
-const ROOT_HUMAN_FREE_SQL = `(
-        COALESCE(t.taskType, '') IN ('heartbeat', 'heartbeat-checklist', 'boot-triage')
-        OR COALESCE(t.tags, '[]') LIKE '%"heartbeat"%'
-        OR (COALESCE(t.source, '') = 'schedule' AND t.requestedByUserId IS NULL)
-        OR (
-          COALESCE(t.source, '') = 'workflow'
-          AND t.requestedByUserId IS NULL
-          AND EXISTS (
-            SELECT 1
-            FROM workflow_runs run
-            WHERE run.id = t.workflowRunId
-              AND run.triggerType = 'schedule'
-              AND run.created_by IS NULL
-          )
-        )
-      )`;
+/**
+ * True for a session whose task is structurally human-free (`isHumanFree`, set
+ * when the task is created; rule in `src/be/db/tasks/human-free.ts`). A session
+ * with no task row is not human-free.
+ */
+const HUMAN_FREE_SQL = "(COALESCE(t.isHumanFree, 0) = 1)";
 
 export async function getSessionCostSummary(opts: {
   startDate?: string;
@@ -4966,19 +4933,15 @@ export async function getSessionCostSummary(opts: {
   // re-attributed after the fact, so the human requester is resolved by joining
   // through the task (same shape as `getDailySpendForUser`). Every column is
   // `sc.`-qualified because `createdAt`/`agentId` exist on both sides.
-  const from = "FROM session_costs sc LEFT JOIN agent_tasks t ON t.id = sc.taskId";
-  // One join marks the sessions of structurally-human-free tasks (`hf.id` set).
-  // The CTE holds each task id once, so the join never duplicates a session.
-  const fromHf = `${from} LEFT JOIN human_free_tasks hf ON hf.id = t.id`;
-
-  // Structurally-human-free: the swarm maintaining itself, with no human
-  // requester by construction — heartbeat/boot-triage tasks, scheduled runs
-  // without a human creator (including workflow roots launched by such a
-  // schedule), and `source='system'` follow-ups whose parent itself has no
-  // human requester. That classification propagates through descendants while
-  // they remain unattributed, so autonomous fan-out cannot leak back into the
-  // denominator. An explicitly attributed child is an independent handoff and
-  // stops propagation down that branch.
+  // INDEXED BY: without ANALYZE statistics (production has none) the planner
+  // probes tasks through the primary key and reads each full row, which follows
+  // the task's overflow pages. The covering index answers the same probe from
+  // the index alone (migration 182).
+  const from =
+    "FROM session_costs sc LEFT JOIN agent_tasks t INDEXED BY idx_agent_tasks_usage_cover ON t.id = sc.taskId";
+  // Only a user filter reads the task, and the join adds no rows (task id is unique).
+  const agentFrom = opts.userId === undefined ? "FROM session_costs sc" : from;
+
   const conditions: string[] = [];
   const params: string[] = [];
 
@@ -5002,11 +4965,6 @@ export async function getSessionCostSummary(opts: {
   }
 
   const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  // Only a user filter makes the daily and per-agent breakdowns classify rows.
-  // Without one they skip the CTE, which scans every task.
-  const classify = opts.userId !== undefined;
-  const withHf = classify ? `WITH RECURSIVE ${HUMAN_FREE_TASKS_CTE}` : "";
-  const scopedFrom = classify ? fromHf : from;
   const subscriptionSql = `t.credentialKeyType IN (${SUBSCRIPTION_KEY_TYPES.map((k) => `'${k}'`).join(", ")})`;
 
   // Totals
@@ -5026,8 +4984,7 @@ export async function getSessionCostSummary(opts: {
   };
 
   const totalsRow = await getDbClient().get<TotalsRow>(
-    `WITH RECURSIVE ${HUMAN_FREE_TASKS_CTE}
-      SELECT
+    `SELECT
         COALESCE(SUM(sc.totalCostUsd), 0) as totalCostUsd,
         COALESCE(SUM(sc.inputTokens), 0) as totalInputTokens,
         COALESCE(SUM(sc.outputTokens), 0) as totalOutputTokens,
@@ -5044,7 +5001,7 @@ export async function getSessionCostSummary(opts: {
         COUNT(DISTINCT CASE WHEN ${HUMAN_FREE_SQL} THEN t.id END) as excludedTaskCount,
         COALESCE(SUM(CASE WHEN ${subscriptionSql}
           THEN sc.totalCostUsd ELSE 0 END), 0) as subscriptionCostUsd
-      ${fromHf} ${where}`,
+      ${from} ${where}`,
     params,
   );
 
@@ -5082,8 +5039,7 @@ export async function getSessionCostSummary(opts: {
       sessions: number;
       subscriptionCostUsd: number;
     }>(
-      `${withHf}
-        SELECT
+      `SELECT
           DATE(sc.createdAt) as date,
           COALESCE(SUM(sc.totalCostUsd), 0) as costUsd,
           COALESCE(SUM(sc.inputTokens), 0) as inputTokens,
@@ -5091,7 +5047,7 @@ export async function getSessionCostSummary(opts: {
           COUNT(*) as sessions,
           COALESCE(SUM(CASE WHEN ${subscriptionSql} THEN sc.totalCostUsd ELSE 0 END), 0)
             as subscriptionCostUsd
-        ${scopedFrom} ${where}
+        ${from} ${where}
         GROUP BY DATE(sc.createdAt)
         ORDER BY date ASC`,
       params,
@@ -5109,15 +5065,14 @@ export async function getSessionCostSummary(opts: {
       sessions: number;
       durationMs: number;
     }>(
-      `${withHf}
-        SELECT
+      `SELECT
           sc.agentId as agentId,
           COALESCE(SUM(sc.totalCostUsd), 0) as costUsd,
           COALESCE(SUM(sc.inputTokens), 0) as inputTokens,
           COALESCE(SUM(sc.outputTokens), 0) as outputTokens,
           COUNT(*) as sessions,
           COALESCE(SUM(sc.durationMs), 0) as durationMs
-        ${scopedFrom} ${where}
+        ${agentFrom} ${where}
         GROUP BY sc.agentId
         ORDER BY costUsd DESC`,
       params,
@@ -5129,15 +5084,14 @@ export async function getSessionCostSummary(opts: {
   let byUser: SessionCostByUserRow[] = [];
   if (groupBy === "user" || groupBy === "both") {
     byUser = await getDbClient().query<SessionCostByUserRow>(
-      `WITH RECURSIVE ${HUMAN_FREE_TASKS_CTE}
-        SELECT
+      `SELECT
           CASE WHEN ${HUMAN_FREE_SQL} THEN NULL ELSE t.requestedByUserId END as userId,
           COALESCE(SUM(sc.totalCostUsd), 0) as costUsd,
           COALESCE(SUM(sc.inputTokens), 0) as inputTokens,
           COALESCE(SUM(sc.outputTokens), 0) as outputTokens,
           COUNT(DISTINCT sc.taskId) as tasks,
           COALESCE(SUM(sc.durationMs), 0) as durationMs
-        ${fromHf} ${where}
+        ${from} ${where}
         GROUP BY CASE WHEN ${HUMAN_FREE_SQL} THEN NULL ELSE t.requestedByUserId END
         ORDER BY costUsd DESC`,
       params,
@@ -5151,8 +5105,7 @@ export async function getSessionCostSummary(opts: {
       "name" | "subscription" | "plan" | "planSource"
     >;
     const rows = await getDbClient().query<CredentialRow>(
-      `${withHf}
-        SELECT
+      `SELECT
           t.credentialKeyType as keyType,
           t.credentialKeySuffix as keySuffix,
           COALESCE(SUM(sc.totalCostUsd), 0) as costUsd,
@@ -5161,7 +5114,7 @@ export async function getSessionCostSummary(opts: {
           COUNT(*) as sessions,
           MIN(sc.createdAt) as firstSessionAt,
           MAX(sc.createdAt) as lastSessionAt
-        ${scopedFrom} ${where}
+        ${from} ${where}
         GROUP BY t.credentialKeyType, t.credentialKeySuffix
         ORDER BY costUsd DESC`,
       params,
@@ -5223,18 +5176,6 @@ async function getCredentialLabels(): Promise<
   return labels;
 }
 
-/**
- * Changes when a session cost or a task is inserted. Part of the usage report
- * cache key (`src/http/usage-cache.ts`). Reads two rowid maxima, so it is cheap.
- */
-export async function getUsageDataVersion(): Promise<string> {
-  const row = await getDbClient().get<{ version: string }>(
-    `SELECT COALESCE((SELECT MAX(rowid) FROM session_costs), 0) || ':' ||
-            COALESCE((SELECT MAX(rowid) FROM agent_tasks), 0) as version`,
-  );
-  return row?.version ?? "0:0";
-}
-
 // --- Per-person attribution (four-metric view) ---
 
 export interface AttributionByPersonRow {
@@ -5265,7 +5206,7 @@ export interface AttributionByPersonRow {
  * a composite score. Scope is root tasks (`problemsInitiated`/`problemsShipped`)
  * or the person's entire task tree (`*Reached`); `requestedByUserId IS NULL`
  * (autonomous work) and structurally-human-free rows with a stale/inherited
- * requester (see `HUMAN_FREE_SQL` in `getSessionCostSummary`) are excluded —
+ * requester (`agent_tasks.isHumanFree`, see `src/be/db/tasks/human-free.ts`) are excluded —
  * neither belongs to a person.
  *
  * "Problems shipped" detection walks each root's full task tree, preferring a
@@ -5309,18 +5250,20 @@ export async function getAttributionByPerson(opts: {
 
   type RootRow = { userId: string; initiated: number; shipped: number };
   const rootRows = await getDbClient().query<RootRow>(
-    `WITH RECURSIVE selected_roots(id, requestedByUserId, status, output) AS (
-        SELECT t.id, t.requestedByUserId, t.status, t.output
+    `WITH RECURSIVE selected_roots(id, requestedByUserId, status) AS (
+        SELECT t.id, t.requestedByUserId, t.status
         FROM agent_tasks t
-        ${where} AND t.parentTaskId IS NULL AND NOT ${ROOT_HUMAN_FREE_SQL}
+        ${where} AND t.parentTaskId IS NULL AND t.isHumanFree = 0
       ),
-      task_tree(rootId, taskId, output) AS (
-        SELECT id, id, output
+      -- Ids only: carrying each descendant's \`output\` through the recursion copied
+      -- every task's text into the queue. The output fallback below reads it by id.
+      task_tree(rootId, taskId) AS (
+        SELECT id, id
         FROM selected_roots
 
         UNION ALL
 
-        SELECT tree.rootId, child.id, child.output
+        SELECT tree.rootId, child.id
         FROM agent_tasks child
         JOIN task_tree tree ON child.parentTaskId = tree.taskId
       ),
@@ -5353,8 +5296,11 @@ export async function getAttributionByPerson(opts: {
 
         SELECT tree.rootId
         FROM task_tree tree
-        WHERE tree.output LIKE '%github.com/%/pull/%'
-           OR tree.output LIKE '%/-/merge_requests/%'
+        -- CROSS JOIN pins the order (tree outer, task by id). Left to itself the
+        -- planner scans every task's output and probes the tree instead.
+        CROSS JOIN agent_tasks described ON described.id = tree.taskId
+        WHERE described.output LIKE '%github.com/%/pull/%'
+           OR described.output LIKE '%/-/merge_requests/%'
       )
       SELECT
         t.requestedByUserId as userId,
@@ -5373,65 +5319,13 @@ export async function getAttributionByPerson(opts: {
     surfacesReached: number;
   };
   const reachRows = await getDbClient().query<ReachRow>(
-    `WITH RECURSIVE report_tasks AS (
-        -- Only the columns read below: a task row carries its full prompt and output.
-        SELECT t.id, t.agentId, t.vcsRepo, t.source, t.parentTaskId, t.requestedByUserId,
-          t.requestedByUserIdInherited, t.taskType, t.tags, t.workflowRunId
-        FROM agent_tasks t
-        ${where}
-      ),
-      task_ancestry(
-        taskId, id, parentTaskId, requestedByUserId, requestedByUserIdInherited,
-        taskType, tags, source, workflowRunId
-      ) AS (
-        SELECT
-          id, id, parentTaskId, requestedByUserId, requestedByUserIdInherited,
-          taskType, tags, source, workflowRunId
-        FROM report_tasks
-
-        UNION ALL
-
-        SELECT
-          child.taskId, parent.id, parent.parentTaskId, parent.requestedByUserId,
-          parent.requestedByUserIdInherited, parent.taskType, parent.tags,
-          parent.source, parent.workflowRunId
-        FROM agent_tasks parent
-        JOIN task_ancestry child ON parent.id = child.parentTaskId
-        WHERE child.requestedByUserId IS NULL
-          OR child.requestedByUserIdInherited = 1
-      ),
-      human_free_report_tasks(id) AS (
-        SELECT DISTINCT ancestor.taskId
-        FROM task_ancestry ancestor
-        LEFT JOIN agent_tasks parent ON parent.id = ancestor.parentTaskId
-        WHERE COALESCE(ancestor.taskType, '') IN ('heartbeat', 'heartbeat-checklist', 'boot-triage')
-          OR COALESCE(ancestor.tags, '[]') LIKE '%"heartbeat"%'
-          OR (COALESCE(ancestor.source, '') = 'schedule' AND ancestor.requestedByUserId IS NULL)
-          OR (
-            ancestor.parentTaskId IS NULL
-            AND COALESCE(ancestor.source, '') = 'workflow'
-            AND ancestor.requestedByUserId IS NULL
-            AND EXISTS (
-              SELECT 1
-              FROM workflow_runs run
-              WHERE run.id = ancestor.workflowRunId
-                AND run.triggerType = 'schedule'
-                AND run.created_by IS NULL
-            )
-          )
-          OR (
-            COALESCE(ancestor.source, '') = 'system'
-            AND parent.id IS NOT NULL
-            AND parent.requestedByUserId IS NULL
-          )
-      )
-      SELECT
+    `SELECT
         t.requestedByUserId as userId,
         COUNT(DISTINCT t.agentId) as agentsReached,
         COUNT(DISTINCT t.vcsRepo) as reposReached,
         COUNT(DISTINCT t.source) as surfacesReached
-      FROM report_tasks t
-      WHERE NOT EXISTS (SELECT 1 FROM human_free_report_tasks WHERE id = t.id)
+      FROM agent_tasks t
+      ${where} AND t.isHumanFree = 0
       GROUP BY t.requestedByUserId`,
     params,
   );
@@ -7596,7 +7490,19 @@ export async function updateWorkflow(
 }
 
 export async function deleteWorkflow(id: string, source?: "api" | "mcp"): Promise<boolean> {
+  // One transaction: the stored human-free flags must never lag the deleted runs
+  // (a scheduled workflow root is human-free only while its run row exists).
+  return await getDbClient().transaction(() => deleteWorkflowRows(id, source));
+}
+
+async function deleteWorkflowRows(id: string, source?: "api" | "mcp"): Promise<boolean> {
   const client = getDbClient();
+  const linkedTaskIds = (
+    await client.query<{ id: string }>(
+      `SELECT id FROM agent_tasks WHERE workflowRunId IN (SELECT id FROM workflow_runs WHERE workflowId = ?)`,
+      [id],
+    )
+  ).map((row) => row.id);
   // Cascade delete in FK-safe order:
   // 1. Unlink agent_tasks (they reference steps and runs)
   await client.run(
@@ -7610,6 +7516,7 @@ export async function deleteWorkflow(id: string, source?: "api" | "mcp"): Promis
   );
   // 3. Delete runs (they reference workflow)
   await client.run("DELETE FROM workflow_runs WHERE workflowId = ?", [id]);
+  await reclassifyTaskHumanFree(linkedTaskIds);
   // 4. Delete workflow
   const result = await client.run("DELETE FROM workflows WHERE id = ?", [id]);
   const deleted = result.changes > 0;
@@ -12112,6 +12019,21 @@ export async function deleteUser(id: string, replacementUserId?: string): Promis
          )`,
     );
     const replacement = replacementUserId ?? null;
+    // The human-free rule only asks whether a task's requester or its workflow
+    // run's creator is NULL, so only clearing them (no replacement) can change a
+    // stored flag. Gather the tasks now: after the rewrite nothing identifies
+    // them. The workflow branch covers roots whose requester was never set.
+    const reclassifySeedIds: string[] = replacementUserId
+      ? []
+      : (
+          await tx.query<{ id: string }>(
+            `SELECT id FROM agent_tasks WHERE requestedByUserId = ?
+             UNION
+             SELECT id FROM agent_tasks
+             WHERE workflowRunId IN (SELECT id FROM workflow_runs WHERE created_by = ?)`,
+            [id, id],
+          )
+        ).map((row) => row.id);
     for (const reference of references) {
       const table = quoteSqlIdentifier(reference.tableName);
       const column = quoteSqlIdentifier(reference.columnName);
@@ -12139,6 +12061,8 @@ export async function deleteUser(id: string, replacementUserId?: string): Promis
       );
     }
 
+    await reclassifyTaskHumanFree(reclassifySeedIds);
+
     const result = await tx.run("DELETE FROM users WHERE id = ?", [id]);
     return result.changes > 0;
   });