@treeseed/core 0.4.13 → 0.5.2

package/dist/pages/questions/index.astro

@@ -3,9 +3,26 @@ import MainLayout from '../../layouts/MainLayout.astro';
 import SectionIntro from '../../components/site/SectionIntro.astro';
 import ChronicleList from '../../components/site/ChronicleList.astro';
 import { getPublishedQuestions, resolveContributorsForEntries } from '../../utils/hub-content';
+import { isPublishedRuntimeContentMode, loadPublishedCollection, resolvePublishedContributor, metadataFromPublishedContent, loadPublishedEntry } from '../../utils/site-content-runtime';
 
-const questions = await getPublishedQuestions();
-const contributors = await resolveContributorsForEntries(questions);
+const publishedRuntime = isPublishedRuntimeContentMode();
+const questions = publishedRuntime
+	? (await loadPublishedCollection(Astro.locals, 'questions')).sort((a, b) => b.data.date.valueOf() - a.data.date.valueOf())
+	: await getPublishedQuestions();
+const contributors = publishedRuntime
+	? new Map(
+		await Promise.all(
+			questions.map(async (question) => {
+				const detail = await loadPublishedEntry(Astro.locals, 'questions', question.id);
+				const contributor = await resolvePublishedContributor(
+					Astro.locals,
+					metadataFromPublishedContent(detail?.content)?.primaryContributor,
+				);
+				return [question.id, contributor ?? null] as const;
+			}),
+		),
+	)
+	: await resolveContributorsForEntries(questions);
 ---
 
 <MainLayout title="Questions" description="Open questions guiding the TreeSeed working site." currentPath="/questions/">

package/dist/scripts/dev-platform.js

@@ -16,7 +16,6 @@ function parseSurface(value) {
         || value === 'api'
         || value === 'manager'
         || value === 'worker'
-        || value === 'agents'
         || value === 'services'
         || value === 'integrated') {
         return value;

package/dist/scripts/release-verify.js

@@ -9,9 +9,9 @@ const forbiddenPatterns = [
     /['"`](?:\.\.\/|\.\/)[^'"`\n]*src\/[^'"`\n]*\.(?:[cm]?js|ts|tsx|json|astro|css)['"`]/,
     /['"`][^'"`\n]*\/packages\/[^'"`\n]*\/src\/[^'"`\n]*['"`]/,
 ];
-function run(command, args) {
+function run(command, args, cwd = packageRoot) {
     const result = spawnSync(command, args, {
-        cwd: packageRoot,
+        cwd,
         stdio: 'inherit',
         env: process.env,
     });
@@ -19,6 +19,32 @@ function run(command, args) {
         process.exit(result.status ?? 1);
     }
 }
+function assertNoLocalDependencyLinks() {
+    const packageJson = JSON.parse(readFileSync(resolve(packageRoot, 'package.json'), 'utf8'));
+    for (const sectionName of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+        for (const [dependencyName, version] of Object.entries(packageJson[sectionName] ?? {})) {
+            if (version.startsWith('workspace:') || version.startsWith('file:')) {
+                throw new Error(`package.json ${sectionName}.${dependencyName} must not use local dependency specifiers: ${version}`);
+            }
+        }
+    }
+    const lockfile = JSON.parse(readFileSync(resolve(packageRoot, 'package-lock.json'), 'utf8'));
+    for (const [entryKey, entryValue] of Object.entries(lockfile.packages ?? {})) {
+        if (entryKey.startsWith('../') || entryKey.includes('/../')) {
+            throw new Error(`package-lock.json contains forbidden local package entry: ${entryKey}`);
+        }
+        if (entryValue.link) {
+            throw new Error(`package-lock.json contains forbidden linked dependency entry: ${entryKey}`);
+        }
+        const resolved = entryValue.resolved ?? '';
+        if (resolved.startsWith('../')
+            || resolved.startsWith('./')
+            || resolved.startsWith('file:')
+            || resolved.startsWith('workspace:')) {
+            throw new Error(`package-lock.json contains forbidden local resolution for ${entryKey}: ${resolved}`);
+        }
+    }
+}
 function walkFiles(root) {
     const files = [];
     for (const entry of readdirSync(root, { withFileTypes: true })) {
@@ -43,6 +69,7 @@ function scanDirectory(root) {
         }
     }
 }
+assertNoLocalDependencyLinks();
 run('npm', ['run', 'lint']);
 scanDirectory(resolve(packageRoot, 'dist'));
 run('npm', ['run', 'test:unit']);

package/dist/scripts/tenant-build.js

@@ -1,7 +1,10 @@
 import { astroBin, createProductionBuildEnv, packageScriptPath, runNodeBinary, runNodeScript } from './package-tools.js';
 process.env.TREESEED_LOCAL_DEV_MODE = process.env.TREESEED_LOCAL_DEV_MODE ?? 'cloudflare';
+const publishedRuntime = process.env.TREESEED_CONTENT_SERVING_MODE === 'published_runtime';
 runNodeScript(packageScriptPath('patch-starlight-content-path'), [], { cwd: process.cwd() });
-runNodeScript(packageScriptPath('aggregate-book'), [], { cwd: process.cwd() });
+if (!publishedRuntime) {
+    runNodeScript(packageScriptPath('aggregate-book'), [], { cwd: process.cwd() });
+}
 runNodeBinary(astroBin, ['build'], {
     cwd: process.cwd(),
     env: createProductionBuildEnv({

package/dist/scripts/tenant-check.js

@@ -1,6 +1,9 @@
 import { createProductionBuildEnv, packageScriptPath, runNodeScript } from './package-tools.js';
+const publishedRuntime = process.env.TREESEED_CONTENT_SERVING_MODE === 'published_runtime';
 runNodeScript(packageScriptPath('patch-starlight-content-path'), [], { cwd: process.cwd() });
-runNodeScript(packageScriptPath('aggregate-book'), [], { cwd: process.cwd() });
+if (!publishedRuntime) {
+    runNodeScript(packageScriptPath('aggregate-book'), [], { cwd: process.cwd() });
+}
 runNodeScript(packageScriptPath('tenant-build'), [], {
     cwd: process.cwd(),
     env: createProductionBuildEnv(),

package/dist/services/agents.d.ts

@@ -1,22 +1,11 @@
 #!/usr/bin/env node
 export declare function resolveAgentsServiceConfig(): {
     serviceName: string;
-    marketBaseUrl: string;
-    projectId: string;
-    runnerToken: string;
-    runnerId: string;
-    batchSize: number;
     pollIntervalMs: number;
 };
 export declare function runAgentsCycle(): Promise<{
     ok: boolean;
     processed: number;
-    idle: boolean;
-    reason: string;
-} | {
-    ok: boolean;
-    processed: number;
-    idle?: undefined;
-    reason?: undefined;
+    results: any[];
 }>;
 export declare function startAgentsLoop(): Promise<void>;

package/dist/services/agents.js

@@ -1,21 +1,40 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
-import { runRemoteRunnerCycle, startRemoteRunnerLoop, resolveRemoteRunnerConfig } from "./remote-runner.js";
+import { AgentKernel } from "../agents/kernel/agent-kernel.js";
+import { createServiceSdk, resolveServiceRepoRoot } from "./common.js";
+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 resolveAgentsServiceConfig() {
   return {
-    ...resolveRemoteRunnerConfig(),
-    serviceName: process.env.TREESEED_AGENTS_SERVICE_NAME?.trim() || "agents"
+    serviceName: process.env.TREESEED_AGENTS_SERVICE_NAME?.trim() || "agents",
+    pollIntervalMs: integerFromEnv("TREESEED_AGENTS_POLL_INTERVAL_MS", 3e4)
   };
 }
 async function runAgentsCycle() {
-  return runRemoteRunnerCycle({
-    config: resolveAgentsServiceConfig()
-  });
+  const sdk = createServiceSdk();
+  const kernel = new AgentKernel(sdk, resolveServiceRepoRoot());
+  const results = await kernel.runCycle();
+  return {
+    ok: true,
+    processed: results.length,
+    results
+  };
 }
 async function startAgentsLoop() {
-  return startRemoteRunnerLoop({
-    config: resolveAgentsServiceConfig()
-  });
+  const config = resolveAgentsServiceConfig();
+  for (; ; ) {
+    try {
+      await runAgentsCycle();
+    } catch (error) {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, config.pollIntervalMs));
+  }
 }
 const currentFile = fileURLToPath(import.meta.url);
 const entryFile = process.argv[1] ?? "";

package/dist/services/index.d.ts

@@ -1,7 +1,5 @@
 export { runManagerAction, runManagerCycle, startManagerLoop } from './manager.ts';
 export { runWorkerCycle, startWorkerLoop } from './worker.ts';
-export { runRemoteRunnerCycle, startRemoteRunnerLoop } from './remote-runner.ts';
-export { runAgentsCycle, startAgentsLoop } from './agents.ts';
 export { runWorkdayStart } from './workday-start.ts';
 export { runWorkdayReport } from './workday-report.ts';
 export { createWorkerPoolScaler, RailwayWorkerPoolScaler, NoopWorkerPoolScaler } from './worker-pool-scaler.ts';

package/dist/services/index.js

@@ -1,7 +1,5 @@
 import { runManagerAction, runManagerCycle, startManagerLoop } from "./manager.js";
 import { runWorkerCycle, startWorkerLoop } from "./worker.js";
-import { runRemoteRunnerCycle, startRemoteRunnerLoop } from "./remote-runner.js";
-import { runAgentsCycle, startAgentsLoop } from "./agents.js";
 import { runWorkdayStart } from "./workday-start.js";
 import { runWorkdayReport } from "./workday-report.js";
 import { createWorkerPoolScaler, RailwayWorkerPoolScaler, NoopWorkerPoolScaler } from "./worker-pool-scaler.js";
@@ -9,15 +7,11 @@ export {
   NoopWorkerPoolScaler,
   RailwayWorkerPoolScaler,
   createWorkerPoolScaler,
-  runAgentsCycle,
   runManagerAction,
   runManagerCycle,
-  runRemoteRunnerCycle,
   runWorkdayReport,
   runWorkdayStart,
   runWorkerCycle,
-  startAgentsLoop,
   startManagerLoop,
-  startRemoteRunnerLoop,
   startWorkerLoop
 };

package/dist/services/manager.d.ts

@@ -48,7 +48,7 @@ export declare function runManagerAction(options?: {
     mode: "reconcile";
     managerId: string;
     projectId: string;
-    environment: "local" | "prod" | "staging";
+    environment: "local" | "staging" | "prod";
     insideWorkWindow: boolean;
     workPolicy: WorkdayPolicy;
     workDay: Record<string, unknown>;
@@ -98,7 +98,7 @@ export declare function runManagerAction(options?: {
             title: string;
         };
         projectId: string;
-        environment: "local" | "prod" | "staging";
+        environment: "local" | "staging" | "prod";
         workDayId: string;
         state: string;
         totalTasks: number;
@@ -165,7 +165,7 @@ export declare function runManagerAction(options?: {
             title: string;
         };
         projectId: string;
-        environment: "local" | "prod" | "staging";
+        environment: "local" | "staging" | "prod";
         workDayId: string;
         state: string;
         totalTasks: number;
@@ -226,7 +226,7 @@ export declare function runManagerCycle(options?: {
     mode: "reconcile";
     managerId: string;
     projectId: string;
-    environment: "local" | "prod" | "staging";
+    environment: "local" | "staging" | "prod";
     insideWorkWindow: boolean;
     workPolicy: WorkdayPolicy;
     workDay: Record<string, unknown>;

package/dist/services/manager.js

@@ -3,7 +3,15 @@ import { fileURLToPath } from "node:url";
 import {
   createControlPlaneReporter
 } 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 {
+  applyInteractiveWakeUpOverride,
+  applyScaleCooldown,
+  collectTaskMetrics,
+  computeDesiredWorkerCount
+} from "./worker-capacity.js";
 import { writeWorkdayContentSnapshot } from "./workday-content.js";
 import { createWorkerPoolScaler } from "./worker-pool-scaler.js";
 const DEFAULT_WORK_DAYS = [1, 2, 3, 4, 5];
@@ -167,6 +175,9 @@ function readDate(record, ...keys) {
   const parsed = new Date(raw);
   return Number.isFinite(parsed.valueOf()) ? parsed : null;
 }
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
 function parseJsonString(value, fallback = {}) {
   if (typeof value !== "string" || !value.trim()) {
     return fallback;
@@ -491,34 +502,6 @@ async function openWorkday(sdk, config, policy, now) {
   });
   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;
@@ -531,7 +514,7 @@ 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");
+      const type = typeof trigger === "string" ? trigger : readString(asRecord(trigger), "type");
       return type === "startup" || type === "schedule";
     });
   });
@@ -640,31 +623,107 @@ async function topUpQueuedTasks(sdk, config, policy, workDay, snapshot, now) {
     remainingCredits: availableCredits
   };
 }
-function desiredWorkersForSnapshot(policy, metrics) {
-  const { minWorkers, maxWorkers, targetQueueDepth } = policy.autoscale;
-  if (metrics.queuedCount <= 0 && metrics.activeLeases <= 0) {
-    return minWorkers;
+function parseCursorTimestamp(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return void 0;
+  }
+  const timestamp = new Date(value).valueOf();
+  return Number.isFinite(timestamp) ? timestamp : void 0;
+}
+function triggerPriority(invocation) {
+  switch (invocation.kind) {
+    case "message":
+      return 90;
+    case "follow":
+      return 80;
+    case "startup":
+      return 70;
+    case "schedule":
+    case "manual":
+    default:
+      return 60;
   }
-  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;
+function triggerTaskIdempotencyKey(workDayId, agent, invocation) {
+  if (invocation.kind === "message" && invocation.message?.id) {
+    return `${workDayId}:trigger:${agent.slug}:message:${invocation.message.id}`;
   }
-  if (nextDesired >= latestDecision.desiredWorkers) {
-    return nextDesired;
+  if (invocation.kind === "follow") {
+    return `${workDayId}:trigger:${agent.slug}:follow:${followCursorKey(invocation.followModels)}:${invocation.cursorValue ?? "none"}`;
   }
-  const cooldownMs = Math.max(0, policy.autoscale.cooldownSeconds) * 1e3;
-  if (cooldownMs === 0) {
-    return nextDesired;
+  const triggerKey = readString(
+    asRecord(invocation.trigger),
+    "name",
+    "type"
+  ) || invocation.kind;
+  return `${workDayId}:trigger:${agent.slug}:${invocation.kind}:${triggerKey}`;
+}
+async function materializeAgentTriggerTasks(sdk, workDay, now) {
+  const workDayId = String(workDay.id ?? "");
+  if (!workDayId) {
+    return [];
+  }
+  const [{ specs, diagnostics }, existingTasksEnvelope] = await Promise.all([
+    loadActiveAgentSpecs(sdk),
+    sdk.searchTasks({ workDayId, limit: 1e3 })
+  ]);
+  const errors = diagnostics.filter((entry) => entry.severity === "error");
+  if (errors.length > 0) {
+    throw new Error(
+      `Agent spec validation failed: ${errors.map((entry) => `${entry.slug}:${entry.field}:${entry.message}`).join(" | ")}`
+    );
   }
-  const lastChangedAt = new Date(latestDecision.createdAt);
-  if (!Number.isFinite(lastChangedAt.valueOf())) {
-    return nextDesired;
+  const existingKeys = new Set(
+    asRecords(existingTasksEnvelope.payload).map((task) => readString(task, "idempotencyKey", "idempotency_key"))
+  );
+  const createdTasks = [];
+  for (const agent of [...specs].sort((left, right) => left.slug.localeCompare(right.slug))) {
+    const scopedSdk = sdk.scopeForAgent(agent);
+    const lastRunAt = parseCursorTimestamp((await sdk.getCursor({
+      agentSlug: agent.slug,
+      cursorKey: "last_run_at"
+    })).payload);
+    const runsThisCycle = agent.triggerPolicy?.maxRunsPerCycle ?? 1;
+    for (let index = 0; index < runsThisCycle; index += 1) {
+      const decision = await resolveTriggerDecision({
+        agent,
+        mode: "auto",
+        isRunning: false,
+        lastRunAt,
+        sdk: scopedSdk
+      });
+      if (decision.kind !== "ready" || !decision.invocation) {
+        break;
+      }
+      const invocation = decision.invocation;
+      const idempotencyKey = triggerTaskIdempotencyKey(workDayId, agent, invocation);
+      if (existingKeys.has(idempotencyKey)) {
+        continue;
+      }
+      const created = await sdk.createTask({
+        workDayId,
+        agentId: agent.slug,
+        type: "agent_trigger",
+        priority: triggerPriority(invocation),
+        idempotencyKey,
+        payload: {
+          executionKind: "agent_trigger",
+          agentSlug: agent.slug,
+          invocation,
+          createdAt: now.toISOString()
+        },
+        graphVersion: typeof workDay.graphVersion === "string" ? workDay.graphVersion : null,
+        actor: "manager"
+      });
+      if (!created.payload) {
+        continue;
+      }
+      await maybeEnqueueTask(sdk, created.payload);
+      createdTasks.push(created.payload);
+      existingKeys.add(idempotencyKey);
+    }
   }
-  return now.valueOf() - lastChangedAt.valueOf() < cooldownMs ? latestDecision.desiredWorkers : nextDesired;
+  return createdTasks;
 }
 async function registerHeartbeat(reporter, config, policy, desiredWorkers, metrics) {
   await reporter.registerAgentPoolHeartbeat({
@@ -878,10 +937,24 @@ async function reconcileManager(options) {
   if (activeWorkDay && insideWorkWindow && seedResult.remainingCredits > 0) {
     seedResult = await topUpQueuedTasks(sdk, config, policy, activeWorkDay, currentSnapshot, now);
   }
+  if (activeWorkDay && insideWorkWindow) {
+    const triggerTasks = await materializeAgentTriggerTasks(sdk, activeWorkDay, now);
+    if (triggerTasks.length > 0) {
+      seedResult = {
+        ...seedResult,
+        createdTasks: [...seedResult.createdTasks, ...triggerTasks]
+      };
+    }
+  }
   const metrics = await collectTaskMetrics(sdk, activeWorkDay ? String(activeWorkDay.id ?? "") : null);
-  const rawDesiredWorkers = activeWorkDay ? desiredWorkersForSnapshot(policy, metrics) : 0;
+  const rawDesiredWorkers = activeWorkDay ? computeDesiredWorkerCount(policy.autoscale, metrics) : 0;
   const latestScaleDecision = await sdk.getLatestScaleDecision(config.projectId, config.environment, config.poolName);
-  const desiredWorkers = applyScaleCooldown(policy, latestScaleDecision.payload, rawDesiredWorkers, now);
+  const desiredWorkers = applyInteractiveWakeUpOverride({
+    priorityClass: "background",
+    queuedCount: metrics.queuedCount,
+    currentWorkers: Number(latestScaleDecision.payload?.desiredWorkers ?? 0),
+    desiredWorkers: applyScaleCooldown(policy.autoscale, latestScaleDecision.payload, rawDesiredWorkers, now)
+  });
   const scaleDecision = {
     projectId: config.projectId,
     environment: config.environment,

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

@@ -4,7 +4,7 @@ export declare function runWorkdayReport(): Promise<{
     mode: "reconcile";
     managerId: string;
     projectId: string;
-    environment: "local" | "prod" | "staging";
+    environment: "local" | "staging" | "prod";
     insideWorkWindow: boolean;
     workPolicy: import("@treeseed/sdk").WorkdayPolicy;
     workDay: Record<string, unknown>;
@@ -56,7 +56,7 @@ export declare function runWorkdayReport(): Promise<{
             title: string;
         };
         projectId: string;
-        environment: "local" | "prod" | "staging";
+        environment: "local" | "staging" | "prod";
         workDayId: string;
         state: string;
         totalTasks: number;
@@ -123,7 +123,7 @@ export declare function runWorkdayReport(): Promise<{
             title: string;
         };
         projectId: string;
-        environment: "local" | "prod" | "staging";
+        environment: "local" | "staging" | "prod";
         workDayId: string;
         state: string;
         totalTasks: number;

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

@@ -4,7 +4,7 @@ export declare function runWorkdayStart(): Promise<{
     mode: "reconcile";
     managerId: string;
     projectId: string;
-    environment: "local" | "prod" | "staging";
+    environment: "local" | "staging" | "prod";
     insideWorkWindow: boolean;
     workPolicy: import("@treeseed/sdk").WorkdayPolicy;
     workDay: Record<string, unknown>;
@@ -56,7 +56,7 @@ export declare function runWorkdayStart(): Promise<{
             title: string;
         };
         projectId: string;
-        environment: "local" | "prod" | "staging";
+        environment: "local" | "staging" | "prod";
         workDayId: string;
         state: string;
         totalTasks: number;
@@ -123,7 +123,7 @@ export declare function runWorkdayStart(): Promise<{
             title: string;
         };
         projectId: string;
-        environment: "local" | "prod" | "staging";
+        environment: "local" | "staging" | "prod";
         workDayId: string;
         state: string;
         totalTasks: number;

package/dist/services/worker-capacity.d.ts

@@ -0,0 +1,58 @@
+import type { AgentPoolAutoscalePolicy, AgentSdk, ProjectEnvironmentName, ScaleDecision, WorkerPoolScaleResult, WorkerPoolScaler } from '@treeseed/sdk';
+export interface TaskMetricsSnapshot {
+    queuedTasks: Array<Record<string, unknown>>;
+    activeTasks: Array<Record<string, unknown>>;
+    queuedCount: number;
+    activeLeases: number;
+    queuedCredits: number;
+}
+export interface WorkerPoolIdentity {
+    projectId: string;
+    environment: ProjectEnvironmentName | 'local';
+    poolName: string;
+}
+export interface CapacityAssuranceResult {
+    ok: true;
+    taskId: string;
+    queued: true;
+    workerState: 'warm' | 'cold_starting';
+    desiredWorkers: number;
+    scaleApplied: boolean;
+    scaleReason: string;
+    scaleDecision: ScaleDecision;
+    scaleResult: WorkerPoolScaleResult;
+    metrics: TaskMetricsSnapshot;
+}
+export declare function resolveAutoscalePolicyFromEnv(): AgentPoolAutoscalePolicy;
+export declare function resolveWorkerPoolIdentityFromEnv(projectId?: string): WorkerPoolIdentity;
+export declare function computeDesiredWorkerCount(autoscale: AgentPoolAutoscalePolicy, metrics: Pick<TaskMetricsSnapshot, 'queuedCount' | 'activeLeases'>): number;
+export declare function applyScaleCooldown(autoscale: AgentPoolAutoscalePolicy, latestDecision: ScaleDecision | null, nextDesired: number, now: Date): number;
+export declare function applyInteractiveWakeUpOverride(options: {
+    priorityClass?: 'interactive' | 'background';
+    queuedCount: number;
+    currentWorkers: number;
+    desiredWorkers: number;
+}): number;
+export declare function collectTaskMetrics(sdk: AgentSdk, workDayId?: string | null): Promise<TaskMetricsSnapshot>;
+export declare function enqueueTaskAndEnsureCapacity(sdk: AgentSdk, request: {
+    taskId: string;
+    actor?: string;
+    queueName?: string;
+    deliveryDelaySeconds?: number;
+    priorityClass?: 'interactive' | 'background';
+    projectId?: string;
+    identity?: WorkerPoolIdentity;
+    autoscale?: AgentPoolAutoscalePolicy;
+    scaler?: WorkerPoolScaler;
+    now?: Date;
+    enqueueTask: (sdk: AgentSdk, request: {
+        taskId: string;
+        queueName?: string;
+        deliveryDelaySeconds?: number;
+        actor?: string;
+    }) => Promise<{
+        ok: boolean;
+        taskId: string;
+        queued: boolean;
+    }>;
+}): Promise<CapacityAssuranceResult>;