@treeseed/core 0.6.38 → 0.6.39

package/dist/services/manager.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
 import {
-  createControlPlaneReporter
+  createControlPlaneReporter,
+  reserveCreditsForEstimate,
+  selectBestCapacityLane,
+  summarizeCapacityPlan
 } from "@treeseed/sdk";
 import { loadActiveAgentSpecs } from "../agents/spec-loader.js";
 import { followCursorKey, resolveTriggerDecision } from "../agents/kernel/trigger-resolver.js";
-import { createQueuePushClient, createServiceSdk, queueEnvelopeForTask, resolveManagerConfig } from "./common.js";
+import { createQueuePushClient, createServiceSdk, queueEnvelopeForTask, resolveManagerConfig, seedGraphRefreshTask } from "./common.js";
 import {
   applyInteractiveWakeUpOverride,
   applyScaleCooldown,
@@ -345,6 +348,13 @@ function normalizePolicyRecord(projectId, environment, config) {
     projectId,
     environment,
     schedule: config.defaultSchedule,
+    enabled: true,
+    startCron: envValue("TREESEED_WORKDAY_START_CRON") || "0 9 * * 1-5",
+    durationMinutes: integerFromEnv("TREESEED_WORKDAY_DURATION_MINUTES", 480),
+    maxRunners: config.autoscale.maxWorkers,
+    maxWorkersPerRunner: integerFromEnv("TREESEED_RUNNER_MAX_LOCAL_WORKERS", 4),
+    dailyCreditBudget: config.dailyTaskCreditBudget,
+    closeoutGraceMinutes: integerFromEnv("TREESEED_WORKDAY_CLOSEOUT_GRACE_MINUTES", 15),
     dailyTaskCreditBudget: config.dailyTaskCreditBudget,
     maxQueuedTasks: config.maxQueuedTasks,
     maxQueuedCredits: config.maxQueuedCredits,
@@ -487,21 +497,112 @@ async function buildPrioritySnapshot(sdk, config, policy, now, workDayId) {
   });
   return snapshot.payload;
 }
-async function openWorkday(sdk, config, policy, now) {
-  const graphRefresh = await sdk.refreshGraph();
+async function openWorkday(sdk, config, policy, now, reporter) {
+  const capacityPlan = await reporter?.getProjectCapacityPlan(config.environment).catch(() => null) ?? null;
+  const capacityEnvelope = await reserveWorkdayCapacity({
+    config,
+    policy,
+    capacityPlan,
+    reporter,
+    now
+  });
+  if (capacityPlan && capacityPlan.grants.length > 0 && !capacityEnvelope) {
+    return null;
+  }
   const created = await sdk.startWorkDay({
     projectId: config.projectId,
     capacityBudget: policy.dailyTaskCreditBudget,
-    graphVersion: graphRefresh.snapshotRoot,
+    graphVersion: null,
     summary: {
       openedAt: now.toISOString(),
       environment: config.environment,
-      graphVersion: graphRefresh.snapshotRoot
+      graphRefresh: { state: "queued" },
+      capacityPlan: capacityPlan ? summarizeCapacityPlan(capacityPlan) : null,
+      capacityEnvelope
     },
     actor: "manager"
   });
+  if (created.payload) {
+    await seedGraphRefreshTask(sdk, {
+      workDayId: String(created.payload.id),
+      projectId: config.projectId,
+      actor: "manager"
+    });
+  }
   return created.payload;
 }
+async function reserveWorkdayCapacity(options) {
+  if (!options.capacityPlan || options.capacityPlan.grants.length === 0 || options.capacityPlan.lanes.length === 0) {
+    return null;
+  }
+  const activeGrants = options.capacityPlan.grants.filter((grant2) => grant2.state === "active");
+  const candidates = activeGrants.flatMap((grant2) => {
+    const lane = grant2.laneId ? options.capacityPlan?.lanes.find((entry) => entry.id === grant2.laneId) : options.capacityPlan?.lanes.find((entry) => entry.capacityProviderId === grant2.capacityProviderId);
+    if (!lane) return [];
+    return [{
+      lane,
+      grant: grant2,
+      remainingCredits: grant2.dailyCreditLimit ?? options.capacityPlan?.remaining.dailyCredits ?? null,
+      taskKind: "workday"
+    }];
+  });
+  const selected = selectBestCapacityLane(candidates).selected;
+  if (!selected || !options.reporter?.enabled) {
+    return null;
+  }
+  const grant = activeGrants.find((entry) => entry.laneId === selected.laneId || entry.capacityProviderId === selected.capacityProviderId);
+  const estimate = reserveCreditsForEstimate({
+    taskKind: "workday",
+    confidence: "medium",
+    estimatedCreditsP50: options.policy.dailyTaskCreditBudget,
+    estimatedCreditsP90: options.policy.dailyTaskCreditBudget
+  });
+  const reservation = await options.reporter.createCapacityReservation({
+    capacityProviderId: selected.capacityProviderId,
+    laneId: selected.laneId,
+    teamId: options.capacityPlan.teamId,
+    projectId: options.config.projectId,
+    workDayId: null,
+    taskId: null,
+    reservedCredits: estimate.reservedCredits,
+    metadata: {
+      environment: options.config.environment,
+      grantId: grant?.id ?? null,
+      createdBy: "manager.openWorkday",
+      createdAt: options.now.toISOString()
+    }
+  }).catch(() => null);
+  if (!reservation) {
+    return null;
+  }
+  await options.reporter.reportCapacityRoutingDecision({
+    projectId: options.config.projectId,
+    selectedProviderId: selected.capacityProviderId,
+    selectedLaneId: selected.laneId,
+    decision: "workday_capacity_reserved",
+    reason: "Selected eligible capacity lane for workday reservation.",
+    scores: { selected },
+    candidates: candidates.map((candidate) => ({
+      laneId: candidate.lane.id,
+      capacityProviderId: candidate.lane.capacityProviderId,
+      grantId: candidate.grant?.id ?? null
+    }))
+  }).catch(() => null);
+  return {
+    providerId: selected.capacityProviderId,
+    laneId: selected.laneId,
+    reservationIds: [reservation.id],
+    maxCredits: estimate.reservedCredits,
+    approvalBehavior: "pause_task",
+    pausePolicy: {
+      onOverrun: "pause_for_approval"
+    },
+    metadata: {
+      grantId: grant?.id ?? null,
+      scarcityLevel: options.capacityPlan.lanes.find((lane) => lane.id === selected.laneId)?.scarcityLevel ?? null
+    }
+  };
+}
 function remainingCredits(workDay, policy) {
   if (!workDay) {
     return policy.dailyTaskCreditBudget;
@@ -510,6 +611,25 @@ function remainingCredits(workDay, policy) {
   const used = Number(workDay.capacityUsed ?? 0);
   return Math.max(0, budget - used);
 }
+function capacityEnvelopeFromWorkDay(workDay, maxCredits) {
+  const summary = parseJsonString(workDay.summaryJson ?? workDay.summary_json, {});
+  const envelope = asRecord(summary.capacityEnvelope);
+  if (!Object.keys(envelope).length) {
+    return maxCredits ? {
+      maxCredits,
+      approvalBehavior: "pause_task",
+      pausePolicy: { onOverrun: "pause_for_approval" }
+    } : null;
+  }
+  return {
+    ...envelope,
+    maxCredits: maxCredits ?? readNumber(envelope, "maxCredits") ?? null,
+    metadata: {
+      ...asRecord(envelope.metadata),
+      inheritedFromWorkDay: true
+    }
+  };
+}
 function chooseAgentId(agentSpecs) {
   const preferred = agentSpecs.find((spec) => {
     const triggers = Array.isArray(spec.triggers) ? spec.triggers : [];
@@ -590,6 +710,7 @@ async function topUpQueuedTasks(sdk, config, policy, workDay, snapshot, now) {
         estimatedCredits,
         priority: item.priority,
         reasons: item.reasons,
+        capacityEnvelope: capacityEnvelopeFromWorkDay(workDay, estimatedCredits),
         createdAt: now.toISOString()
       },
       graphVersion: typeof workDay.graphVersion === "string" ? workDay.graphVersion : null,
@@ -710,6 +831,7 @@ async function materializeAgentTriggerTasks(sdk, workDay, now) {
           executionKind: "agent_trigger",
           agentSlug: agent.slug,
           invocation,
+          capacityEnvelope: capacityEnvelopeFromWorkDay(workDay),
           createdAt: now.toISOString()
         },
         graphVersion: typeof workDay.graphVersion === "string" ? workDay.graphVersion : null,
@@ -840,26 +962,44 @@ async function buildWorkdaySummary(sdk, config, workDay, policy, currentSnapshot
 }
 async function reportWorkdaySummary(sdk, reporter, config, workDay, policy, currentSnapshot, scaleDecision, scaleResult) {
   const summary = await buildWorkdaySummary(sdk, config, workDay, policy, currentSnapshot, scaleDecision, scaleResult);
+  const capacityPlan = await reporter.getProjectCapacityPlan(config.environment).catch(() => null);
+  const enrichedSummary = {
+    ...summary,
+    capacity: capacityPlan ? {
+      ...summarizeCapacityPlan(capacityPlan),
+      providerSplit: capacityPlan.activeReservations.filter((reservation) => reservation.workDayId === String(workDay.id ?? "") || reservation.workDayId === null).map((reservation) => ({
+        providerId: reservation.capacityProviderId,
+        laneId: reservation.laneId,
+        state: reservation.state,
+        reservedCredits: reservation.reservedCredits,
+        consumedCredits: reservation.consumedCredits,
+        reservedProviderUnits: reservation.reservedProviderUnits,
+        consumedProviderUnits: reservation.consumedProviderUnits,
+        reservedUsd: reservation.reservedUsd,
+        consumedUsd: reservation.consumedUsd
+      }))
+    } : null
+  };
   const snapshot = writeWorkdayContentSnapshot({
     repoRoot: process.env.TREESEED_AGENT_REPO_ROOT?.trim() || process.cwd(),
     projectId: config.projectId,
     teamId: config.teamId,
     environment: config.environment,
     workDay,
-    summary,
+    summary: enrichedSummary,
     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())
+    tasks: Array.isArray(enrichedSummary.taskItems) ? enrichedSummary.taskItems : [],
+    changedFiles: Array.isArray(enrichedSummary.changedFiles) ? enrichedSummary.changedFiles.filter((entry) => typeof entry === "string") : [],
+    releases: Array.isArray(enrichedSummary.releases) ? enrichedSummary.releases : [],
+    generatedAt: String(enrichedSummary.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString())
   });
   const report = await sdk.createReport({
     workDayId: String(workDay.id ?? ""),
     kind: "workday_summary",
     body: {
-      ...summary,
+      ...enrichedSummary,
       contentSnapshot: {
         relativePath: snapshot.relativePath,
         slug: snapshot.slug,
@@ -868,7 +1008,7 @@ async function reportWorkdaySummary(sdk, reporter, config, workDay, policy, curr
       }
     },
     renderedRef: snapshot.relativePath,
-    sentAt: String(summary.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString()),
+    sentAt: String(enrichedSummary.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString()),
     actor: "manager"
   });
   await reporter.reportWorkdaySummary({
@@ -878,7 +1018,7 @@ async function reportWorkdaySummary(sdk, reporter, config, workDay, policy, curr
     state: String(workDay.state ?? "active"),
     startedAt: readString(workDay, "startedAt", "started_at") || null,
     endedAt: readString(workDay, "endedAt", "ended_at") || null,
-    summary,
+    summary: enrichedSummary,
     metadata: {
       projectId: config.projectId,
       contentSnapshot: {
@@ -890,7 +1030,7 @@ async function reportWorkdaySummary(sdk, reporter, config, workDay, policy, curr
     }
   });
   return {
-    ...summary,
+    ...enrichedSummary,
     contentSnapshot: {
       relativePath: snapshot.relativePath,
       slug: snapshot.slug,
@@ -916,13 +1056,35 @@ async function reconcileManager(options) {
   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);
+  if (policy.enabled === false) {
+    return {
+      ok: true,
+      mode: "reconcile",
+      managerId: config.managerId,
+      projectId: config.projectId,
+      environment: config.environment,
+      insideWorkWindow: false,
+      workPolicy: policy,
+      workDay: null,
+      prioritySnapshot: null,
+      seededTasks: [],
+      queuedCount: 0,
+      activeLeases: 0,
+      desiredWorkers: 0,
+      scaleResult: { applied: false, provider: "noop", desiredWorkers: 0, metadata: { reason: "workday_policy_disabled" } },
+      workdaySummary: null
+    };
+  }
+  const pendingWorkdayRequests = typeof sdk.listWorkdayRequests === "function" ? (await sdk.listWorkdayRequests(config.projectId, config.environment, "pending").catch(() => ({ payload: [] }))).payload ?? [] : [];
+  const manualRunRequested = pendingWorkdayRequests.some((entry) => entry.type === "one_off_run" || entry.type === "retry_open");
+  const earlyCloseRequested = pendingWorkdayRequests.some((entry) => entry.type === "early_close");
+  const insideWorkWindow = !earlyCloseRequested && (manualRunRequested || 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);
+      activeWorkDay = await openWorkday(sdk, config, policy, now, reporter);
       currentSnapshot = activeWorkDay ? await buildPrioritySnapshot(sdk, config, policy, now, String(activeWorkDay.id ?? "")) : previewSnapshot;
     }
   }
@@ -1038,16 +1200,20 @@ async function reconcileManager(options) {
 async function runOpenWorkday(options) {
   const config = options.config ?? resolveManagerServiceConfig();
   const sdk = options.sdk ?? createServiceSdk();
+  const reporter = await resolveReporter(options.reporter);
   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 (policy.enabled === false) {
+    return { ok: true, created: false, skipped: true, reason: "workday_policy_disabled" };
+  }
   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 workDay = await openWorkday(sdk, config, policy, now, reporter);
   const prioritySnapshot = workDay ? await buildPrioritySnapshot(sdk, config, policy, now, String(workDay.id ?? "")) : null;
   return { ok: true, created: Boolean(workDay), workDay, prioritySnapshot };
 }

package/dist/services/workday-manager.d.ts

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+import { createServiceSdk } from './common.ts';
+import { resolveManagerServiceConfig } from './manager.ts';
+type WorkdayManagerSdk = ReturnType<typeof createServiceSdk>;
+type WorkdayManagerConfig = ReturnType<typeof resolveManagerServiceConfig>;
+export declare function runScheduledWorkdayManager(options?: {
+    sdk?: WorkdayManagerSdk;
+    config?: WorkdayManagerConfig;
+    now?: Date;
+}): Promise<{
+    ok: boolean;
+    skipped: boolean;
+    reason: string;
+    initial?: undefined;
+    latest?: undefined;
+    closed?: undefined;
+} | {
+    ok: boolean;
+    skipped: boolean;
+    reason: string;
+    initial: {
+        ok: boolean;
+        mode: "reconcile";
+        managerId: string;
+        projectId: string;
+        environment: "local" | "prod" | "staging";
+        insideWorkWindow: boolean;
+        workPolicy: import("@treeseed/sdk").WorkdayPolicy;
+        workDay: Record<string, unknown>;
+        prioritySnapshot: import("@treeseed/sdk").PrioritySnapshot;
+        seededTasks: {
+            [x: string]: unknown;
+        }[];
+        queuedCount: number;
+        activeLeases: number;
+        desiredWorkers: number;
+        scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
+        workdaySummary: Record<string, unknown>;
+    };
+    latest?: undefined;
+    closed?: undefined;
+} | {
+    ok: boolean;
+    initial: {
+        ok: boolean;
+        mode: "reconcile";
+        managerId: string;
+        projectId: string;
+        environment: "local" | "prod" | "staging";
+        insideWorkWindow: boolean;
+        workPolicy: import("@treeseed/sdk").WorkdayPolicy;
+        workDay: Record<string, unknown>;
+        prioritySnapshot: import("@treeseed/sdk").PrioritySnapshot;
+        seededTasks: {
+            [x: string]: unknown;
+        }[];
+        queuedCount: number;
+        activeLeases: number;
+        desiredWorkers: number;
+        scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
+        workdaySummary: Record<string, unknown>;
+    };
+    latest: {
+        ok: boolean;
+        mode: "reconcile";
+        managerId: string;
+        projectId: string;
+        environment: "local" | "prod" | "staging";
+        insideWorkWindow: boolean;
+        workPolicy: import("@treeseed/sdk").WorkdayPolicy;
+        workDay: Record<string, unknown>;
+        prioritySnapshot: import("@treeseed/sdk").PrioritySnapshot;
+        seededTasks: {
+            [x: string]: unknown;
+        }[];
+        queuedCount: number;
+        activeLeases: number;
+        desiredWorkers: number;
+        scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
+        workdaySummary: Record<string, unknown>;
+    };
+    closed: {
+        ok: boolean;
+        mode: "reconcile";
+        managerId: string;
+        projectId: string;
+        environment: "local" | "prod" | "staging";
+        insideWorkWindow: boolean;
+        workPolicy: import("@treeseed/sdk").WorkdayPolicy;
+        workDay: Record<string, unknown>;
+        prioritySnapshot: import("@treeseed/sdk").PrioritySnapshot;
+        seededTasks: {
+            [x: string]: unknown;
+        }[];
+        queuedCount: number;
+        activeLeases: number;
+        desiredWorkers: number;
+        scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
+        workdaySummary: Record<string, unknown>;
+    } | {
+        ok: boolean;
+        created: boolean;
+        workDay: Record<string, unknown>;
+        skipped?: undefined;
+        reason?: undefined;
+        prioritySnapshot?: undefined;
+    } | {
+        ok: boolean;
+        created: boolean;
+        skipped: boolean;
+        reason: string;
+        workDay?: undefined;
+        prioritySnapshot?: undefined;
+    } | {
+        ok: boolean;
+        created: boolean;
+        workDay: import("@treeseed/sdk").SdkWorkDayEntity;
+        prioritySnapshot: import("@treeseed/sdk").PrioritySnapshot;
+        skipped?: undefined;
+        reason?: undefined;
+    } | {
+        ok: boolean;
+        skipped: boolean;
+        reason: string;
+        workDay?: undefined;
+        summary?: undefined;
+        scale?: undefined;
+    } | {
+        ok: boolean;
+        workDay: import("@treeseed/sdk").SdkWorkDayEntity;
+        summary: {
+            contentSnapshot: {
+                relativePath: string;
+                slug: string;
+                reportVersion: string;
+                title: string;
+            };
+            capacity: {
+                providerSplit: any;
+                grantedDailyCredits: number;
+                reservedCredits: number;
+                consumedCredits: number;
+                remainingDailyCredits: number | null;
+                providerCount: number;
+                laneCount: number;
+                grantCount: number;
+            };
+            projectId: string;
+            environment: "local" | "prod" | "staging";
+            workDayId: string;
+            state: string;
+            totalTasks: number;
+            completedTasks: number;
+            failedTasks: number;
+            queuedTasks: number;
+            activeTasks: number;
+            dailyTaskCreditBudget: number;
+            usedTaskCredits: number;
+            remainingTaskCredits: number;
+            creditLedgerEntries: number;
+            prioritySnapshotId: string;
+            priorityItemCount: number;
+            priorityItems: import("@treeseed/sdk").PrioritySnapshotItem[];
+            taskItems: {
+                id: string;
+                agentId: string;
+                type: string;
+                state: string;
+                priority: number;
+                idempotencyKey: string;
+                createdAt: string;
+                startedAt: string;
+                completedAt: string;
+                lastErrorCode: string;
+                lastErrorMessage: string;
+                lastEventKind: string;
+                outputCount: number;
+                changedFiles: string[];
+            }[];
+            changedFiles: string[];
+            releases: {
+                id: string;
+                deploymentKind: string;
+                status: string;
+                releaseTag: string;
+                commitSha: string;
+                sourceRef: string;
+                startedAt: string;
+                finishedAt: string;
+                createdAt: string;
+            }[];
+            scaleDecision: import("@treeseed/sdk").ScaleDecision;
+            scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
+            generatedAt: string;
+        };
+        scale: import("@treeseed/sdk").WorkerPoolScaleResult;
+        skipped?: undefined;
+        reason?: undefined;
+    } | {
+        ok: boolean;
+        skipped: boolean;
+        reason: string;
+        workDayId?: undefined;
+        summary?: undefined;
+    } | {
+        ok: boolean;
+        workDayId: unknown;
+        summary: {
+            contentSnapshot: {
+                relativePath: string;
+                slug: string;
+                reportVersion: string;
+                title: string;
+            };
+            capacity: {
+                providerSplit: any;
+                grantedDailyCredits: number;
+                reservedCredits: number;
+                consumedCredits: number;
+                remainingDailyCredits: number | null;
+                providerCount: number;
+                laneCount: number;
+                grantCount: number;
+            };
+            projectId: string;
+            environment: "local" | "prod" | "staging";
+            workDayId: string;
+            state: string;
+            totalTasks: number;
+            completedTasks: number;
+            failedTasks: number;
+            queuedTasks: number;
+            activeTasks: number;
+            dailyTaskCreditBudget: number;
+            usedTaskCredits: number;
+            remainingTaskCredits: number;
+            creditLedgerEntries: number;
+            prioritySnapshotId: string;
+            priorityItemCount: number;
+            priorityItems: import("@treeseed/sdk").PrioritySnapshotItem[];
+            taskItems: {
+                id: string;
+                agentId: string;
+                type: string;
+                state: string;
+                priority: number;
+                idempotencyKey: string;
+                createdAt: string;
+                startedAt: string;
+                completedAt: string;
+                lastErrorCode: string;
+                lastErrorMessage: string;
+                lastEventKind: string;
+                outputCount: number;
+                changedFiles: string[];
+            }[];
+            changedFiles: string[];
+            releases: {
+                id: string;
+                deploymentKind: string;
+                status: string;
+                releaseTag: string;
+                commitSha: string;
+                sourceRef: string;
+                startedAt: string;
+                finishedAt: string;
+                createdAt: string;
+            }[];
+            scaleDecision: import("@treeseed/sdk").ScaleDecision;
+            scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
+            generatedAt: string;
+        };
+        skipped?: undefined;
+        reason?: undefined;
+    };
+    skipped?: undefined;
+    reason?: undefined;
+}>;
+export {};