@treeseed/core 0.6.38 → 0.6.39

package/README.md

@@ -52,8 +52,8 @@ npm run dev
 npm run dev:web
 npm run dev:api
 npm run dev:worker
-npm run dev:workday-start
-npm run dev:workday-report
+npm run dev:workday-manager
+npm run dev:worker-runner
 npm run fixtures:check
 npm run build:dist
 npm run test:unit
@@ -67,7 +67,7 @@ What they do:
 - `dev`: starts the integrated Astro UI and Hono API local runtime from `core`
 - `dev:web`: starts only the Astro UI dev surface through the `core` runtime
 - `dev:api`: starts only the Hono API dev surface through the `core` runtime
-- `dev:worker`, `dev:workday-start`, `dev:workday-report`: start the worker-service entrypoints from `core`
+- `dev:workday-manager`, `dev:worker-runner`: start the scheduled manager and worker runner entrypoints from `core`
 - `fixtures:check`: verifies that the pinned shared fixture is initialized and usable
 - `build:dist`: builds the publishable `dist/` package output
 - `test:unit`: runs package unit tests with Vitest

package/dist/agent.d.ts

@@ -3,6 +3,7 @@ export { listTreeseedAgentCommands, renderTreeseedAgentHelp, runTreeseedAgentCli
 export { resolveAgentHandler, listRegisteredAgentHandlers } from './agents/registry.ts';
 export { resolveAgentRuntimeProviders } from './agent-runtime.ts';
 export { runWorkerCycle, startWorkerLoop } from './services/worker.ts';
+export { runScheduledWorkdayManager } from './services/workday-manager.ts';
 export { runWorkdayStart } from './services/workday-start.ts';
 export { runWorkdayReport } from './services/workday-report.ts';
 export { parseAgentMessagePayload, AGENT_MESSAGE_TYPES } from './agents/contracts/messages.ts';

package/dist/agent.js

@@ -3,6 +3,7 @@ import { listTreeseedAgentCommands, renderTreeseedAgentHelp, runTreeseedAgentCli
 import { resolveAgentHandler, listRegisteredAgentHandlers } from "./agents/registry.js";
 import { resolveAgentRuntimeProviders } from "./agent-runtime.js";
 import { runWorkerCycle, startWorkerLoop } from "./services/worker.js";
+import { runScheduledWorkdayManager } from "./services/workday-manager.js";
 import { runWorkdayStart } from "./services/workday-start.js";
 import { runWorkdayReport } from "./services/workday-report.js";
 import { parseAgentMessagePayload, AGENT_MESSAGE_TYPES } from "./agents/contracts/messages.js";
@@ -15,6 +16,7 @@ export {
   renderTreeseedAgentHelp,
   resolveAgentHandler,
   resolveAgentRuntimeProviders,
+  runScheduledWorkdayManager,
   runTreeseedAgentCli,
   runWorkdayReport,
   runWorkdayStart,

package/dist/agents/spec-normalizer.js

@@ -122,7 +122,77 @@ function normalizeExecution(value, diagnostics, slug) {
     cooldownSeconds: ensurePositiveNumber(next.cooldownSeconds, "execution.cooldownSeconds", diagnostics, slug, 30, true),
     leaseSeconds: ensurePositiveNumber(next.leaseSeconds, "execution.leaseSeconds", diagnostics, slug, 300),
     retryLimit: ensurePositiveNumber(next.retryLimit, "execution.retryLimit", diagnostics, slug, 3, true),
-    branchPrefix: ensureString(next.branchPrefix ?? "agent", "execution.branchPrefix", diagnostics, slug) || "agent"
+    branchPrefix: ensureString(next.branchPrefix ?? "agent", "execution.branchPrefix", diagnostics, slug) || "agent",
+    providerProfile: normalizeProviderProfile(next.providerProfile, diagnostics, slug)
+  };
+}
+function normalizeWeightedLaneList(value, field, diagnostics, slug) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    diagnostics.push({
+      severity: "error",
+      slug,
+      field,
+      message: `Expected ${field} to be an array.`
+    });
+    return [];
+  }
+  return value.flatMap((entry, index) => {
+    if (!isPlainObject(entry)) {
+      diagnostics.push({
+        severity: "error",
+        slug,
+        field: `${field}[${index}]`,
+        message: "Expected provider lane entry to be an object."
+      });
+      return [];
+    }
+    return [{
+      providerId: typeof entry.providerId === "string" ? entry.providerId : void 0,
+      provider: typeof entry.provider === "string" ? entry.provider : void 0,
+      laneId: typeof entry.laneId === "string" ? entry.laneId : void 0,
+      model: typeof entry.model === "string" ? entry.model : void 0,
+      modelClass: typeof entry.modelClass === "string" ? entry.modelClass : void 0,
+      weight: ensurePositiveNumber(entry.weight, `${field}[${index}].weight`, diagnostics, slug, 1, true),
+      reason: typeof entry.reason === "string" ? entry.reason : void 0,
+      maxQualityPenalty: typeof entry.maxQualityPenalty === "number" ? entry.maxQualityPenalty : void 0
+    }];
+  });
+}
+function normalizeProviderProfile(value, diagnostics, slug) {
+  if (value === void 0) return void 0;
+  if (!isPlainObject(value)) {
+    diagnostics.push({
+      severity: "error",
+      slug,
+      field: "execution.providerProfile",
+      message: "Expected execution.providerProfile to be an object."
+    });
+    return void 0;
+  }
+  const fallbackPolicy = typeof value.fallbackPolicy === "string" ? value.fallbackPolicy : "allow_substitution";
+  if (!["allow_substitution", "require_same_model_class", "fail_if_unavailable", "ask_for_approval"].includes(fallbackPolicy)) {
+    diagnostics.push({
+      severity: "error",
+      slug,
+      field: "execution.providerProfile.fallbackPolicy",
+      message: `Unsupported fallback policy "${String(value.fallbackPolicy)}".`
+    });
+  }
+  return {
+    requiredCapabilities: Array.isArray(value.requiredCapabilities) ? value.requiredCapabilities.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [],
+    preferredLanes: normalizeWeightedLaneList(value.preferredLanes, "execution.providerProfile.preferredLanes", diagnostics, slug),
+    acceptableFallbacks: normalizeWeightedLaneList(value.acceptableFallbacks, "execution.providerProfile.acceptableFallbacks", diagnostics, slug).map((entry) => ({
+      providerId: entry.providerId,
+      provider: entry.provider,
+      laneId: entry.laneId,
+      model: entry.model,
+      modelClass: entry.modelClass,
+      maxQualityPenalty: entry.maxQualityPenalty
+    })),
+    disallowedProviders: Array.isArray(value.disallowedProviders) ? value.disallowedProviders.filter((entry) => typeof entry === "string") : void 0,
+    disallowedRegions: Array.isArray(value.disallowedRegions) ? value.disallowedRegions.filter((entry) => typeof entry === "string") : void 0,
+    fallbackPolicy
   };
 }
 function normalizeOutputs(value, _diagnostics, _slug) {

package/dist/api/agent-routes.js

@@ -58,17 +58,7 @@ function registerAgentRoutes(app, options) {
   app.post(withPrefix(prefix, "/workdays/start"), async (c) => {
     const unauthorized = authorizeRequest(c, options);
     if (unauthorized) return unauthorized;
-    const body = await c.req.json().catch(() => ({}));
-    const graphRefresh = await options.sdk.refreshGraph();
-    const result = await options.sdk.startWorkDay({
-      id: typeof body.id === "string" ? body.id : void 0,
-      projectId: String(body.projectId ?? options.projectId ?? "treeseed-market"),
-      capacityBudget: body.capacityBudget === void 0 ? void 0 : Number(body.capacityBudget),
-      graphVersion: typeof body.graphVersion === "string" ? body.graphVersion : graphRefresh.snapshotRoot,
-      summary: body.summary ?? { graphRefresh },
-      actor: actor(body, defaultActor)
-    });
-    return c.json(result);
+    return jsonError(c, 410, "Starting workdays through /agent/workdays/start is deprecated. Use project workday policy and workday requests instead.");
   });
   app.post(withPrefix(prefix, "/workdays/:id/close"), async (c) => {
     const unauthorized = authorizeRequest(c, options);

package/dist/scripts/build-dist.js

@@ -8,6 +8,7 @@ const require = createRequire(import.meta.url);
 const srcRoot = resolve(packageRoot, 'src');
 const scriptsRoot = resolve(packageRoot, 'scripts');
 const distRoot = resolve(packageRoot, 'dist');
+const workspaceSdkDistRoot = resolve(packageRoot, '..', 'sdk', 'dist');
 const JS_SOURCE_EXTENSIONS = new Set(['.ts', '.ts']);
 const COPY_EXTENSIONS = new Set(['.astro', '.css', '.d.js', '.js', '.json', '.jsonc', '.ts', '.yaml', '.yml']);
 function walkFiles(root) {
@@ -202,6 +203,18 @@ function rewriteDeclarations() {
         writeFileSync(filePath, rewriteRuntimeSpecifiers(contents), 'utf8');
     }
 }
+function relativePathForTsconfig(fromRoot, targetPath) {
+    return relative(fromRoot, targetPath).replaceAll('\\', '/');
+}
+function resolveWorkspaceSdkDeclarationPaths() {
+    if (!existsSync(resolve(workspaceSdkDistRoot, 'index.d.ts'))) {
+        return null;
+    }
+    return {
+        '@treeseed/sdk': [relativePathForTsconfig(packageRoot, resolve(workspaceSdkDistRoot, 'index.d.ts'))],
+        '@treeseed/sdk/*': [relativePathForTsconfig(packageRoot, resolve(workspaceSdkDistRoot, '*.d.ts'))],
+    };
+}
 function emitTypeDeclarations() {
     const sourceFiles = [
         resolve(srcRoot, 'types/astro-build.d.ts'),
@@ -228,11 +241,13 @@ function emitTypeDeclarations() {
     }
     const compilerOptions = {
         allowImportingTsExtensions: true,
+        baseUrl: packageRoot,
         declaration: true,
         emitDeclarationOnly: true,
         module: ts.ModuleKind.ESNext,
         moduleResolution: ts.ModuleResolutionKind.Bundler,
         outDir: distRoot,
+        paths: resolveWorkspaceSdkDeclarationPaths() ?? undefined,
         rootDir: srcRoot,
         skipLibCheck: true,
         target: ts.ScriptTarget.ES2022,

package/dist/services/common.d.ts

@@ -28,6 +28,12 @@ export declare function buildTaskContext(sdk: AgentSdk, taskId: string): Promise
     graph: Record<string, unknown> | null;
 }>;
 export declare function seedRootTasks(sdk: AgentSdk, workDayId: string): Promise<any[]>;
+export declare function seedGraphRefreshTask(sdk: AgentSdk, request: {
+    workDayId: string;
+    projectId: string;
+    repositoryId?: string | null;
+    actor?: string;
+}): Promise<import("@treeseed/sdk").SdkTaskEntity>;
 export declare function startAndSeedWorkday(sdk: AgentSdk, request: {
     id?: string;
     projectId: string;
@@ -47,7 +53,14 @@ export declare function resolveManagerConfig(): {
 export declare function resolveWorkerConfig(): {
     workerId: string;
     batchSize: number;
+    maxLocalWorkers: number;
+    runnerServiceName: string;
+    volumeRoot: string;
+    volumeIdentity: string;
+    projectId: string;
+    environment: string;
     visibilityTimeoutMs: number;
     pollIntervalMs: number;
+    idleExitMs: number;
     leaseSeconds: number;
 };

package/dist/services/common.js

@@ -135,21 +135,41 @@ async function seedRootTasks(sdk, workDayId) {
   }
   return created;
 }
+async function seedGraphRefreshTask(sdk, request) {
+  const task = await sdk.createTask({
+    workDayId: request.workDayId,
+    agentId: "system",
+    type: "refresh_project_graph",
+    priority: 1e3,
+    idempotencyKey: `${request.workDayId}:refresh_project_graph`,
+    payload: {
+      projectId: request.projectId,
+      repositoryId: request.repositoryId ?? request.projectId
+    },
+    graphVersion: null,
+    actor: request.actor ?? "manager"
+  });
+  return task.payload;
+}
 async function startAndSeedWorkday(sdk, request) {
-  const graphRefresh = await sdk.refreshGraph();
   const workDay = await sdk.startWorkDay({
     id: request.id,
     projectId: request.projectId,
     capacityBudget: request.capacityBudget,
-    graphVersion: graphRefresh.snapshotRoot,
-    summary: { graphRefresh },
+    graphVersion: null,
+    summary: { graphRefresh: { state: "queued" } },
     actor: request.actor ?? "manager"
   });
+  const graphTask = workDay.payload ? await seedGraphRefreshTask(sdk, {
+    workDayId: String(workDay.payload.id),
+    projectId: request.projectId,
+    actor: request.actor ?? "manager"
+  }) : null;
   const tasks = workDay.payload ? await seedRootTasks(sdk, String(workDay.payload.id)) : [];
   return {
     ok: true,
     workDay: workDay.payload,
-    seededTasks: tasks.map((entry) => entry.payload).filter(Boolean)
+    seededTasks: [graphTask, ...tasks.map((entry) => entry.payload).filter(Boolean)].filter(Boolean)
   };
 }
 function resolveManagerConfig() {
@@ -163,9 +183,16 @@ function resolveManagerConfig() {
 function resolveWorkerConfig() {
   return {
     workerId: process.env.TREESEED_WORKER_ID?.trim() || `worker-${process.pid}`,
-    batchSize: integerFromEnv("TREESEED_QUEUE_BATCH_SIZE", 1),
+    batchSize: integerFromEnv("TREESEED_QUEUE_BATCH_SIZE", integerFromEnv("TREESEED_RUNNER_MAX_LOCAL_WORKERS", 4)),
+    maxLocalWorkers: integerFromEnv("TREESEED_RUNNER_MAX_LOCAL_WORKERS", 4),
+    runnerServiceName: process.env.TREESEED_RUNNER_SERVICE_NAME?.trim() || process.env.RAILWAY_SERVICE_NAME?.trim() || `worker-runner-${process.pid}`,
+    volumeRoot: process.env.TREESEED_RUNNER_VOLUME_ROOT?.trim() || process.env.RAILWAY_VOLUME_MOUNT_PATH?.trim() || ".treeseed-runner",
+    volumeIdentity: process.env.TREESEED_RUNNER_VOLUME_ID?.trim() || process.env.RAILWAY_VOLUME_ID?.trim() || process.env.RAILWAY_VOLUME_NAME?.trim() || "local-runner-volume",
+    projectId: process.env.TREESEED_PROJECT_ID?.trim() || "treeseed-market",
+    environment: process.env.TREESEED_DEPLOY_ENVIRONMENT?.trim() || (process.env.NODE_ENV === "production" ? "prod" : "local"),
     visibilityTimeoutMs: integerFromEnv("TREESEED_QUEUE_VISIBILITY_TIMEOUT_MS", 12e4),
     pollIntervalMs: integerFromEnv("TREESEED_WORKER_POLL_INTERVAL_MS", 5e3),
+    idleExitMs: integerFromEnv("TREESEED_WORKER_IDLE_EXIT_MS", 0),
     leaseSeconds: integerFromEnv("TREESEED_TASK_LEASE_SECONDS", 120)
   };
 }
@@ -179,6 +206,7 @@ export {
   resolveManagerConfig,
   resolveServiceRepoRoot,
   resolveWorkerConfig,
+  seedGraphRefreshTask,
   seedRootTasks,
   startAndSeedWorkday
 };

package/dist/services/index.d.ts

@@ -1,5 +1,6 @@
 export { runManagerAction, runManagerCycle, startManagerLoop } from './manager.ts';
 export { runWorkerCycle, startWorkerLoop } from './worker.ts';
+export { runScheduledWorkdayManager } from './workday-manager.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,5 +1,6 @@
 import { runManagerAction, runManagerCycle, startManagerLoop } from "./manager.js";
 import { runWorkerCycle, startWorkerLoop } from "./worker.js";
+import { runScheduledWorkdayManager } from "./workday-manager.js";
 import { runWorkdayStart } from "./workday-start.js";
 import { runWorkdayReport } from "./workday-report.js";
 import { createWorkerPoolScaler, RailwayWorkerPoolScaler, NoopWorkerPoolScaler } from "./worker-pool-scaler.js";
@@ -9,6 +10,7 @@ export {
   createWorkerPoolScaler,
   runManagerAction,
   runManagerCycle,
+  runScheduledWorkdayManager,
   runWorkdayReport,
   runWorkdayStart,
   runWorkerCycle,

package/dist/services/manager.d.ts

@@ -48,7 +48,7 @@ export declare function runManagerAction(options?: {
     mode: "reconcile";
     managerId: string;
     projectId: string;
-    environment: "local" | "staging" | "prod";
+    environment: "local" | "prod" | "staging";
     insideWorkWindow: boolean;
     workPolicy: WorkdayPolicy;
     workDay: Record<string, unknown>;
@@ -97,8 +97,18 @@ export declare function runManagerAction(options?: {
             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" | "staging" | "prod";
+        environment: "local" | "prod" | "staging";
         workDayId: string;
         state: string;
         totalTasks: number;
@@ -164,8 +174,18 @@ export declare function runManagerAction(options?: {
             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" | "staging" | "prod";
+        environment: "local" | "prod" | "staging";
         workDayId: string;
         state: string;
         totalTasks: number;
@@ -226,7 +246,7 @@ export declare function runManagerCycle(options?: {
     mode: "reconcile";
     managerId: string;
     projectId: string;
-    environment: "local" | "staging" | "prod";
+    environment: "local" | "prod" | "staging";
     insideWorkWindow: boolean;
     workPolicy: WorkdayPolicy;
     workDay: Record<string, unknown>;