@treeseed/core 0.4.9 → 0.4.10

package/dist/api/operations-routes.d.ts

@@ -2,5 +2,6 @@ import type { Hono } from 'hono';
 import { executeHttpWorkflowOperation } from './operations.ts';
 export declare function registerOperationRoutes(app: Hono<any>, options: {
     scope: string;
+    prefix?: string;
     executeOperation?: typeof executeHttpWorkflowOperation;
 }): void;

package/dist/api/operations-routes.js

@@ -3,7 +3,12 @@ import { executeHttpWorkflowOperation, isHttpWorkflowOperationAllowed } from "./
 import { jsonError, requireScope } from "./http.js";
 function registerOperationRoutes(app, options) {
   const executeOperation = options.executeOperation ?? executeHttpWorkflowOperation;
-  app.post("/operations/:operation", async (c) => {
+  const prefix = options.prefix ?? "";
+  function withPrefix(path) {
+    if (!prefix) return path;
+    return `${prefix}${path}`.replace(/\/{2,}/g, "/");
+  }
+  app.post(withPrefix("/operations/:operation"), async (c) => {
     const unauthorized = requireScope(c, options.scope);
     if (unauthorized) return unauthorized;
     const requestedOperation = c.req.param("operation");

package/dist/api/railway.d.ts

@@ -22,7 +22,11 @@ export declare function createRailwayTreeseedApiServer(options?: ApiServerOption
         baseUrl: string;
         issuer: string;
         repoRoot: string;
+        projectId: string;
         authSecret: string;
+        projectApiKey?: string;
+        projectApiLabel: string;
+        projectApiPermissions: string[];
         cloudflareAccountId?: string;
         cloudflareApiToken?: string;
         d1DatabaseId?: string;

package/dist/api/sdk-dispatch.d.ts

@@ -1,14 +1,5 @@
 import type { AgentSdk, RemoteSdkOperationRequest } from '@treeseed/sdk';
+import { executeSdkOperation, findSdkOperation, listSdkOperationNames } from '@treeseed/sdk';
 import type { ApiConfig } from './types.ts';
-type JsonRecord = Record<string, unknown>;
-type SdkOperationHandler = (sdk: AgentSdk, input: JsonRecord) => Promise<unknown> | unknown;
-interface SdkOperationSpec {
-    name: string;
-    aliases?: string[];
-    handler: SdkOperationHandler;
-}
-export declare function listSdkOperationNames(): string[];
-export declare function findSdkOperation(name: string): SdkOperationSpec;
+export { executeSdkOperation, findSdkOperation, listSdkOperationNames, };
 export declare function resolveSdkInstance(sharedSdk: AgentSdk | undefined, config: ApiConfig, request: RemoteSdkOperationRequest): AgentSdk;
-export declare function executeSdkOperation(sdk: AgentSdk, operationName: string, input: JsonRecord): Promise<unknown>;
-export {};

package/dist/api/sdk-dispatch.js

@@ -1,142 +1,10 @@
-import { AgentSdk as AgentSdkClass } from "@treeseed/sdk";
-function passthrough(methodName) {
-  return (sdk, input) => sdk[methodName](input);
-}
-const SDK_OPERATION_SPECS = [
-  { name: "get", handler: passthrough("get") },
-  { name: "read", handler: passthrough("read") },
-  { name: "search", handler: passthrough("search") },
-  { name: "follow", handler: passthrough("follow") },
-  { name: "pick", handler: passthrough("pick") },
-  { name: "create", handler: passthrough("create") },
-  { name: "update", handler: passthrough("update") },
-  { name: "claimMessage", aliases: ["claim-message"], handler: passthrough("claimMessage") },
-  { name: "ackMessage", aliases: ["ack-message"], handler: passthrough("ackMessage") },
-  { name: "createMessage", aliases: ["create-message"], handler: passthrough("createMessage") },
-  { name: "recordRun", aliases: ["record-run"], handler: passthrough("recordRun") },
-  { name: "getCursor", aliases: ["get-cursor"], handler: passthrough("getCursor") },
-  { name: "upsertCursor", aliases: ["upsert-cursor"], handler: passthrough("upsertCursor") },
-  { name: "releaseLease", aliases: ["release-lease"], handler: passthrough("releaseLease") },
-  {
-    name: "releaseAllLeases",
-    aliases: ["release-all-leases"],
-    handler: (sdk) => sdk.releaseAllLeases()
-  },
-  { name: "startWorkDay", aliases: ["start-work-day"], handler: passthrough("startWorkDay") },
-  { name: "closeWorkDay", aliases: ["close-work-day"], handler: passthrough("closeWorkDay") },
-  { name: "createTask", aliases: ["create-task"], handler: passthrough("createTask") },
-  { name: "claimTask", aliases: ["claim-task"], handler: passthrough("claimTask") },
-  {
-    name: "recordTaskProgress",
-    aliases: ["record-task-progress"],
-    handler: passthrough("recordTaskProgress")
-  },
-  { name: "completeTask", aliases: ["complete-task"], handler: passthrough("completeTask") },
-  { name: "failTask", aliases: ["fail-task"], handler: passthrough("failTask") },
-  { name: "appendTaskEvent", aliases: ["append-task-event"], handler: passthrough("appendTaskEvent") },
-  { name: "searchTasks", aliases: ["search-tasks"], handler: passthrough("searchTasks") },
-  {
-    name: "getManagerContext",
-    aliases: ["get-manager-context"],
-    handler: (sdk, input) => sdk.getManagerContext(String(input.taskId ?? input.id ?? ""))
-  },
-  { name: "createReport", aliases: ["create-report"], handler: passthrough("createReport") },
-  {
-    name: "listAgentSpecs",
-    aliases: ["list-agent-specs"],
-    handler: (sdk, input) => sdk.listAgentSpecs(input)
-  },
-  { name: "refreshGraph", aliases: ["refresh-graph"], handler: passthrough("refreshGraph") },
-  {
-    name: "searchFiles",
-    aliases: ["search-files"],
-    handler: (sdk, input) => sdk.searchFiles(String(input.query ?? ""), input.options)
-  },
-  {
-    name: "searchSections",
-    aliases: ["search-sections"],
-    handler: (sdk, input) => sdk.searchSections(String(input.query ?? ""), input.options)
-  },
-  {
-    name: "searchEntities",
-    aliases: ["search-entities"],
-    handler: (sdk, input) => sdk.searchEntities(String(input.query ?? ""), input.options)
-  },
-  {
-    name: "getGraphNode",
-    aliases: ["get-graph-node"],
-    handler: (sdk, input) => sdk.getGraphNode(String(input.id ?? ""))
-  },
-  {
-    name: "getNeighbors",
-    aliases: ["get-neighbors"],
-    handler: (sdk, input) => sdk.getNeighbors(String(input.id ?? ""), input.options)
-  },
-  {
-    name: "followReferences",
-    aliases: ["follow-references"],
-    handler: (sdk, input) => sdk.followReferences(String(input.id ?? ""), input.options)
-  },
-  {
-    name: "getBacklinks",
-    aliases: ["get-backlinks"],
-    handler: (sdk, input) => sdk.getBacklinks(String(input.id ?? ""), input.options)
-  },
-  {
-    name: "getRelated",
-    aliases: ["get-related"],
-    handler: (sdk, input) => sdk.getRelated(String(input.id ?? ""), input.options)
-  },
-  {
-    name: "getSubgraph",
-    aliases: ["get-subgraph"],
-    handler: (sdk, input) => sdk.getSubgraph(Array.isArray(input.seedIds) ? input.seedIds.map(String) : [], input.options)
-  },
-  { name: "resolveSeeds", aliases: ["resolve-seeds"], handler: passthrough("resolveSeeds") },
-  { name: "queryGraph", aliases: ["query-graph"], handler: passthrough("queryGraph") },
-  { name: "buildContextPack", aliases: ["build-context-pack"], handler: passthrough("buildContextPack") },
-  {
-    name: "parseGraphDsl",
-    aliases: ["parse-graph-dsl"],
-    handler: (sdk, input) => sdk.parseGraphDsl(String(input.source ?? input.query ?? ""))
-  },
-  {
-    name: "resolveReference",
-    aliases: ["resolve-reference"],
-    handler: (sdk, input) => sdk.resolveReference(String(input.reference ?? ""), input.options)
-  },
-  {
-    name: "explainReferenceChain",
-    aliases: ["explain-reference-chain"],
-    handler: (sdk, input) => sdk.explainReferenceChain(String(input.fromId ?? ""), String(input.toId ?? ""))
-  }
-];
-const SDK_OPERATION_INDEX = /* @__PURE__ */ new Map();
-for (const spec of SDK_OPERATION_SPECS) {
-  SDK_OPERATION_INDEX.set(spec.name, spec);
-  for (const alias of spec.aliases ?? []) {
-    SDK_OPERATION_INDEX.set(alias, spec);
-  }
-}
-function listSdkOperationNames() {
-  return [...new Set(SDK_OPERATION_SPECS.map((entry) => entry.name))];
-}
-function findSdkOperation(name) {
-  return SDK_OPERATION_INDEX.get(name) ?? null;
-}
+import { AgentSdk as AgentSdkClass, executeSdkOperation, findSdkOperation, listSdkOperationNames } from "@treeseed/sdk";
 function resolveSdkInstance(sharedSdk, config, request) {
   if (!request.repoRoot || request.repoRoot === config.repoRoot) {
     return sharedSdk ?? new AgentSdkClass({ repoRoot: config.repoRoot });
   }
   return new AgentSdkClass({ repoRoot: request.repoRoot });
 }
-async function executeSdkOperation(sdk, operationName, input) {
-  const spec = findSdkOperation(operationName);
-  if (!spec) {
-    throw new Error(`Unknown SDK operation "${operationName}".`);
-  }
-  return await spec.handler(sdk, input);
-}
 export {
   executeSdkOperation,
   findSdkOperation,

package/dist/api/sdk-routes.d.ts

@@ -5,6 +5,7 @@ interface RegisterSdkRoutesOptions {
     config: ApiConfig;
     sharedSdk?: AgentSdk;
     scope: string;
+    prefix?: string;
 }
 export declare function registerSdkRoutes(app: Hono<any>, options: RegisterSdkRoutesOptions): void;
 export {};

package/dist/api/sdk-routes.js

@@ -1,7 +1,11 @@
 import { executeSdkOperation, resolveSdkInstance } from "./sdk-dispatch.js";
 import { jsonError, requireScope } from "./http.js";
+function withPrefix(prefix, path) {
+  if (!prefix) return path;
+  return `${prefix}${path}`.replace(/\/{2,}/g, "/");
+}
 function registerSdkRoutes(app, options) {
-  app.post("/sdk/:operation", async (c) => {
+  app.post(withPrefix(options.prefix ?? "", "/sdk/:operation"), async (c) => {
     const unauthorized = requireScope(c, options.scope);
     if (unauthorized) return unauthorized;
     const operation = c.req.param("operation");

package/dist/api/types.d.ts

@@ -1,4 +1,5 @@
-import type { AgentSdk, SdkQueueMessageEnvelope } from '@treeseed/sdk';
+import type { Hono } from 'hono';
+import type { AgentSdk } from '@treeseed/sdk';
 import type { ApiPrincipal, ApiScope, DeviceCodeApproveRequest as SdkDeviceCodeApproveRequest, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, RemoteWorkflowOperationRequest as WorkflowHttpOperationRequest, RemoteWorkflowOperationResponse as ApiWorkflowOperationResponse, RemoteSdkOperationRequest as SdkHttpOperationRequest, TokenRefreshRequest, TokenRefreshResponse } from '@treeseed/sdk/remote';
 export type { ApiPrincipal, ApiScope, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, WorkflowHttpOperationRequest, ApiWorkflowOperationResponse, SdkHttpOperationRequest, TokenRefreshRequest, TokenRefreshResponse, };
 export type DeviceCodeApproveRequest = SdkDeviceCodeApproveRequest;
@@ -87,7 +88,11 @@ export interface ApiConfig {
     baseUrl: string;
     issuer: string;
     repoRoot: string;
+    projectId: string;
     authSecret: string;
+    projectApiKey?: string;
+    projectApiLabel: string;
+    projectApiPermissions: string[];
     cloudflareAccountId?: string;
     cloudflareApiToken?: string;
     d1DatabaseId?: string;
@@ -111,11 +116,11 @@ export interface AppVariables {
     principal: ApiPrincipal | null;
     actingUser: ApiPrincipal | null;
     credential: ApiCredential | null;
-    actorType: 'anonymous' | 'user' | 'service';
+    actorType: 'anonymous' | 'user' | 'service' | 'project';
     permissionGrants: string[];
 }
 export interface ApiCredential {
-    type: 'access_token' | 'personal_access_token' | 'service_secret' | 'service_token';
+    type: 'access_token' | 'personal_access_token' | 'service_secret' | 'service_token' | 'project_api_key' | 'team_api_key';
     id: string;
     label?: string;
 }
@@ -158,6 +163,28 @@ export interface ResolvedApiRuntimeProviders {
     };
     selections: ApiRuntimeProviderSelections;
 }
+export interface ApiResolvedSettings {
+    config: ApiConfig;
+    surfaces: {
+        auth: boolean;
+        templates: boolean;
+        sdk: boolean;
+        agent: boolean;
+        operations: boolean;
+    };
+    scopes: {
+        authMe: ApiScope;
+        sdk: ApiScope;
+        agent: ApiScope;
+        operations: ApiScope;
+    };
+}
+export interface ApiAppRuntime {
+    resolved: ApiResolvedSettings;
+    runtimeProviders: ResolvedApiRuntimeProviders;
+    sharedSdk: AgentSdk;
+    internalPrefix: string;
+}
 export interface ApiServerOptions {
     config?: Partial<ApiConfig>;
     runtimeProviders?: ApiRuntimeProviders;
@@ -176,18 +203,7 @@ export interface ApiServerOptions {
         agent: ApiScope;
         operations: ApiScope;
     }>;
+    internalPrefix?: string;
+    extendApp?: (app: Hono<any>, runtime: ApiAppRuntime) => void;
     log?: (message: string, details?: Record<string, unknown>) => void;
 }
-export interface GatewayQueueProducer {
-    enqueue(request: {
-        queueName?: string;
-        message: SdkQueueMessageEnvelope;
-        delaySeconds?: number;
-    }): Promise<void>;
-}
-export interface GatewayServerOptions {
-    sdk: AgentSdk;
-    bearerToken: string;
-    queueProducer?: GatewayQueueProducer;
-    projectId?: string;
-}

package/dist/dev.js

@@ -38,6 +38,28 @@ function resolveNodeEntrypoint(packageDir, sourceRelativePath, distRelativePath)
     args: [resolve(packageDir, distRelativePath)]
   };
 }
+function resolveTenantApiEntrypoint(tenantRoot, runTsPath) {
+  const javascriptCandidates = [
+    resolve(tenantRoot, "src", "api", "server.js"),
+    resolve(tenantRoot, "src", "api", "server.mjs")
+  ];
+  for (const candidate of javascriptCandidates) {
+    if (existsSync(candidate)) {
+      return {
+        command: process.execPath,
+        args: [candidate]
+      };
+    }
+  }
+  const typescriptCandidate = resolve(tenantRoot, "src", "api", "server.ts");
+  if (existsSync(typescriptCandidate) && existsSync(runTsPath)) {
+    return {
+      command: process.execPath,
+      args: [runTsPath, typescriptCandidate]
+    };
+  }
+  return null;
+}
 function withWatchArgs(args, watchPaths) {
   return watchPaths.flatMap((watchPath) => ["--watch-path", watchPath]).concat(args);
 }
@@ -55,12 +77,13 @@ function createTreeseedIntegratedDevPlan(options = {}) {
   const mergedEnv = { ...process.env, ...options.env ?? {} };
   const apiBaseUrl = mergedEnv.TREESEED_API_BASE_URL?.trim() || `http://${apiHost}:${apiPort}`;
   const sdkPackageRoot = resolvePackageRoot("@treeseed/sdk", tenantRoot);
+  const coreRunTsPath = resolve(packageRoot, "scripts", "run-ts.mjs");
   const webEntrypoint = resolveNodeEntrypoint(
     sdkPackageRoot,
     "scripts/tenant-astro-command.ts",
     "dist/scripts/tenant-astro-command.js"
   );
-  const apiEntrypoint = resolveNodeEntrypoint(
+  const apiEntrypoint = resolveTenantApiEntrypoint(tenantRoot, coreRunTsPath) ?? resolveNodeEntrypoint(
     packageRoot,
     "src/api/server.ts",
     "dist/api/server.js"

package/dist/index.d.ts

@@ -2,7 +2,6 @@ export { buildTreeseedSiteLayers, resolveTreeseedPageEntrypoint, resolveTreeseed
 export { buildTreeseedPlatformLayers, resolveTreeseedPlatformResource, TREESEED_PLATFORM_RESOURCE_KINDS, } from './platform-resources';
 export { parseSiteConfig } from './utils/site-config-schema.js';
 export { createTreeseedApiApp } from './api/app';
-export { createTreeseedGatewayApp } from './api/gateway';
 export { createRailwayTreeseedApiServer } from './api/railway';
 export { resolveApiConfig } from './api/config';
 export { createTreeseedIntegratedDevPlan, runTreeseedIntegratedDev, type TreeseedIntegratedDevCommand, type TreeseedIntegratedDevOptions, type TreeseedIntegratedDevPlan, type TreeseedIntegratedDevSurface, } from './dev';

package/dist/index.js

@@ -12,7 +12,6 @@ import {
 } from "./platform-resources.js";
 import { parseSiteConfig } from "./utils/site-config-schema.js";
 import { createTreeseedApiApp } from "./api/app.js";
-import { createTreeseedGatewayApp } from "./api/gateway.js";
 import { createRailwayTreeseedApiServer } from "./api/railway.js";
 import { resolveApiConfig } from "./api/config.js";
 import {
@@ -26,7 +25,6 @@ export {
   buildTreeseedSiteLayers,
   createRailwayTreeseedApiServer,
   createTreeseedApiApp,
-  createTreeseedGatewayApp,
   createTreeseedIntegratedDevPlan,
   parseSiteConfig,
   resolveApiConfig,

package/dist/scripts/test-smoke.js

@@ -174,7 +174,6 @@ try {
             'await import("@treeseed/core/runtime-types");',
             'await import("@treeseed/core/contracts/messages");',
             'await import("@treeseed/core/contracts/run");',
-            'await import("@treeseed/core/services/manager");',
             'await import("@treeseed/core/services/worker");',
             'await import("@treeseed/core/services/workday-start");',
             'await import("@treeseed/core/services/workday-report");',

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>;