@treeseed/core 0.4.8 → 0.4.10

package/dist/services/common.d.ts

@@ -1,9 +1,43 @@
-import { AgentSdk } from '@treeseed/sdk/sdk';
-import { TreeseedGatewayClient, CloudflareQueuePullClient } from '@treeseed/sdk/remote';
+import { AgentSdk } from '@treeseed/sdk';
+import { CloudflareQueuePullClient } from '@treeseed/sdk/remote';
+import type { SdkQueueMessageEnvelope } from '@treeseed/sdk';
 export declare function resolveServiceRepoRoot(): string;
 export declare function createServiceSdk(): AgentSdk;
-export declare function createGatewayClient(): TreeseedGatewayClient;
 export declare function createQueueClient(): CloudflareQueuePullClient;
+export declare function createQueuePushClient(): {
+    enqueue(request: {
+        message: SdkQueueMessageEnvelope;
+        delaySeconds?: number;
+    }): Promise<void>;
+};
+export declare function queueEnvelopeForTask(task: Record<string, unknown>): SdkQueueMessageEnvelope;
+export declare function enqueueTaskFromSdk(sdk: AgentSdk, request: {
+    taskId: string;
+    queueName?: string;
+    deliveryDelaySeconds?: number;
+    actor?: string;
+}): Promise<{
+    ok: boolean;
+    taskId: string;
+    queued: boolean;
+}>;
+export declare function buildTaskContext(sdk: AgentSdk, taskId: string): Promise<{
+    agent: Record<string, unknown> | import("@treeseed/sdk").SdkContentEntry;
+    task: import("@treeseed/sdk").SdkTaskEntity | null;
+    workDay: import("@treeseed/sdk").SdkWorkDayEntity | null;
+    graph: Record<string, unknown> | null;
+}>;
+export declare function seedRootTasks(sdk: AgentSdk, workDayId: string): Promise<any[]>;
+export declare function startAndSeedWorkday(sdk: AgentSdk, request: {
+    id?: string;
+    projectId: string;
+    capacityBudget: number;
+    actor?: string;
+}): Promise<{
+    ok: boolean;
+    workDay: import("@treeseed/sdk").SdkWorkDayEntity;
+    seededTasks: any[];
+}>;
 export declare function resolveManagerConfig(): {
     host: string;
     port: number;
@@ -16,5 +50,4 @@ export declare function resolveWorkerConfig(): {
     visibilityTimeoutMs: number;
     pollIntervalMs: number;
     leaseSeconds: number;
-    managerBaseUrl: string;
 };

package/dist/services/common.js

@@ -1,5 +1,6 @@
-import { AgentSdk } from "@treeseed/sdk/sdk";
-import { TreeseedGatewayClient, CloudflareQueuePullClient } from "@treeseed/sdk/remote";
+import crypto from "node:crypto";
+import { AgentSdk } from "@treeseed/sdk";
+import { CloudflareQueuePullClient } from "@treeseed/sdk/remote";
 function integerFromEnv(name, fallback) {
   const value = process.env[name];
   if (!value) return fallback;
@@ -16,27 +17,140 @@ function createServiceSdk() {
     persistTo: process.env.TREESEED_AGENT_D1_PERSIST_TO ?? void 0
   });
 }
-function createGatewayClient() {
-  const baseUrl = process.env.TREESEED_GATEWAY_BASE_URL?.trim();
-  const bearerToken = process.env.TREESEED_GATEWAY_BEARER_TOKEN?.trim();
-  if (!baseUrl || !bearerToken) {
-    return null;
-  }
-  return new TreeseedGatewayClient({ baseUrl, bearerToken });
-}
-function createQueueClient() {
+function createQueueClientConfig(token) {
   const accountId = process.env.CLOUDFLARE_ACCOUNT_ID?.trim();
   const queueId = process.env.TREESEED_QUEUE_ID?.trim();
-  const token = process.env.TREESEED_QUEUE_PULL_TOKEN?.trim();
   if (!accountId || !queueId || !token) {
     return null;
   }
-  return new CloudflareQueuePullClient({
+  return {
     accountId,
     queueId,
     token,
     apiBaseUrl: process.env.TREESEED_QUEUE_API_BASE_URL?.trim() || void 0
+  };
+}
+function createQueueClient() {
+  const config = createQueueClientConfig(process.env.TREESEED_QUEUE_PULL_TOKEN?.trim() || "");
+  if (!config) {
+    return null;
+  }
+  return new CloudflareQueuePullClient(config);
+}
+function createQueuePushClient() {
+  const config = createQueueClientConfig(
+    process.env.TREESEED_QUEUE_PUSH_TOKEN?.trim() || process.env.CLOUDFLARE_API_TOKEN?.trim() || ""
+  );
+  if (!config) {
+    return null;
+  }
+  const apiBaseUrl = config.apiBaseUrl ?? "https://api.cloudflare.com/client/v4/accounts";
+  const baseUrl = `${apiBaseUrl.replace(/\/$/u, "")}/${config.accountId}/queues/${config.queueId}`;
+  return {
+    async enqueue(request) {
+      const response = await fetch(`${baseUrl}/messages`, {
+        method: "POST",
+        headers: {
+          accept: "application/json",
+          authorization: `Bearer ${config.token}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          body: request.message,
+          content_type: "json",
+          delay_seconds: request.delaySeconds ?? 0
+        })
+      });
+      const payload = await response.json().catch(() => ({}));
+      if (!response.ok || payload.success === false) {
+        throw new Error(payload.errors?.[0]?.message ?? `Queue request failed with ${response.status}.`);
+      }
+    }
+  };
+}
+function queueEnvelopeForTask(task) {
+  return {
+    messageId: crypto.randomUUID(),
+    taskId: String(task.id ?? ""),
+    workDayId: String(task.workDayId ?? task.work_day_id ?? ""),
+    agentId: String(task.agentId ?? task.agent_id ?? ""),
+    taskType: String(task.type ?? ""),
+    idempotencyKey: String(task.idempotencyKey ?? task.idempotency_key ?? ""),
+    attempt: Number(task.attemptCount ?? task.attempt_count ?? 0) + 1,
+    payloadRef: `d1:tasks/${String(task.id ?? "")}`,
+    graphVersion: task.graphVersion !== void 0 && task.graphVersion !== null ? String(task.graphVersion) : task.graph_version !== void 0 && task.graph_version !== null ? String(task.graph_version) : null,
+    budgetHint: 1
+  };
+}
+async function enqueueTaskFromSdk(sdk, request) {
+  const queue = createQueuePushClient();
+  if (!queue) {
+    throw new Error("Queue push client not configured.");
+  }
+  const task = await sdk.get({ model: "task", id: request.taskId });
+  if (!task.payload) {
+    throw new Error("Unknown task.");
+  }
+  await queue.enqueue({
+    message: queueEnvelopeForTask(task.payload),
+    delaySeconds: request.deliveryDelaySeconds ?? 0
+  });
+  await sdk.recordTaskProgress({
+    id: request.taskId,
+    state: "queued",
+    appendEvent: { kind: "queued", data: { queueName: request.queueName ?? null } },
+    actor: request.actor
   });
+  return { ok: true, taskId: request.taskId, queued: true };
+}
+async function buildTaskContext(sdk, taskId) {
+  const context = await sdk.getManagerContext(taskId);
+  const task = context.payload.task;
+  const agent = task ? (await sdk.get({ model: "agent", slug: String(task.agentId) })).payload : null;
+  return {
+    ...context.payload,
+    agent
+  };
+}
+async function seedRootTasks(sdk, workDayId) {
+  const specs = await sdk.listAgentSpecs({ enabled: true });
+  const created = [];
+  for (const spec of specs) {
+    const hasStartTrigger = spec.triggers.some((trigger) => trigger.type === "startup" || trigger.type === "schedule");
+    if (!hasStartTrigger) continue;
+    created.push(await sdk.createTask({
+      workDayId,
+      agentId: spec.slug,
+      type: "agent_root",
+      priority: 100,
+      idempotencyKey: `${workDayId}:${spec.slug}:root`,
+      payload: {
+        agentSlug: spec.slug,
+        handler: spec.handler,
+        triggerKinds: spec.triggers.map((entry) => entry.type)
+      },
+      graphVersion: null,
+      actor: "manager"
+    }));
+  }
+  return created;
+}
+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 },
+    actor: request.actor ?? "manager"
+  });
+  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)
+  };
 }
 function resolveManagerConfig() {
   return {
@@ -52,15 +166,19 @@ function resolveWorkerConfig() {
     batchSize: integerFromEnv("TREESEED_QUEUE_BATCH_SIZE", 1),
     visibilityTimeoutMs: integerFromEnv("TREESEED_QUEUE_VISIBILITY_TIMEOUT_MS", 12e4),
     pollIntervalMs: integerFromEnv("TREESEED_WORKER_POLL_INTERVAL_MS", 5e3),
-    leaseSeconds: integerFromEnv("TREESEED_TASK_LEASE_SECONDS", 120),
-    managerBaseUrl: process.env.TREESEED_MANAGER_BASE_URL?.trim() || `http://${process.env.TREESEED_MANAGER_HOST?.trim() || "manager.railway.internal"}:${integerFromEnv("TREESEED_MANAGER_PORT", 3100)}`
+    leaseSeconds: integerFromEnv("TREESEED_TASK_LEASE_SECONDS", 120)
   };
 }
 export {
-  createGatewayClient,
+  buildTaskContext,
   createQueueClient,
+  createQueuePushClient,
   createServiceSdk,
+  enqueueTaskFromSdk,
+  queueEnvelopeForTask,
   resolveManagerConfig,
   resolveServiceRepoRoot,
-  resolveWorkerConfig
+  resolveWorkerConfig,
+  seedRootTasks,
+  startAndSeedWorkday
 };

package/dist/services/index.d.ts

@@ -1,4 +1,4 @@
-export { createManagerApp } from './manager.ts';
 export { runWorkerCycle, startWorkerLoop } from './worker.ts';
+export { runRemoteRunnerCycle, startRemoteRunnerLoop } from './remote-runner.ts';
 export { runWorkdayStart } from './workday-start.ts';
 export { runWorkdayReport } from './workday-report.ts';

package/dist/services/index.js

@@ -1,11 +1,12 @@
-import { createManagerApp } from "./manager.js";
 import { runWorkerCycle, startWorkerLoop } from "./worker.js";
+import { runRemoteRunnerCycle, startRemoteRunnerLoop } from "./remote-runner.js";
 import { runWorkdayStart } from "./workday-start.js";
 import { runWorkdayReport } from "./workday-report.js";
 export {
-  createManagerApp,
+  runRemoteRunnerCycle,
   runWorkdayReport,
   runWorkdayStart,
   runWorkerCycle,
+  startRemoteRunnerLoop,
   startWorkerLoop
 };

package/dist/services/remote-runner.d.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { AgentSdk } from '@treeseed/sdk';
+export declare function resolveRemoteRunnerConfig(): {
+    marketBaseUrl: string;
+    projectId: string;
+    runnerToken: string;
+    runnerId: string;
+    batchSize: number;
+    pollIntervalMs: number;
+};
+export declare function runRemoteRunnerCycle(options?: {
+    sdk?: AgentSdk;
+    config?: ReturnType<typeof resolveRemoteRunnerConfig>;
+    fetchImpl?: typeof fetch;
+}): Promise<{
+    ok: boolean;
+    processed: number;
+}>;
+export declare function startRemoteRunnerLoop(options?: {
+    sdk?: AgentSdk;
+    config?: ReturnType<typeof resolveRemoteRunnerConfig>;
+    fetchImpl?: typeof fetch;
+}): Promise<void>;

package/dist/services/remote-runner.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { AgentSdk, RemoteTreeseedClient, RemoteTreeseedRunnerClient } from "@treeseed/sdk";
+import { createServiceSdk } 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 envValue(name) {
+  const value = process.env[name]?.trim();
+  return value ? value : "";
+}
+function resolveRemoteRunnerConfig() {
+  return {
+    marketBaseUrl: envValue("TREESEED_MARKET_API_BASE_URL") || envValue("TREESEED_API_BASE_URL"),
+    projectId: envValue("TREESEED_PROJECT_ID") || "treeseed-market",
+    runnerToken: envValue("TREESEED_PROJECT_RUNNER_TOKEN"),
+    runnerId: envValue("TREESEED_REMOTE_RUNNER_ID") || `remote-runner-${process.pid}`,
+    batchSize: integerFromEnv("TREESEED_REMOTE_RUNNER_BATCH_SIZE", 1),
+    pollIntervalMs: integerFromEnv("TREESEED_REMOTE_RUNNER_POLL_INTERVAL_MS", 5e3)
+  };
+}
+function createRunnerClient(config, fetchImpl) {
+  if (!config.marketBaseUrl || !config.runnerToken) {
+    throw new Error(
+      "Remote runner requires TREESEED_MARKET_API_BASE_URL (or TREESEED_API_BASE_URL) and TREESEED_PROJECT_RUNNER_TOKEN."
+    );
+  }
+  return new RemoteTreeseedRunnerClient(new RemoteTreeseedClient({
+    hosts: [{ id: "market", baseUrl: config.marketBaseUrl }],
+    activeHostId: "market",
+    auth: {
+      accessToken: config.runnerToken
+    }
+  }, {
+    fetchImpl
+  }));
+}
+async function runRemoteRunnerCycle(options = {}) {
+  const config = options.config ?? resolveRemoteRunnerConfig();
+  const sdk = options.sdk ?? createServiceSdk();
+  const runner = createRunnerClient(config, options.fetchImpl);
+  const pulled = await runner.pull(config.projectId, {
+    limit: config.batchSize,
+    runnerId: config.runnerId
+  });
+  if (pulled.payload.length === 0) {
+    return { ok: true, processed: 0 };
+  }
+  let processed = 0;
+  for (const job of pulled.payload) {
+    try {
+      await runner.progress(job.id, {
+        summary: `Running ${job.namespace}:${job.operation}`,
+        data: {
+          runnerId: config.runnerId,
+          status: "running"
+        }
+      });
+      const result = await sdk.dispatch({
+        namespace: job.namespace,
+        operation: job.operation,
+        input: job.input ?? {},
+        preferredMode: "prefer_local"
+      });
+      await runner.complete(job.id, {
+        output: result.mode === "inline" ? result.payload : result
+      });
+      processed += 1;
+    } catch (error) {
+      await runner.fail(job.id, {
+        code: "runner_execution_failed",
+        message: error instanceof Error ? error.message : String(error)
+      }).catch(() => null);
+    }
+  }
+  return { ok: true, processed };
+}
+async function startRemoteRunnerLoop(options = {}) {
+  const config = options.config ?? resolveRemoteRunnerConfig();
+  for (; ; ) {
+    try {
+      await runRemoteRunnerCycle({
+        ...options,
+        config
+      });
+    } catch (error) {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    }
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, config.pollIntervalMs));
+  }
+}
+const currentFile = fileURLToPath(import.meta.url);
+const entryFile = process.argv[1] ?? "";
+if (entryFile === currentFile) {
+  await startRemoteRunnerLoop();
+}
+export {
+  resolveRemoteRunnerConfig,
+  runRemoteRunnerCycle,
+  startRemoteRunnerLoop
+};

package/dist/services/workday-report.js

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
-import { createGatewayClient, createServiceSdk } from "./common.js";
+import { createServiceSdk } from "./common.js";
 async function runWorkdayReport() {
   const sdk = createServiceSdk();
-  const gateway = createGatewayClient();
   const workDays = await sdk.search({ model: "work_day", limit: 1 });
   const active = workDays.payload[0];
   if (!active || typeof active.id !== "string") {
@@ -16,21 +15,18 @@ async function runWorkdayReport() {
     failedTasks: tasks.payload.filter((entry) => entry.state === "failed").length,
     pendingTasks: tasks.payload.filter((entry) => entry.state !== "completed" && entry.state !== "failed").length
   };
-  if (gateway) {
-    await gateway.requestJson("/reports", {
-      body: {
-        workDayId: active.id,
-        kind: "workday_summary",
-        body: summary
-      }
-    });
-    await gateway.requestJson(`/workdays/${encodeURIComponent(active.id)}/close`, {
-      body: {
-        state: "completed",
-        summary
-      }
-    });
-  }
+  await sdk.createReport({
+    workDayId: active.id,
+    kind: "workday_summary",
+    body: summary,
+    actor: "workday-report"
+  });
+  await sdk.closeWorkDay({
+    id: active.id,
+    state: "completed",
+    summary,
+    actor: "workday-report"
+  });
   return { ok: true, workDayId: active.id, summary };
 }
 const currentFile = fileURLToPath(import.meta.url);

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

@@ -1,2 +1,6 @@
 #!/usr/bin/env node
-export declare function runWorkdayStart(): Promise<any>;
+export declare function runWorkdayStart(): Promise<{
+    ok: boolean;
+    workDay: import("@treeseed/sdk").SdkWorkDayEntity;
+    seededTasks: any[];
+}>;

package/dist/services/workday-start.js

@@ -1,20 +1,14 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
-import { resolveWorkerConfig } from "./common.js";
+import { createServiceSdk, resolveManagerConfig, startAndSeedWorkday } from "./common.js";
 async function runWorkdayStart() {
-  const managerBaseUrl = resolveWorkerConfig().managerBaseUrl;
-  const response = await fetch(`${managerBaseUrl}/internal/workdays/start`, {
-    method: "POST",
-    headers: {
-      accept: "application/json",
-      "content-type": "application/json"
-    },
-    body: JSON.stringify({})
+  const sdk = createServiceSdk();
+  const config = resolveManagerConfig();
+  return startAndSeedWorkday(sdk, {
+    projectId: config.projectId,
+    capacityBudget: config.defaultCapacityBudget,
+    actor: "manager"
   });
-  if (!response.ok) {
-    throw new Error(`Workday start failed with ${response.status}.`);
-  }
-  return response.json();
 }
 const currentFile = fileURLToPath(import.meta.url);
 const entryFile = process.argv[1] ?? "";

package/dist/services/worker.js

@@ -1,27 +1,12 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
-import { createGatewayClient, createQueueClient, resolveWorkerConfig } from "./common.js";
-async function managerRequest(baseUrl, path, body) {
-  const response = await fetch(`${baseUrl}${path}`, {
-    method: "POST",
-    headers: {
-      accept: "application/json",
-      "content-type": "application/json"
-    },
-    body: JSON.stringify(body)
-  });
-  const payload = await response.json().catch(() => ({}));
-  if (!response.ok) {
-    throw new Error(typeof payload.error === "string" ? payload.error : `Manager request failed with ${response.status}.`);
-  }
-  return payload;
-}
+import { buildTaskContext, createQueueClient, createServiceSdk, resolveWorkerConfig } from "./common.js";
 async function runWorkerCycle() {
-  const gateway = createGatewayClient();
+  const sdk = createServiceSdk();
   const queue = createQueueClient();
   const config = resolveWorkerConfig();
-  if (!gateway || !queue) {
-    throw new Error("Worker requires TREESEED_GATEWAY_BASE_URL, TREESEED_GATEWAY_BEARER_TOKEN, CLOUDFLARE_ACCOUNT_ID, TREESEED_QUEUE_ID, and TREESEED_QUEUE_PULL_TOKEN.");
+  if (!queue) {
+    throw new Error("Worker requires CLOUDFLARE_ACCOUNT_ID, TREESEED_QUEUE_ID, and TREESEED_QUEUE_PULL_TOKEN.");
   }
   const pulled = await queue.pull({
     batchSize: config.batchSize,
@@ -33,52 +18,48 @@ async function runWorkerCycle() {
   let processed = 0;
   for (const message of pulled.messages) {
     try {
-      await gateway.requestJson(`/tasks/${encodeURIComponent(message.body.taskId)}/claim`, {
-        body: {
-          workerId: config.workerId,
-          leaseSeconds: config.leaseSeconds
-        }
+      await sdk.claimTask({
+        id: message.body.taskId,
+        workerId: config.workerId,
+        leaseSeconds: config.leaseSeconds,
+        actor: "worker"
       });
-      const context = await managerRequest(
-        config.managerBaseUrl,
-        "/internal/context/resolve-task",
-        { taskId: message.body.taskId }
-      );
-      const task = context.payload.task;
+      const context = await buildTaskContext(sdk, message.body.taskId);
+      const task = context.task;
       const payload = task && typeof task.payloadJson === "string" ? JSON.parse(task.payloadJson) : {};
-      await gateway.requestJson(`/tasks/${encodeURIComponent(message.body.taskId)}/progress`, {
-        body: {
-          workerId: config.workerId,
-          state: "running",
-          appendEvent: {
-            kind: "worker_started",
-            data: { workerId: config.workerId, queueAttempt: message.attempts }
-          }
-        }
+      await sdk.recordTaskProgress({
+        id: message.body.taskId,
+        workerId: config.workerId,
+        state: "running",
+        appendEvent: {
+          kind: "worker_started",
+          data: { workerId: config.workerId, queueAttempt: message.attempts }
+        },
+        actor: "worker"
       });
-      await gateway.requestJson(`/tasks/${encodeURIComponent(message.body.taskId)}/complete`, {
-        body: {
-          output: {
-            workerId: config.workerId,
-            queueAttempt: message.attempts,
-            payload
-          },
-          summary: {
-            status: "completed",
-            workerId: config.workerId
-          }
-        }
+      await sdk.completeTask({
+        id: message.body.taskId,
+        output: {
+          workerId: config.workerId,
+          queueAttempt: message.attempts,
+          payload
+        },
+        summary: {
+          status: "completed",
+          workerId: config.workerId
+        },
+        actor: "worker"
       });
       await queue.ack([message.leaseId]);
       processed += 1;
     } catch (error) {
       const retryDelaySeconds = Math.min(300, Math.max(15, message.attempts * 30));
-      await gateway.requestJson(`/tasks/${encodeURIComponent(message.body.taskId)}/fail`, {
-        body: {
-          errorMessage: error instanceof Error ? error.message : String(error),
-          retryable: true,
-          nextVisibleAt: new Date(Date.now() + retryDelaySeconds * 1e3).toISOString()
-        }
+      await sdk.failTask({
+        id: message.body.taskId,
+        errorMessage: error instanceof Error ? error.message : String(error),
+        retryable: true,
+        nextVisibleAt: new Date(Date.now() + retryDelaySeconds * 1e3).toISOString(),
+        actor: "worker"
       }).catch(() => null);
       await queue.retry([{ leaseId: message.leaseId, delaySeconds: retryDelaySeconds }]);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/core",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "Treeseed integrated platform starter for Astro/Starlight web runtimes and Hono API runtimes.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -40,8 +40,8 @@
     "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: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:watch": "node ./scripts/run-ts.mjs ./scripts/dev-platform.ts --watch",
@@ -67,7 +67,7 @@
     "release:publish": "node ./scripts/run-ts.mjs ./scripts/publish-package.ts"
   },
   "dependencies": {
-    "@treeseed/sdk": "^0.4.7",
+    "@treeseed/sdk": "^0.4.9",
     "@astrojs/check": "^0.9.8",
     "@astrojs/cloudflare": "^12.6.13",
     "@astrojs/sitemap": "3.7.0",
@@ -159,14 +159,14 @@
     "./tenant": "./dist/tenant/bridge.js",
     "./scripts/dev-platform": "./dist/scripts/dev-platform.js",
     "./scripts/workspace-bootstrap": "./dist/scripts/workspace-bootstrap.js",
-    "./services/manager": {
-      "types": "./dist/services/manager.d.ts",
-      "default": "./dist/services/manager.js"
-    },
     "./services/worker": {
       "types": "./dist/services/worker.d.ts",
       "default": "./dist/services/worker.js"
     },
+    "./services/remote-runner": {
+      "types": "./dist/services/remote-runner.d.ts",
+      "default": "./dist/services/remote-runner.js"
+    },
     "./services/workday-start": {
       "types": "./dist/services/workday-start.d.ts",
       "default": "./dist/services/workday-start.js"
@@ -179,10 +179,6 @@
       "types": "./dist/api/app.d.ts",
       "default": "./dist/api/app.js"
     },
-    "./api/gateway": {
-      "types": "./dist/api/gateway.d.ts",
-      "default": "./dist/api/gateway.js"
-    },
     "./site-resources": {
       "types": "./dist/site-resources.d.ts",
       "default": "./dist/site-resources.js"

package/dist/api/gateway.d.ts

@@ -1,5 +0,0 @@
-import { Hono } from 'hono';
-import type { AppVariables, GatewayServerOptions } from './types.ts';
-export declare function createTreeseedGatewayApp(options: GatewayServerOptions): Hono<{
-    Variables: AppVariables;
-}, import("hono/types").BlankSchema, "/">;