@treeseed/core 0.6.37 → 0.6.39

package/dist/services/worker.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { AgentKernel } from "../agents/kernel/agent-kernel.js";
+import { createControlPlaneReporter } from "@treeseed/sdk";
 import { buildTaskContext, createQueueClient, createServiceSdk, resolveServiceRepoRoot, resolveWorkerConfig } from "./common.js";
 function parseTaskPayload(task) {
   const raw = typeof task?.payloadJson === "string" ? task.payloadJson : "{}";
@@ -10,11 +13,114 @@ function parseTaskPayload(task) {
     return {};
   }
 }
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readCapacityEnvelope(payload) {
+  const envelope = asRecord(payload.capacityEnvelope);
+  return Object.keys(envelope).length > 0 ? envelope : null;
+}
+function runnerRepositoryPath(volumeRoot, repositoryId, taskId) {
+  const repositoryRoot = join(volumeRoot, "repositories", repositoryId);
+  return {
+    repositoryRoot,
+    bareGit: join(repositoryRoot, "bare.git"),
+    worktree: join(repositoryRoot, "worktrees", taskId)
+  };
+}
+class WorkerPausedForApproval extends Error {
+  constructor(request) {
+    super(String(request.summary ?? request.title ?? "Task paused for approval."));
+    this.request = request;
+  }
+  request;
+}
 async function executeQueuedTask(options) {
   const context = await buildTaskContext(options.sdk, options.taskId);
   const task = context.task;
   const payload = parseTaskPayload(task);
+  const capacityEnvelope = readCapacityEnvelope(payload);
+  const explicitApproval = asRecord(payload.approvalRequest);
+  if (Object.keys(explicitApproval).length > 0 || capacityEnvelope?.maxCredits === 0) {
+    throw new WorkerPausedForApproval({
+      kind: String(explicitApproval.kind ?? "capacity_boundary"),
+      title: String(explicitApproval.title ?? "Task paused for approval"),
+      summary: String(explicitApproval.summary ?? "The task reached a boundary outside its approved execution envelope."),
+      severity: explicitApproval.severity ?? "medium",
+      workDayId: task?.workDayId ?? task?.work_day_id ?? null,
+      taskId: options.taskId,
+      options: Array.isArray(explicitApproval.options) ? explicitApproval.options : [],
+      recommendation: asRecord(explicitApproval.recommendation),
+      policySnapshot: {
+        capacityEnvelope,
+        ...asRecord(explicitApproval.policySnapshot)
+      }
+    });
+  }
   const executionKind = typeof payload.executionKind === "string" ? payload.executionKind : null;
+  if (String(task?.type ?? task?.taskType ?? "") === "refresh_project_graph") {
+    const config = resolveWorkerConfig();
+    const projectId = typeof payload.projectId === "string" ? payload.projectId : config.projectId;
+    const repositoryId = typeof payload.repositoryId === "string" ? payload.repositoryId : projectId;
+    const paths = runnerRepositoryPath(config.volumeRoot, repositoryId, options.taskId);
+    await mkdir(paths.bareGit, { recursive: true });
+    await mkdir(paths.worktree, { recursive: true });
+    const graphRefresh = await options.sdk.refreshGraph();
+    const graphVersion = graphRefresh.snapshotRoot;
+    await options.sdk.create({
+      model: "graph_run",
+      data: {
+        id: `${options.taskId}:graph`,
+        workDayId: String(task?.workDayId ?? task?.work_day_id ?? ""),
+        corpusHash: graphVersion,
+        graphVersion,
+        statsJson: JSON.stringify(graphRefresh),
+        snapshotRef: graphVersion
+      },
+      actor: "worker"
+    });
+    if (typeof options.sdk.updateWorkDayGraph === "function") {
+      await options.sdk.updateWorkDayGraph({
+        id: String(task?.workDayId ?? task?.work_day_id ?? ""),
+        graphVersion,
+        summaryPatch: {
+          graphRefresh: {
+            state: "completed",
+            graphVersion,
+            snapshotRef: graphVersion,
+            runnerId: config.workerId
+          }
+        }
+      });
+    }
+    if (typeof options.sdk.recordRepositoryClaim === "function") {
+      await options.sdk.recordRepositoryClaim({
+        projectId,
+        repositoryId,
+        runnerId: config.workerId,
+        runnerServiceName: config.runnerServiceName,
+        volumeIdentity: config.volumeIdentity,
+        lastSeenCommit: typeof payload.commitSha === "string" ? payload.commitSha : null,
+        metadata: {
+          bareGit: paths.bareGit,
+          worktree: paths.worktree
+        }
+      });
+    }
+    return {
+      workerId: options.workerId,
+      queueAttempt: options.queueAttempt,
+      graphVersion,
+      snapshotRef: graphVersion,
+      repositoryId,
+      paths,
+      summary: {
+        status: "completed",
+        workerId: options.workerId,
+        summary: `Refreshed project graph ${graphVersion}`
+      }
+    };
+  }
   if (executionKind === "workflow_dispatch" || executionKind === "sdk_dispatch") {
     const namespace = typeof payload.namespace === "string" ? payload.namespace : "workflow";
     const operation = typeof payload.operation === "string" ? payload.operation : "";
@@ -57,7 +163,14 @@ async function executeQueuedTask(options) {
       status: agentResult.status,
       workerId: options.workerId,
       summary: agentResult.summary
-    }
+    },
+    capacityUsage: capacityEnvelope?.providerId && capacityEnvelope?.laneId ? {
+      capacityProviderId: capacityEnvelope.providerId,
+      laneId: capacityEnvelope.laneId,
+      reservationId: capacityEnvelope.reservationIds?.[0] ?? null,
+      credits: Number(payload.estimatedCredits ?? capacityEnvelope.maxCredits ?? 1),
+      source: "worker"
+    } : null
   };
 }
 async function runWorkerCycle() {
@@ -65,6 +178,21 @@ async function runWorkerCycle() {
   const queue = createQueueClient();
   const config = resolveWorkerConfig();
   const kernel = new AgentKernel(sdk, resolveServiceRepoRoot());
+  if (typeof sdk.recordWorkerRunner === "function") {
+    await sdk.recordWorkerRunner({
+      projectId: config.projectId,
+      environment: config.environment,
+      runnerId: config.workerId,
+      runnerServiceName: config.runnerServiceName,
+      volumeIdentity: config.volumeIdentity,
+      state: "active",
+      maxLocalWorkers: config.maxLocalWorkers,
+      activeLocalWorkers: 0,
+      metadata: {
+        volumeRoot: config.volumeRoot
+      }
+    }).catch(() => null);
+  }
   if (!queue) {
     if (process.env.TREESEED_LOCAL_DEV_MODE?.trim()) {
       return { ok: true, processed: 0, idle: true, reason: "queue_unconfigured" };
@@ -78,8 +206,9 @@ async function runWorkerCycle() {
   if (pulled.messages.length === 0) {
     return { ok: true, processed: 0 };
   }
-  let processed = 0;
-  for (const message of pulled.messages) {
+  const maxLocalWorkers = Number.isFinite(Number(config.maxLocalWorkers)) ? Math.max(1, Number(config.maxLocalWorkers)) : 1;
+  const selectedMessages = pulled.messages.slice(0, maxLocalWorkers);
+  const results = await Promise.all(selectedMessages.map(async (message) => {
     try {
       await sdk.claimTask({
         id: message.body.taskId,
@@ -97,21 +226,78 @@ async function runWorkerCycle() {
         },
         actor: "worker"
       });
-      const output = await executeQueuedTask({
-        sdk,
-        kernel,
-        taskId: message.body.taskId,
-        workerId: config.workerId,
-        queueAttempt: message.attempts
-      });
+      let output;
+      try {
+        output = await executeQueuedTask({
+          sdk,
+          kernel,
+          taskId: message.body.taskId,
+          workerId: config.workerId,
+          queueAttempt: message.attempts
+        });
+      } catch (error) {
+        if (error instanceof WorkerPausedForApproval) {
+          const reporter = createControlPlaneReporter();
+          const context = await buildTaskContext(sdk, message.body.taskId);
+          const task = context.task;
+          const projectId = String(process.env.TREESEED_PROJECT_ID ?? "");
+          await reporter.createApprovalRequest({
+            projectId,
+            teamId: String(error.request.teamId ?? process.env.TREESEED_TEAM_ID ?? ""),
+            workDayId: typeof error.request.workDayId === "string" ? error.request.workDayId : String(task?.workDayId ?? task?.work_day_id ?? ""),
+            taskId: message.body.taskId,
+            kind: String(error.request.kind ?? "capacity_boundary"),
+            severity: error.request.severity === "high" || error.request.severity === "low" ? error.request.severity : "medium",
+            requestedByType: "worker",
+            requestedById: config.workerId,
+            title: String(error.request.title ?? "Task paused for approval"),
+            summary: String(error.request.summary ?? error.message),
+            options: Array.isArray(error.request.options) ? error.request.options : [],
+            recommendation: asRecord(error.request.recommendation),
+            policySnapshot: asRecord(error.request.policySnapshot)
+          }).catch(() => null);
+          await sdk.recordTaskProgress({
+            id: message.body.taskId,
+            workerId: config.workerId,
+            state: "paused_for_approval",
+            appendEvent: {
+              kind: "paused_for_approval",
+              data: error.request
+            },
+            actor: "worker"
+          });
+          await queue.ack([message.leaseId]);
+          return 1;
+        }
+        throw error;
+      }
       await sdk.completeTask({
         id: message.body.taskId,
         output,
         summary: output.summary,
         actor: "worker"
       });
+      if (output.capacityUsage?.capacityProviderId && output.capacityUsage?.laneId) {
+        const reporter = createControlPlaneReporter();
+        await reporter.reportCapacityUsage({
+          capacityProviderId: output.capacityUsage.capacityProviderId,
+          laneId: output.capacityUsage.laneId,
+          reservationId: output.capacityUsage.reservationId,
+          teamId: String(process.env.TREESEED_TEAM_ID ?? ""),
+          projectId: String(process.env.TREESEED_PROJECT_ID ?? ""),
+          workDayId: message.body.workDayId,
+          taskId: message.body.taskId,
+          phase: "consume",
+          credits: output.capacityUsage.credits,
+          source: "worker",
+          metadata: {
+            workerId: config.workerId,
+            queueAttempt: message.attempts
+          }
+        }).catch(() => null);
+      }
       await queue.ack([message.leaseId]);
-      processed += 1;
+      return 1;
     } catch (error) {
       const retryDelaySeconds = Math.min(300, Math.max(15, message.attempts * 30));
       await sdk.failTask({
@@ -122,15 +308,62 @@ async function runWorkerCycle() {
         actor: "worker"
       }).catch(() => null);
       await queue.retry([{ leaseId: message.leaseId, delaySeconds: retryDelaySeconds }]);
+      return 0;
     }
+  }));
+  return { ok: true, processed: results.reduce((sum, value) => sum + value, 0) };
+}
+function shouldExitWorkerLoopAfterIdle(options) {
+  const idleExitMs = Number(options.idleExitMs ?? 0);
+  if (!Number.isFinite(idleExitMs) || idleExitMs <= 0) {
+    return false;
   }
-  return { ok: true, processed };
+  if (options.processed > 0 || options.idleSince === null) {
+    return false;
+  }
+  return options.now - options.idleSince >= idleExitMs;
+}
+async function recordWorkerLoopExitState(config) {
+  const sdk = createServiceSdk();
+  if (typeof sdk.recordWorkerRunner !== "function") {
+    return;
+  }
+  await sdk.recordWorkerRunner({
+    projectId: config.projectId,
+    environment: config.environment,
+    runnerId: config.workerId,
+    runnerServiceName: config.runnerServiceName,
+    volumeIdentity: config.volumeIdentity,
+    state: "sleeping",
+    maxLocalWorkers: config.maxLocalWorkers,
+    activeLocalWorkers: 0,
+    metadata: {
+      volumeRoot: config.volumeRoot,
+      reason: "idle_exit"
+    }
+  }).catch(() => null);
 }
 async function startWorkerLoop() {
   const config = resolveWorkerConfig();
+  let idleSince = null;
   for (; ; ) {
     try {
-      await runWorkerCycle();
+      const result = await runWorkerCycle();
+      const processed = Number(result.processed ?? 0);
+      if (processed > 0) {
+        idleSince = null;
+      } else {
+        idleSince ??= Date.now();
+        if (shouldExitWorkerLoopAfterIdle({
+          idleExitMs: config.idleExitMs,
+          idleSince,
+          now: Date.now(),
+          processed
+        })) {
+          await recordWorkerLoopExitState(config);
+          return;
+        }
+      }
     } catch (error) {
       process.stderr.write(`${error instanceof Error ? error.message : String(error)}
 `);
@@ -145,5 +378,6 @@ if (entryFile === currentFile) {
 }
 export {
   runWorkerCycle,
+  shouldExitWorkerLoopAfterIdle,
   startWorkerLoop
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/core",
-  "version": "0.6.37",
+  "version": "0.6.39",
   "description": "Treeseed integrated platform starter for Astro/Starlight web runtimes and Hono API runtimes.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -42,12 +42,14 @@
     "dev": "node ./scripts/run-ts.mjs ./scripts/dev-platform.ts",
     "dev:web": "node ./scripts/run-ts.mjs ./scripts/dev-platform.ts --surface web",
     "dev:api": "node ./scripts/run-ts.mjs ./scripts/dev-platform.ts --surface api",
-    "dev:manager": "node ./scripts/run-ts.mjs ./src/services/manager.ts",
-    "dev:worker": "node ./scripts/run-ts.mjs ./src/services/worker.ts",
+    "dev:workday-manager": "node ./scripts/run-ts.mjs ./src/services/workday-manager.ts",
+    "dev:worker-runner": "node ./scripts/run-ts.mjs ./src/services/worker.ts",
+    "dev:manager": "npm run dev:workday-manager",
+    "dev:worker": "npm run dev:worker-runner",
     "dev:agents": "node ./scripts/run-ts.mjs ./src/services/agents.ts",
     "dev:remote-runner": "node ./scripts/run-ts.mjs ./src/services/remote-runner.ts",
-    "dev:workday-start": "node ./scripts/run-ts.mjs ./src/services/workday-start.ts",
-    "dev:workday-report": "node ./scripts/run-ts.mjs ./src/services/workday-report.ts",
+    "dev:workday-start": "npm run dev:workday-manager",
+    "dev:workday-report": "npm run dev:workday-manager",
     "dev:watch": "node ./scripts/run-ts.mjs ./scripts/dev-platform.ts --watch",
     "starlight:patch": "node ./scripts/run-ts.mjs ./scripts/patch-starlight-content-path.ts",
     "precheck": "npm run starlight:patch",
@@ -76,7 +78,7 @@
     "@astrojs/sitemap": "3.7.0",
     "@astrojs/starlight": "0.37.6",
     "@tailwindcss/vite": "^4.1.4",
-    "@treeseed/sdk": "0.6.38",
+    "@treeseed/sdk": "0.6.40",
     "astro": "^5.6.1",
     "esbuild": "^0.28.0",
     "hono": "^4.8.2",
@@ -187,6 +189,10 @@
       "types": "./dist/services/remote-runner.d.ts",
       "default": "./dist/services/remote-runner.js"
     },
+    "./services/workday-manager": {
+      "types": "./dist/services/workday-manager.d.ts",
+      "default": "./dist/services/workday-manager.js"
+    },
     "./services/workday-start": {
       "types": "./dist/services/workday-start.d.ts",
       "default": "./dist/services/workday-start.js"