@treeseed/core 0.4.10 → 0.4.12

package/dist/services/manager.js

@@ -0,0 +1,1129 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import {
+  createControlPlaneReporter
+} from "@treeseed/sdk";
+import { createQueuePushClient, createServiceSdk, queueEnvelopeForTask, resolveManagerConfig } from "./common.js";
+import { writeWorkdayContentSnapshot } from "./workday-content.js";
+import { createWorkerPoolScaler } from "./worker-pool-scaler.js";
+const DEFAULT_WORK_DAYS = [1, 2, 3, 4, 5];
+const DEFAULT_PRIORITY_MODELS = ["objective", "question", "note", "page", "book", "knowledge"];
+function integerFromEnv(name, fallback) {
+  const value = process.env[name];
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function envValue(name) {
+  const value = process.env[name]?.trim();
+  return value ? value : "";
+}
+function booleanFromEnv(name, fallback = false) {
+  const value = envValue(name).toLowerCase();
+  if (!value) {
+    return fallback;
+  }
+  return ["1", "true", "yes", "on"].includes(value);
+}
+function parseDays(value) {
+  const days = value.split(",").map((entry) => Number.parseInt(entry.trim(), 10)).filter((entry) => Number.isInteger(entry) && entry >= 0 && entry <= 6);
+  return days.length > 0 ? [...new Set(days)] : [...DEFAULT_WORK_DAYS];
+}
+function parseWindowsFromEnv() {
+  const jsonValue = envValue("TREESEED_WORKDAY_WINDOWS_JSON");
+  if (jsonValue) {
+    try {
+      const parsed = JSON.parse(jsonValue);
+      if (Array.isArray(parsed) && parsed.length > 0) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return [{
+    days: parseDays(envValue("TREESEED_WORKDAY_DAYS") || DEFAULT_WORK_DAYS.join(",")),
+    startTime: envValue("TREESEED_WORKDAY_START_TIME") || "09:00",
+    endTime: envValue("TREESEED_WORKDAY_END_TIME") || "17:00"
+  }];
+}
+function resolveScheduleFromEnv() {
+  return {
+    timezone: envValue("TREESEED_WORKDAY_TIMEZONE") || process.env.TZ || "UTC",
+    windows: parseWindowsFromEnv()
+  };
+}
+function parsePriorityModels() {
+  const raw = envValue("TREESEED_MANAGER_PRIORITY_MODELS");
+  if (!raw) {
+    return [...DEFAULT_PRIORITY_MODELS];
+  }
+  return raw.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function parseMinutes(value) {
+  const [hours, minutes] = value.split(":", 2).map((entry) => Number.parseInt(entry, 10));
+  if (!Number.isInteger(hours) || !Number.isInteger(minutes)) {
+    return 0;
+  }
+  return hours * 60 + minutes;
+}
+function zonedNowParts(date, timezone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    weekday: "short",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  }).formatToParts(date);
+  const weekdayMap = {
+    Sun: 0,
+    Mon: 1,
+    Tue: 2,
+    Wed: 3,
+    Thu: 4,
+    Fri: 5,
+    Sat: 6
+  };
+  const weekday = weekdayMap[parts.find((part) => part.type === "weekday")?.value ?? "Sun"] ?? 0;
+  const hour = Number.parseInt(parts.find((part) => part.type === "hour")?.value ?? "0", 10);
+  const minute = Number.parseInt(parts.find((part) => part.type === "minute")?.value ?? "0", 10);
+  return {
+    weekday,
+    minutes: hour * 60 + minute
+  };
+}
+function isWithinWorkWindow(date, schedule) {
+  const now = zonedNowParts(date, schedule.timezone);
+  for (const window of schedule.windows) {
+    const startMinutes = parseMinutes(window.startTime);
+    const endMinutes = parseMinutes(window.endTime);
+    const todayIncluded = window.days.includes(now.weekday);
+    if (startMinutes <= endMinutes) {
+      if (todayIncluded && now.minutes >= startMinutes && now.minutes <= endMinutes) {
+        return true;
+      }
+      continue;
+    }
+    const previousDay = (now.weekday + 6) % 7;
+    if (todayIncluded && now.minutes >= startMinutes) {
+      return true;
+    }
+    if (window.days.includes(previousDay) && now.minutes <= endMinutes) {
+      return true;
+    }
+  }
+  return false;
+}
+function parseJson(value, fallback) {
+  if (typeof value !== "string" || !value.trim()) {
+    return fallback;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function asRecords(value) {
+  return Array.isArray(value) ? value : [];
+}
+function readString(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return "";
+}
+function readArray(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (Array.isArray(value)) {
+      return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+    }
+  }
+  return [];
+}
+function readNumber(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number.parseFloat(value);
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+  }
+  return null;
+}
+function readDate(record, ...keys) {
+  const raw = readString(record, ...keys);
+  if (!raw) {
+    return null;
+  }
+  const parsed = new Date(raw);
+  return Number.isFinite(parsed.valueOf()) ? parsed : null;
+}
+function parseJsonString(value, fallback = {}) {
+  if (typeof value !== "string" || !value.trim()) {
+    return fallback;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function normalizeChangedFilesFromValue(value, changedFiles = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      if (typeof entry === "string" && entry.trim()) {
+        changedFiles.add(entry.trim());
+      } else if (entry && typeof entry === "object") {
+        normalizeChangedFilesFromValue(entry, changedFiles);
+      }
+    }
+    return changedFiles;
+  }
+  if (!value || typeof value !== "object") {
+    return changedFiles;
+  }
+  for (const [key, nested] of Object.entries(value)) {
+    if (["changedFiles", "changed_files", "files", "paths"].includes(key)) {
+      normalizeChangedFilesFromValue(nested, changedFiles);
+      continue;
+    }
+    if (nested && typeof nested === "object") {
+      normalizeChangedFilesFromValue(nested, changedFiles);
+    }
+  }
+  return changedFiles;
+}
+function isoDateOrNull(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = new Date(value);
+  return Number.isFinite(parsed.valueOf()) ? parsed.toISOString() : null;
+}
+function filterDeploymentsForWorkday(deployments, workDay, generatedAt) {
+  const startedAt = readDate(workDay, "startedAt", "started_at");
+  const endedAt = readDate(workDay, "endedAt", "ended_at") ?? new Date(generatedAt);
+  if (!startedAt || !endedAt) {
+    return deployments;
+  }
+  return deployments.filter((deployment) => {
+    const relevant = readDate(deployment, "finishedAt", "finished_at") ?? readDate(deployment, "startedAt", "started_at") ?? readDate(deployment, "createdAt", "created_at");
+    if (!relevant) {
+      return false;
+    }
+    return relevant.valueOf() >= startedAt.valueOf() && relevant.valueOf() <= endedAt.valueOf();
+  });
+}
+async function fetchRunnerDeployments(config) {
+  if (!config.marketBaseUrl || !config.runnerToken) {
+    return [];
+  }
+  const url = new URL(`/v1/projects/${encodeURIComponent(config.projectId)}/runner/deployments`, config.marketBaseUrl);
+  url.searchParams.set("environment", config.environment);
+  const response = await fetch(url, {
+    headers: {
+      accept: "application/json",
+      authorization: `Bearer ${config.runnerToken}`
+    }
+  });
+  if (!response.ok) {
+    return [];
+  }
+  const payload = await response.json().catch(() => ({}));
+  return asRecords(payload.payload);
+}
+function defaultCreditsForModel(model) {
+  switch (model) {
+    case "objective":
+      return 5;
+    case "question":
+      return 4;
+    case "note":
+    case "page":
+      return 3;
+    case "book":
+    case "knowledge":
+      return 2;
+    default:
+      return 1;
+  }
+}
+function statusWeight(status) {
+  switch (status.toLowerCase()) {
+    case "urgent":
+      return 50;
+    case "blocked":
+      return 45;
+    case "active":
+    case "in_progress":
+    case "open":
+      return 35;
+    case "ready":
+      return 30;
+    case "draft":
+      return 20;
+    case "live":
+      return 15;
+    case "done":
+    case "completed":
+      return -25;
+    case "archived":
+      return -40;
+    default:
+      return 0;
+  }
+}
+function modelWeight(model) {
+  switch (model) {
+    case "objective":
+      return 45;
+    case "question":
+      return 40;
+    case "note":
+      return 25;
+    case "page":
+      return 20;
+    case "book":
+      return 15;
+    case "knowledge":
+      return 10;
+    default:
+      return 5;
+  }
+}
+function relationWeight(record) {
+  const relatedCount = readArray(record, "related_objectives", "relatedObjectives").length + readArray(record, "related_questions", "relatedQuestions").length + readArray(record, "related_books", "relatedBooks").length;
+  return relatedCount * 4;
+}
+function stalenessWeight(updatedAt, now) {
+  if (!updatedAt) {
+    return 8;
+  }
+  const ageDays = Math.max(0, Math.floor((now.valueOf() - updatedAt.valueOf()) / (24 * 60 * 60 * 1e3)));
+  if (ageDays >= 90) return 18;
+  if (ageDays >= 30) return 12;
+  if (ageDays >= 7) return 6;
+  return 0;
+}
+function resolveEstimatedCredits(model, policy, override) {
+  const overrideCredits = readNumber(override ?? {}, "estimatedCredits", "estimated_credits");
+  if (overrideCredits && overrideCredits > 0) {
+    return overrideCredits;
+  }
+  const weighted = policy.creditWeights.find((weight) => weight.taskType === `${model}_review`);
+  return weighted?.credits ?? defaultCreditsForModel(model);
+}
+function summarizeWorkWindow(schedule) {
+  return schedule.windows.map((window) => ({
+    days: window.days,
+    startTime: window.startTime,
+    endTime: window.endTime
+  }));
+}
+function normalizePolicyRecord(projectId, environment, config) {
+  return {
+    projectId,
+    environment,
+    schedule: config.defaultSchedule,
+    dailyTaskCreditBudget: config.dailyTaskCreditBudget,
+    maxQueuedTasks: config.maxQueuedTasks,
+    maxQueuedCredits: config.maxQueuedCredits,
+    autoscale: config.autoscale,
+    creditWeights: config.creditWeights,
+    metadata: {
+      managedBy: "manager",
+      mode: config.mode
+    }
+  };
+}
+function resolveManagerServiceConfig() {
+  const shared = resolveManagerConfig();
+  const environment = envValue("TREESEED_DEPLOY_ENVIRONMENT") || (process.env.NODE_ENV === "production" ? "prod" : "local");
+  const projectId = envValue("TREESEED_PROJECT_ID") || shared.projectId;
+  const teamId = envValue("TREESEED_HOSTING_TEAM_ID") || envValue("TREESEED_CONTENT_DEFAULT_TEAM_ID") || projectId;
+  const dailyTaskCreditBudget = integerFromEnv(
+    "TREESEED_WORKDAY_TASK_CREDIT_BUDGET",
+    integerFromEnv("TREESEED_WORKDAY_CAPACITY_BUDGET", shared.defaultCapacityBudget)
+  );
+  const maxQueuedTasks = integerFromEnv("TREESEED_MANAGER_MAX_QUEUED_TASKS", Math.max(1, Math.min(20, dailyTaskCreditBudget)));
+  const maxQueuedCredits = integerFromEnv("TREESEED_MANAGER_MAX_QUEUED_CREDITS", Math.max(1, Math.min(dailyTaskCreditBudget, maxQueuedTasks * 4)));
+  return {
+    ...shared,
+    mode: envValue("TREESEED_MANAGER_MODE") || (process.env.CI ? "reconcile" : "loop"),
+    managerId: envValue("TREESEED_MANAGER_ID") || `manager-${process.pid}`,
+    marketBaseUrl: envValue("TREESEED_MARKET_API_BASE_URL") || envValue("TREESEED_API_BASE_URL"),
+    runnerToken: envValue("TREESEED_PROJECT_RUNNER_TOKEN"),
+    projectId,
+    teamId,
+    environment,
+    poolName: envValue("TREESEED_AGENT_POOL_NAME") || `${projectId}-${environment}`,
+    serviceBaseUrl: envValue("TREESEED_MANAGER_BASE_URL") || null,
+    pollIntervalMs: integerFromEnv("TREESEED_MANAGER_POLL_INTERVAL_MS", 15e3),
+    dailyTaskCreditBudget,
+    maxQueuedTasks,
+    maxQueuedCredits,
+    priorityModels: parsePriorityModels(),
+    priorityLimitPerModel: integerFromEnv("TREESEED_MANAGER_PRIORITY_LIMIT_PER_MODEL", 50),
+    graphInvalidated: booleanFromEnv("TREESEED_MANAGER_GRAPH_INVALIDATED"),
+    defaultSchedule: resolveScheduleFromEnv(),
+    scalerKind: envValue("TREESEED_WORKER_POOL_SCALER") || "" || null,
+    creditWeights: parseJson(envValue("TREESEED_TASK_CREDIT_WEIGHTS_JSON"), []),
+    autoscale: {
+      minWorkers: integerFromEnv("TREESEED_AGENT_POOL_MIN_WORKERS", 0),
+      maxWorkers: integerFromEnv("TREESEED_AGENT_POOL_MAX_WORKERS", 1),
+      targetQueueDepth: Math.max(1, integerFromEnv("TREESEED_AGENT_POOL_TARGET_QUEUE_DEPTH", 1)),
+      cooldownSeconds: Math.max(0, integerFromEnv("TREESEED_AGENT_POOL_COOLDOWN_SECONDS", 60))
+    }
+  };
+}
+async function resolveReporter(reporter) {
+  return reporter ?? createControlPlaneReporter();
+}
+function resolveScaler(config, scaler) {
+  return scaler ?? createWorkerPoolScaler(config.scalerKind);
+}
+async function getActiveWorkDay(sdk, projectId) {
+  const workDays = await sdk.search({
+    model: "work_day",
+    limit: 10,
+    filters: [
+      { field: "project_id", op: "eq", value: projectId },
+      { field: "state", op: "eq", value: "active" }
+    ],
+    sort: [{ field: "updated_at", direction: "desc" }]
+  });
+  return asRecords(workDays.payload)[0] ?? null;
+}
+async function ensureWorkPolicy(sdk, config) {
+  const existing = await sdk.getWorkPolicy(config.projectId, config.environment);
+  if (existing.payload) {
+    return existing.payload;
+  }
+  const created = await sdk.upsertWorkPolicy(normalizePolicyRecord(config.projectId, config.environment, config));
+  return created.payload;
+}
+async function loadPriorityInputs(sdk, config) {
+  const [overridesEnvelope, ...contentEnvelopes] = await Promise.all([
+    sdk.listPriorityOverrides(config.projectId),
+    ...config.priorityModels.map((model) => sdk.search({
+      model,
+      limit: config.priorityLimitPerModel,
+      sort: [{ field: "updated_at", direction: "desc" }]
+    }).catch(() => ({ payload: [] })))
+  ]);
+  const overrides = asRecords(overridesEnvelope.payload).reduce((map, entry) => {
+    const model = readString(entry, "model");
+    const subjectId = readString(entry, "subjectId", "subject_id");
+    if (model && subjectId) {
+      map.set(`${model}:${subjectId}`, entry);
+    }
+    return map;
+  }, /* @__PURE__ */ new Map());
+  const records = contentEnvelopes.flatMap((envelope, index) => {
+    const model = config.priorityModels[index];
+    return asRecords(envelope.payload).map((entry) => ({ model, entry }));
+  });
+  return { overrides, records };
+}
+async function buildPrioritySnapshot(sdk, config, policy, now, workDayId) {
+  const { overrides, records } = await loadPriorityInputs(sdk, config);
+  const items = records.map(({ model, entry }) => {
+    const id = readString(entry, "id", "slug");
+    const slug = readString(entry, "slug") || null;
+    const title = readString(entry, "title", "name") || null;
+    const status = readString(entry, "status", "runtime_status", "runtimeStatus");
+    const updatedAt = readDate(entry, "updated_at", "updatedAt", "updated", "date");
+    const override = overrides.get(`${model}:${id}`);
+    const overridePriority = readNumber(override ?? {}, "priority") ?? 0;
+    const reasons = [
+      overridePriority > 0 ? `override:${overridePriority}` : null,
+      status ? `status:${status}` : null,
+      relationWeight(entry) > 0 ? "linked_work" : null,
+      updatedAt ? `updated:${updatedAt.toISOString()}` : "updated:unknown"
+    ].filter((value) => Boolean(value));
+    return {
+      model,
+      id,
+      slug,
+      title,
+      priority: modelWeight(model) + statusWeight(status) + relationWeight(entry) + stalenessWeight(updatedAt, now) + overridePriority,
+      estimatedCredits: resolveEstimatedCredits(model, policy, override),
+      reasons,
+      metadata: {
+        status: status || null,
+        updatedAt: updatedAt?.toISOString() ?? null,
+        overrideId: override ? readString(override, "id") : null
+      }
+    };
+  }).filter((item) => item.id).sort((left, right) => right.priority - left.priority || left.model.localeCompare(right.model) || left.id.localeCompare(right.id));
+  const snapshot = await sdk.createPrioritySnapshot({
+    projectId: config.projectId,
+    workDayId: workDayId ?? null,
+    items,
+    metadata: {
+      models: config.priorityModels,
+      schedule: summarizeWorkWindow(policy.schedule)
+    }
+  });
+  return snapshot.payload;
+}
+async function openWorkday(sdk, config, policy, now) {
+  const graphRefresh = await sdk.refreshGraph();
+  const created = await sdk.startWorkDay({
+    projectId: config.projectId,
+    capacityBudget: policy.dailyTaskCreditBudget,
+    graphVersion: graphRefresh.snapshotRoot,
+    summary: {
+      openedAt: now.toISOString(),
+      environment: config.environment,
+      graphVersion: graphRefresh.snapshotRoot
+    },
+    actor: "manager"
+  });
+  return created.payload;
+}
+async function collectTaskMetrics(sdk, workDayId) {
+  const [queuedEnvelope, activeEnvelope] = await Promise.all([
+    sdk.searchTasks({
+      workDayId: workDayId ?? void 0,
+      limit: 500,
+      state: ["pending", "queued"]
+    }),
+    sdk.searchTasks({
+      workDayId: workDayId ?? void 0,
+      limit: 500,
+      state: ["claimed", "running"]
+    })
+  ]);
+  const queuedTasks = asRecords(queuedEnvelope.payload);
+  const activeTasks = asRecords(activeEnvelope.payload);
+  const queuedCredits = queuedTasks.reduce((total, task) => {
+    const payload = parseJson(String(task.payloadJson ?? "{}"), {});
+    const credits = readNumber(payload, "estimatedCredits") ?? 1;
+    return total + credits;
+  }, 0);
+  return {
+    queuedTasks,
+    activeTasks,
+    queuedCount: queuedTasks.length,
+    activeLeases: activeTasks.length,
+    queuedCredits
+  };
+}
+function remainingCredits(workDay, policy) {
+  if (!workDay) {
+    return policy.dailyTaskCreditBudget;
+  }
+  const budget = Number(workDay.capacityBudget ?? policy.dailyTaskCreditBudget ?? 0);
+  const used = Number(workDay.capacityUsed ?? 0);
+  return Math.max(0, budget - used);
+}
+function chooseAgentId(agentSpecs) {
+  const preferred = agentSpecs.find((spec) => {
+    const triggers = Array.isArray(spec.triggers) ? spec.triggers : [];
+    return triggers.some((trigger) => {
+      const type = typeof trigger === "string" ? trigger : readString(trigger, "type");
+      return type === "startup" || type === "schedule";
+    });
+  });
+  return readString(preferred ?? agentSpecs[0] ?? {}, "slug");
+}
+async function maybeEnqueueTask(sdk, task) {
+  const queue = createQueuePushClient();
+  if (!queue) {
+    return { queued: false, queueName: null };
+  }
+  await queue.enqueue({
+    message: queueEnvelopeForTask(task),
+    delaySeconds: 0
+  });
+  await sdk.recordTaskProgress({
+    id: String(task.id ?? ""),
+    state: "queued",
+    appendEvent: {
+      kind: "queued",
+      data: {
+        queueName: envValue("TREESEED_QUEUE_ID") || null
+      }
+    },
+    actor: "manager"
+  });
+  return { queued: true, queueName: envValue("TREESEED_QUEUE_ID") || null };
+}
+async function topUpQueuedTasks(sdk, config, policy, workDay, snapshot, now) {
+  const agentSpecs = await sdk.listAgentSpecs({ enabled: true });
+  const agentId = chooseAgentId(asRecords(agentSpecs));
+  if (!agentId || !snapshot?.items.length) {
+    return {
+      createdTasks: [],
+      remainingCandidates: 0,
+      remainingCredits: remainingCredits(workDay, policy)
+    };
+  }
+  const [allTasksEnvelope, queuedMetrics] = await Promise.all([
+    sdk.searchTasks({ workDayId: String(workDay.id ?? ""), limit: 1e3 }),
+    collectTaskMetrics(sdk, String(workDay.id ?? ""))
+  ]);
+  const existingTasks = asRecords(allTasksEnvelope.payload);
+  const existingKeys = new Set(existingTasks.map((task) => readString(task, "idempotencyKey", "idempotency_key")));
+  let availableCredits = remainingCredits(workDay, policy);
+  let remainingQueuedSlots = Math.max(0, policy.maxQueuedTasks - queuedMetrics.queuedCount);
+  let remainingQueuedCredits = Math.max(0, policy.maxQueuedCredits - queuedMetrics.queuedCredits);
+  const createdTasks = [];
+  for (const item of snapshot.items) {
+    if (remainingQueuedSlots <= 0 || availableCredits <= 0 || remainingQueuedCredits <= 0) {
+      break;
+    }
+    const idempotencyKey = `${String(workDay.id ?? "")}:${item.model}:${item.id}`;
+    if (existingKeys.has(idempotencyKey)) {
+      continue;
+    }
+    const estimatedCredits = Math.max(1, Math.ceil(item.estimatedCredits));
+    if (estimatedCredits > availableCredits || estimatedCredits > remainingQueuedCredits) {
+      continue;
+    }
+    const created = await sdk.createTask({
+      workDayId: String(workDay.id ?? ""),
+      agentId,
+      type: `${item.model}_review`,
+      priority: Math.max(1, Math.round(item.priority)),
+      idempotencyKey,
+      payload: {
+        subject: {
+          model: item.model,
+          id: item.id,
+          slug: item.slug ?? null,
+          title: item.title ?? null
+        },
+        estimatedCredits,
+        priority: item.priority,
+        reasons: item.reasons,
+        createdAt: now.toISOString()
+      },
+      graphVersion: typeof workDay.graphVersion === "string" ? workDay.graphVersion : null,
+      actor: "manager"
+    });
+    if (!created.payload) {
+      continue;
+    }
+    await sdk.recordTaskCredits({
+      projectId: config.projectId,
+      workDayId: String(workDay.id ?? ""),
+      taskId: String(created.payload.id ?? ""),
+      phase: "seed",
+      credits: estimatedCredits,
+      metadata: {
+        model: item.model,
+        subjectId: item.id
+      }
+    });
+    await maybeEnqueueTask(sdk, created.payload);
+    createdTasks.push(created.payload);
+    existingKeys.add(idempotencyKey);
+    availableCredits -= estimatedCredits;
+    remainingQueuedSlots -= 1;
+    remainingQueuedCredits -= estimatedCredits;
+  }
+  const remainingCandidates = snapshot.items.filter((item) => !existingKeys.has(`${String(workDay.id ?? "")}:${item.model}:${item.id}`)).length;
+  return {
+    createdTasks,
+    remainingCandidates,
+    remainingCredits: availableCredits
+  };
+}
+function desiredWorkersForSnapshot(policy, metrics) {
+  const { minWorkers, maxWorkers, targetQueueDepth } = policy.autoscale;
+  if (metrics.queuedCount <= 0 && metrics.activeLeases <= 0) {
+    return minWorkers;
+  }
+  const requiredByQueue = Math.ceil(metrics.queuedCount / Math.max(1, targetQueueDepth));
+  const minimumActive = metrics.activeLeases > 0 ? 1 : 0;
+  return Math.max(minWorkers, Math.min(maxWorkers, Math.max(requiredByQueue, minimumActive)));
+}
+function applyScaleCooldown(policy, latestDecision, nextDesired, now) {
+  if (!latestDecision) {
+    return nextDesired;
+  }
+  if (nextDesired >= latestDecision.desiredWorkers) {
+    return nextDesired;
+  }
+  const cooldownMs = Math.max(0, policy.autoscale.cooldownSeconds) * 1e3;
+  if (cooldownMs === 0) {
+    return nextDesired;
+  }
+  const lastChangedAt = new Date(latestDecision.createdAt);
+  if (!Number.isFinite(lastChangedAt.valueOf())) {
+    return nextDesired;
+  }
+  return now.valueOf() - lastChangedAt.valueOf() < cooldownMs ? latestDecision.desiredWorkers : nextDesired;
+}
+async function registerHeartbeat(reporter, config, policy, desiredWorkers, metrics) {
+  await reporter.registerAgentPoolHeartbeat({
+    teamId: config.teamId,
+    environment: config.environment,
+    poolName: config.poolName,
+    managerId: config.managerId,
+    serviceName: "manager",
+    registrationIdentity: config.managerId,
+    serviceBaseUrl: config.serviceBaseUrl,
+    autoscale: policy.autoscale,
+    desiredWorkers,
+    observedQueueDepth: metrics.queuedCount,
+    observedActiveLeases: metrics.activeLeases,
+    metadata: {
+      projectId: config.projectId,
+      managerPort: config.port
+    }
+  });
+}
+async function buildWorkdaySummary(sdk, config, workDay, policy, currentSnapshot, scaleDecision, scaleResult) {
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const [tasksEnvelope, creditsEnvelope, deployments] = await Promise.all([
+    sdk.searchTasks({ workDayId: String(workDay.id ?? ""), limit: 1e3 }),
+    sdk.listTaskCredits(String(workDay.id ?? "")),
+    fetchRunnerDeployments(config)
+  ]);
+  const tasks = asRecords(tasksEnvelope.payload);
+  const credits = Array.isArray(creditsEnvelope.payload) ? creditsEnvelope.payload : [];
+  const taskDetails = await Promise.all(tasks.map(async (task) => {
+    const taskId = readString(task, "id");
+    const [eventsEnvelope, outputsEnvelope] = await Promise.all([
+      sdk.search({
+        model: "task_event",
+        filters: [{ field: "taskId", op: "eq", value: taskId }],
+        limit: 200
+      }),
+      sdk.search({
+        model: "task_output",
+        filters: [{ field: "taskId", op: "eq", value: taskId }],
+        limit: 200
+      })
+    ]);
+    const taskEvents = asRecords(eventsEnvelope.payload);
+    const taskOutputs = asRecords(outputsEnvelope.payload);
+    const changedFiles2 = /* @__PURE__ */ new Set();
+    for (const output of taskOutputs) {
+      normalizeChangedFilesFromValue(parseJsonString(output.outputJson ?? output.output_json), changedFiles2);
+    }
+    const latestEvent = [...taskEvents].sort((left, right) => Number(readNumber(right, "seq") ?? 0) - Number(readNumber(left, "seq") ?? 0))[0];
+    return {
+      task: {
+        id: taskId,
+        agentId: readString(task, "agentId", "agent_id") || void 0,
+        type: readString(task, "type") || void 0,
+        state: readString(task, "state") || void 0,
+        priority: readNumber(task, "priority") ?? void 0,
+        idempotencyKey: readString(task, "idempotencyKey", "idempotency_key") || void 0,
+        createdAt: isoDateOrNull(readString(task, "createdAt", "created_at")),
+        startedAt: isoDateOrNull(readString(task, "startedAt", "started_at")),
+        completedAt: isoDateOrNull(readString(task, "completedAt", "completed_at")),
+        lastErrorCode: readString(task, "lastErrorCode", "last_error_code") || null,
+        lastErrorMessage: readString(task, "lastErrorMessage", "last_error_message") || null,
+        lastEventKind: latestEvent ? readString(latestEvent, "kind") || null : null,
+        outputCount: taskOutputs.length,
+        changedFiles: [...changedFiles2]
+      },
+      changedFiles: changedFiles2
+    };
+  }));
+  const changedFiles = [...taskDetails.reduce((set, detail) => {
+    for (const filePath of detail.changedFiles) {
+      set.add(filePath);
+    }
+    return set;
+  }, /* @__PURE__ */ new Set())].sort((left, right) => left.localeCompare(right));
+  const releases = filterDeploymentsForWorkday(deployments, workDay, generatedAt).map((deployment) => ({
+    id: readString(deployment, "id") || void 0,
+    deploymentKind: readString(deployment, "deploymentKind", "deployment_kind") || "code",
+    status: readString(deployment, "status") || "unknown",
+    releaseTag: readString(deployment, "releaseTag", "release_tag") || null,
+    commitSha: readString(deployment, "commitSha", "commit_sha") || null,
+    sourceRef: readString(deployment, "sourceRef", "source_ref") || null,
+    startedAt: isoDateOrNull(readString(deployment, "startedAt", "started_at")),
+    finishedAt: isoDateOrNull(readString(deployment, "finishedAt", "finished_at")),
+    createdAt: isoDateOrNull(readString(deployment, "createdAt", "created_at"))
+  }));
+  const budget = Number(workDay.capacityBudget ?? policy.dailyTaskCreditBudget ?? 0);
+  const used = Number(workDay.capacityUsed ?? 0);
+  return {
+    projectId: config.projectId,
+    environment: config.environment,
+    workDayId: String(workDay.id ?? ""),
+    state: String(workDay.state ?? "active"),
+    totalTasks: tasks.length,
+    completedTasks: tasks.filter((task) => task.state === "completed").length,
+    failedTasks: tasks.filter((task) => task.state === "failed").length,
+    queuedTasks: tasks.filter((task) => task.state === "queued" || task.state === "pending").length,
+    activeTasks: tasks.filter((task) => task.state === "claimed" || task.state === "running").length,
+    dailyTaskCreditBudget: budget,
+    usedTaskCredits: used,
+    remainingTaskCredits: Math.max(0, budget - used),
+    creditLedgerEntries: credits.length,
+    prioritySnapshotId: currentSnapshot?.id ?? null,
+    priorityItemCount: currentSnapshot?.items.length ?? 0,
+    priorityItems: currentSnapshot?.items ?? [],
+    taskItems: taskDetails.map((detail) => detail.task),
+    changedFiles,
+    releases,
+    scaleDecision,
+    scaleResult,
+    generatedAt
+  };
+}
+async function reportWorkdaySummary(sdk, reporter, config, workDay, policy, currentSnapshot, scaleDecision, scaleResult) {
+  const summary = await buildWorkdaySummary(sdk, config, workDay, policy, currentSnapshot, scaleDecision, scaleResult);
+  const snapshot = writeWorkdayContentSnapshot({
+    repoRoot: process.env.TREESEED_AGENT_REPO_ROOT?.trim() || process.cwd(),
+    projectId: config.projectId,
+    teamId: config.teamId,
+    environment: config.environment,
+    workDay,
+    summary,
+    prioritySnapshot: currentSnapshot,
+    scaleDecision,
+    scaleResult,
+    tasks: Array.isArray(summary.taskItems) ? summary.taskItems : [],
+    changedFiles: Array.isArray(summary.changedFiles) ? summary.changedFiles.filter((entry) => typeof entry === "string") : [],
+    releases: Array.isArray(summary.releases) ? summary.releases : [],
+    generatedAt: String(summary.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString())
+  });
+  const report = await sdk.createReport({
+    workDayId: String(workDay.id ?? ""),
+    kind: "workday_summary",
+    body: {
+      ...summary,
+      contentSnapshot: {
+        relativePath: snapshot.relativePath,
+        slug: snapshot.slug,
+        reportVersion: snapshot.reportVersion,
+        title: snapshot.title
+      }
+    },
+    renderedRef: snapshot.relativePath,
+    sentAt: String(summary.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString()),
+    actor: "manager"
+  });
+  await reporter.reportWorkdaySummary({
+    environment: config.environment,
+    workDayId: String(workDay.id ?? ""),
+    kind: "workday_summary",
+    state: String(workDay.state ?? "active"),
+    startedAt: readString(workDay, "startedAt", "started_at") || null,
+    endedAt: readString(workDay, "endedAt", "ended_at") || null,
+    summary,
+    metadata: {
+      projectId: config.projectId,
+      contentSnapshot: {
+        relativePath: snapshot.relativePath,
+        slug: snapshot.slug,
+        reportVersion: snapshot.reportVersion
+      },
+      reportId: report.payload ? readString(report.payload, "id") || null : null
+    }
+  });
+  return {
+    ...summary,
+    contentSnapshot: {
+      relativePath: snapshot.relativePath,
+      slug: snapshot.slug,
+      reportVersion: snapshot.reportVersion,
+      title: snapshot.title
+    }
+  };
+}
+function shouldCloseWorkday(options) {
+  if (!options.workDay) {
+    return false;
+  }
+  const drained = options.queuedCount === 0 && options.activeLeases === 0;
+  if (!drained) {
+    return false;
+  }
+  return !options.insideWorkWindow || options.remainingCredits <= 0 || options.remainingCandidates <= 0;
+}
+async function reconcileManager(options) {
+  const config = options.config ?? resolveManagerServiceConfig();
+  const sdk = options.sdk ?? createServiceSdk();
+  const reporter = await resolveReporter(options.reporter);
+  const scaler = resolveScaler(config, options.scaler);
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const policy = await ensureWorkPolicy(sdk, config);
+  const insideWorkWindow = isWithinWorkWindow(now, policy.schedule);
+  let activeWorkDay = await getActiveWorkDay(sdk, config.projectId);
+  let currentSnapshot = null;
+  if (!activeWorkDay && insideWorkWindow && policy.dailyTaskCreditBudget > 0) {
+    const previewSnapshot = await buildPrioritySnapshot(sdk, config, policy, now, null);
+    if ((previewSnapshot?.items.length ?? 0) > 0) {
+      activeWorkDay = await openWorkday(sdk, config, policy, now);
+      currentSnapshot = activeWorkDay ? await buildPrioritySnapshot(sdk, config, policy, now, String(activeWorkDay.id ?? "")) : previewSnapshot;
+    }
+  }
+  if (activeWorkDay && !currentSnapshot) {
+    currentSnapshot = await buildPrioritySnapshot(sdk, config, policy, now, String(activeWorkDay.id ?? ""));
+  }
+  let seedResult = {
+    createdTasks: [],
+    remainingCandidates: currentSnapshot?.items.length ?? 0,
+    remainingCredits: remainingCredits(activeWorkDay, policy)
+  };
+  if (activeWorkDay && insideWorkWindow && seedResult.remainingCredits > 0) {
+    seedResult = await topUpQueuedTasks(sdk, config, policy, activeWorkDay, currentSnapshot, now);
+  }
+  const metrics = await collectTaskMetrics(sdk, activeWorkDay ? String(activeWorkDay.id ?? "") : null);
+  const rawDesiredWorkers = activeWorkDay ? desiredWorkersForSnapshot(policy, metrics) : 0;
+  const latestScaleDecision = await sdk.getLatestScaleDecision(config.projectId, config.environment, config.poolName);
+  const desiredWorkers = applyScaleCooldown(policy, latestScaleDecision.payload, rawDesiredWorkers, now);
+  const scaleDecision = {
+    projectId: config.projectId,
+    environment: config.environment,
+    poolName: config.poolName,
+    workDayId: activeWorkDay ? String(activeWorkDay.id ?? "") : null,
+    desiredWorkers,
+    observedQueueDepth: metrics.queuedCount,
+    observedActiveLeases: metrics.activeLeases,
+    reason: desiredWorkers !== rawDesiredWorkers ? "cooldown_hold" : "reconcile",
+    metadata: {
+      insideWorkWindow,
+      remainingCredits: seedResult.remainingCredits,
+      seededTaskCount: seedResult.createdTasks.length
+    }
+  };
+  const recordedScaleDecision = await sdk.recordScaleDecision(scaleDecision);
+  const appliedScaleDecision = recordedScaleDecision.payload ?? scaleDecision;
+  const scaleResult = await scaler.scale(appliedScaleDecision);
+  await registerHeartbeat(reporter, config, policy, desiredWorkers, metrics);
+  await reporter.reportScaleDecision({
+    environment: config.environment,
+    poolName: config.poolName,
+    workDayId: activeWorkDay ? String(activeWorkDay.id ?? "") : null,
+    desiredWorkers,
+    observedQueueDepth: metrics.queuedCount,
+    observedActiveLeases: metrics.activeLeases,
+    reason: appliedScaleDecision.reason,
+    metadata: {
+      ...appliedScaleDecision.metadata,
+      scaleResult
+    }
+  });
+  let closedWorkDay = null;
+  let workdaySummary = null;
+  if (shouldCloseWorkday({
+    insideWorkWindow,
+    workDay: activeWorkDay,
+    remainingCredits: seedResult.remainingCredits,
+    queuedCount: metrics.queuedCount,
+    activeLeases: metrics.activeLeases,
+    remainingCandidates: seedResult.remainingCandidates
+  })) {
+    if (activeWorkDay) {
+      workdaySummary = await reportWorkdaySummary(
+        sdk,
+        reporter,
+        config,
+        activeWorkDay,
+        policy,
+        currentSnapshot,
+        appliedScaleDecision,
+        scaleResult
+      );
+      const closed = await sdk.closeWorkDay({
+        id: String(activeWorkDay.id ?? ""),
+        state: "completed",
+        summary: workdaySummary,
+        actor: "manager"
+      });
+      closedWorkDay = closed.payload ?? activeWorkDay;
+    }
+  }
+  return {
+    ok: true,
+    mode: "reconcile",
+    managerId: config.managerId,
+    projectId: config.projectId,
+    environment: config.environment,
+    insideWorkWindow,
+    workPolicy: policy,
+    workDay: closedWorkDay ?? activeWorkDay,
+    prioritySnapshot: currentSnapshot,
+    seededTasks: seedResult.createdTasks,
+    queuedCount: metrics.queuedCount,
+    activeLeases: metrics.activeLeases,
+    desiredWorkers,
+    scaleResult,
+    workdaySummary
+  };
+}
+async function runOpenWorkday(options) {
+  const config = options.config ?? resolveManagerServiceConfig();
+  const sdk = options.sdk ?? createServiceSdk();
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const policy = await ensureWorkPolicy(sdk, config);
+  const active = await getActiveWorkDay(sdk, config.projectId);
+  if (active) {
+    return { ok: true, created: false, workDay: active };
+  }
+  if (!isWithinWorkWindow(now, policy.schedule)) {
+    return { ok: true, created: false, skipped: true, reason: "outside_work_window" };
+  }
+  const workDay = await openWorkday(sdk, config, policy, now);
+  const prioritySnapshot = workDay ? await buildPrioritySnapshot(sdk, config, policy, now, String(workDay.id ?? "")) : null;
+  return { ok: true, created: Boolean(workDay), workDay, prioritySnapshot };
+}
+async function runCloseWorkday(options) {
+  const config = options.config ?? resolveManagerServiceConfig();
+  const sdk = options.sdk ?? createServiceSdk();
+  const reporter = await resolveReporter(options.reporter);
+  const scaler = resolveScaler(config, options.scaler);
+  const policy = await ensureWorkPolicy(sdk, config);
+  const activeWorkDay = await getActiveWorkDay(sdk, config.projectId);
+  if (!activeWorkDay) {
+    return { ok: true, skipped: true, reason: "no_active_workday" };
+  }
+  const decision = {
+    projectId: config.projectId,
+    environment: config.environment,
+    poolName: config.poolName,
+    workDayId: String(activeWorkDay.id ?? ""),
+    desiredWorkers: 0,
+    observedQueueDepth: 0,
+    observedActiveLeases: 0,
+    reason: "close_workday",
+    metadata: {
+      requestedBy: "manager"
+    }
+  };
+  const recorded = await sdk.recordScaleDecision(decision);
+  const scale = await scaler.scale(recorded.payload ?? decision);
+  const latestSnapshot = await sdk.getLatestPrioritySnapshot(config.projectId, String(activeWorkDay.id ?? ""));
+  const summary = await reportWorkdaySummary(
+    sdk,
+    reporter,
+    config,
+    activeWorkDay,
+    policy,
+    latestSnapshot.payload,
+    recorded.payload ?? decision,
+    scale
+  );
+  const closed = await sdk.closeWorkDay({
+    id: String(activeWorkDay.id ?? ""),
+    state: "completed",
+    summary,
+    actor: "manager"
+  });
+  return { ok: true, workDay: closed.payload, summary, scale };
+}
+async function runReportWorkday(options) {
+  const config = options.config ?? resolveManagerServiceConfig();
+  const sdk = options.sdk ?? createServiceSdk();
+  const reporter = await resolveReporter(options.reporter);
+  const policy = await ensureWorkPolicy(sdk, config);
+  const activeWorkDay = await getActiveWorkDay(sdk, config.projectId);
+  if (!activeWorkDay) {
+    return { ok: true, skipped: true, reason: "no_active_workday" };
+  }
+  const latestScaleDecision = await sdk.getLatestScaleDecision(config.projectId, config.environment, config.poolName);
+  const latestSnapshot = await sdk.getLatestPrioritySnapshot(config.projectId, String(activeWorkDay.id ?? ""));
+  const summary = await reportWorkdaySummary(
+    sdk,
+    reporter,
+    config,
+    activeWorkDay,
+    policy,
+    latestSnapshot.payload,
+    latestScaleDecision.payload ?? {
+      projectId: config.projectId,
+      environment: config.environment,
+      poolName: config.poolName,
+      workDayId: String(activeWorkDay.id ?? ""),
+      desiredWorkers: 0,
+      observedQueueDepth: 0,
+      observedActiveLeases: 0,
+      reason: "report_workday",
+      metadata: {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    {
+      applied: false,
+      provider: "noop",
+      desiredWorkers: Number(latestScaleDecision.payload?.desiredWorkers ?? 0),
+      metadata: {
+        reason: "report_only"
+      }
+    }
+  );
+  return { ok: true, workDayId: activeWorkDay.id, summary };
+}
+async function runManagerAction(options = {}) {
+  const mode = options.mode ?? options.config?.mode ?? resolveManagerServiceConfig().mode;
+  switch (mode) {
+    case "open-workday":
+      return runOpenWorkday(options);
+    case "close-workday":
+      return runCloseWorkday(options);
+    case "report-workday":
+      return runReportWorkday(options);
+    case "reconcile":
+      return reconcileManager(options);
+    case "loop":
+    default:
+      return reconcileManager(options);
+  }
+}
+async function runManagerCycle(options = {}) {
+  return reconcileManager(options);
+}
+async function startManagerLoop(options = {}) {
+  const config = options.config ?? resolveManagerServiceConfig();
+  for (; ; ) {
+    try {
+      await reconcileManager({
+        ...options,
+        config
+      });
+    } catch (error) {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    }
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, config.pollIntervalMs));
+  }
+}
+function readCliMode() {
+  const args = process.argv.slice(2);
+  const index = args.indexOf("--mode");
+  if (index >= 0) {
+    return args[index + 1];
+  }
+  return void 0;
+}
+const currentFile = fileURLToPath(import.meta.url);
+const entryFile = process.argv[1] ?? "";
+if (entryFile === currentFile) {
+  const mode = readCliMode() ?? resolveManagerServiceConfig().mode;
+  if (mode === "loop") {
+    await startManagerLoop({
+      config: {
+        ...resolveManagerServiceConfig(),
+        mode
+      }
+    });
+  } else {
+    process.stdout.write(`${JSON.stringify(await runManagerAction({ mode }), null, 2)}
+`);
+  }
+}
+export {
+  resolveManagerServiceConfig,
+  runManagerAction,
+  runManagerCycle,
+  startManagerLoop
+};