@treeseed/sdk 0.4.8 → 0.4.9

package/README.md

@@ -168,7 +168,7 @@ const scoped = sdk.scopeForAgent({
 The package also exports:
 
 - workflow helpers such as `TreeseedWorkflowSdk`
-- gateway and queue clients such as `TreeseedGatewayClient` and `CloudflareQueuePullClient`
+- remote and queue clients such as `RemoteTreeseedClient`, `CloudflareQueuePullClient`, and `CloudflareQueuePushClient`
 - model registry, field, and filter utilities
 - plugin/runtime types and helpers
 

package/dist/dispatch.d.ts

@@ -0,0 +1,4 @@
+import type { SdkDispatchCapability, SdkDispatchNamespace } from './sdk-types.ts';
+export declare function listSdkDispatchCapabilities(): SdkDispatchCapability[];
+export declare function listWorkflowDispatchCapabilities(): SdkDispatchCapability[];
+export declare function findDispatchCapability(namespace: SdkDispatchNamespace, operation: string): SdkDispatchCapability | null;

package/dist/dispatch.js

@@ -0,0 +1,180 @@
+import {
+  findTreeseedOperation
+} from "./operations-registry.js";
+function capability(namespace, operation, options) {
+  return {
+    namespace,
+    operation,
+    executionClass: options.executionClass,
+    allowedTargets: options.allowedTargets,
+    defaultTarget: options.defaultTarget,
+    defaultDispatchMode: options.defaultDispatchMode ?? "auto",
+    summary: options.summary
+  };
+}
+const INLINE_PROJECT_API_SDK_OPERATIONS = [
+  "get",
+  "read",
+  "search",
+  "follow",
+  "pick",
+  "create",
+  "update",
+  "claimMessage",
+  "ackMessage",
+  "createMessage",
+  "recordRun",
+  "getCursor",
+  "upsertCursor",
+  "releaseLease",
+  "releaseAllLeases",
+  "startWorkDay",
+  "closeWorkDay",
+  "createTask",
+  "claimTask",
+  "recordTaskProgress",
+  "completeTask",
+  "failTask",
+  "appendTaskEvent",
+  "searchTasks",
+  "createReport",
+  "getManagerContext",
+  "listAgentSpecs",
+  "listRawAgentSpecs",
+  "searchFiles",
+  "searchSections",
+  "searchEntities",
+  "getGraphNode",
+  "getNeighbors",
+  "followReferences",
+  "getBacklinks",
+  "getRelated",
+  "getSubgraph",
+  "resolveSeeds",
+  "parseGraphDsl",
+  "resolveReference",
+  "explainReferenceChain"
+];
+const REMOTE_JOB_SDK_OPERATIONS = [
+  "refreshGraph",
+  "queryGraph",
+  "buildContextPack"
+];
+const LOCAL_ONLY_WORKFLOW_OPERATIONS = /* @__PURE__ */ new Set([
+  "init",
+  "config",
+  "auth:login",
+  "auth:logout",
+  "dev",
+  "dev:watch",
+  "mailpit:up",
+  "mailpit:down",
+  "mailpit:logs",
+  "d1:migrate:local",
+  "cleanup-markdown",
+  "cleanup-markdown:check",
+  "astro",
+  "sync-devvars",
+  "starlight:patch",
+  "build",
+  "check",
+  "preview",
+  "lint",
+  "test",
+  "test:unit"
+]);
+const REMOTE_JOB_WORKFLOW_OPERATIONS = /* @__PURE__ */ new Set([
+  "save",
+  "close",
+  "stage",
+  "release",
+  "rollback",
+  "destroy",
+  "sync",
+  "export",
+  "test:e2e",
+  "test:e2e:local",
+  "test:e2e:staging",
+  "test:e2e:full",
+  "test:fast",
+  "verify",
+  "publish:changed"
+]);
+const INLINE_WORKFLOW_OPERATIONS = /* @__PURE__ */ new Set([
+  "status",
+  "tasks",
+  "doctor",
+  "template",
+  "auth:whoami"
+]);
+const SDK_CAPABILITIES = [
+  ...INLINE_PROJECT_API_SDK_OPERATIONS.map((operation) => capability("sdk", operation, {
+    executionClass: "remote_inline",
+    allowedTargets: ["local", "project_api"],
+    defaultTarget: "project_api"
+  })),
+  ...REMOTE_JOB_SDK_OPERATIONS.map((operation) => capability("sdk", operation, {
+    executionClass: "remote_job",
+    allowedTargets: ["local", "project_api", "project_runner"],
+    defaultTarget: "project_runner",
+    defaultDispatchMode: "prefer_remote"
+  }))
+];
+const SDK_CAPABILITY_INDEX = new Map(
+  SDK_CAPABILITIES.map((entry) => [`${entry.namespace}:${entry.operation}`, entry])
+);
+function workflowCapability(operation) {
+  const resolved = findTreeseedOperation(operation);
+  if (!resolved) {
+    return null;
+  }
+  if (LOCAL_ONLY_WORKFLOW_OPERATIONS.has(resolved.name)) {
+    return capability("workflow", resolved.name, {
+      executionClass: "local_only",
+      allowedTargets: ["local"],
+      defaultTarget: "local"
+    });
+  }
+  if (REMOTE_JOB_WORKFLOW_OPERATIONS.has(resolved.name)) {
+    return capability("workflow", resolved.name, {
+      executionClass: "remote_job",
+      allowedTargets: ["local", "project_runner"],
+      defaultTarget: "project_runner",
+      defaultDispatchMode: "prefer_remote"
+    });
+  }
+  if (INLINE_WORKFLOW_OPERATIONS.has(resolved.name)) {
+    return capability("workflow", resolved.name, {
+      executionClass: "remote_inline",
+      allowedTargets: resolved.name === "template" ? ["local", "market_catalog", "project_api"] : ["local", "project_api"],
+      defaultTarget: resolved.name === "template" ? "market_catalog" : "project_api"
+    });
+  }
+  return capability("workflow", resolved.name, {
+    executionClass: "remote_job",
+    allowedTargets: ["local", "project_runner"],
+    defaultTarget: "project_runner",
+    defaultDispatchMode: "prefer_remote"
+  });
+}
+function listSdkDispatchCapabilities() {
+  return [...SDK_CAPABILITIES];
+}
+function listWorkflowDispatchCapabilities() {
+  return [
+    ...LOCAL_ONLY_WORKFLOW_OPERATIONS,
+    ...REMOTE_JOB_WORKFLOW_OPERATIONS,
+    ...INLINE_WORKFLOW_OPERATIONS
+  ].map((operation) => workflowCapability(operation)).filter((entry) => Boolean(entry));
+}
+function findDispatchCapability(namespace, operation) {
+  if (namespace === "sdk") {
+    return SDK_CAPABILITY_INDEX.get(`sdk:${operation}`) ?? null;
+  }
+  return workflowCapability(operation);
+}
+export {
+  findDispatchCapability,
+  listSdkDispatchCapabilities,
+  listWorkflowDispatchCapabilities
+};

package/dist/index.d.ts

@@ -4,16 +4,18 @@ export { parseGraphDsl } from './graph/dsl.ts';
 export { createDefaultGraphRankingProvider, DEFAULT_GRAPH_RANKING_PROVIDER } from './graph/ranking.ts';
 export { BUILTIN_MODEL_REGISTRY, MODEL_REGISTRY, buildBuiltinModelRegistry, buildModelRegistry, buildScopedModelRegistry, mergeModelRegistries, resolveModelDefinition, } from './model-registry.ts';
 export { normalizeAgentCliOptions, buildCopilotAllowToolArgs } from './cli-tools.ts';
+export { findDispatchCapability, listSdkDispatchCapabilities, listWorkflowDispatchCapabilities, } from './dispatch.ts';
+export { executeSdkOperation, findSdkOperation, listSdkOperationNames, } from './sdk-dispatch.ts';
 export { resolveSdkRecordVersion } from './sdk-version.ts';
 export { normalizeAliasedRecord, preprocessAliasedRecord, resolveAliasedField, } from './field-aliases.ts';
 export { canonicalizeFrontmatter, normalizeFilterFields, normalizeMutationData, normalizeRecordToCanonicalShape, normalizeSortFields, readCanonicalFieldValue, resolveModelField, validateModelFieldAliases, } from './sdk-fields.ts';
 export { RemoteTemplateCatalogClient, parseTemplateCatalogResponse } from './template-catalog.ts';
-export { TREESEED_REMOTE_CONTRACT_HEADER, TREESEED_REMOTE_CONTRACT_VERSION, CloudflareQueuePullClient, RemoteTreeseedClient, RemoteTreeseedAuthClient, RemoteTreeseedSdkClient, RemoteTreeseedOperationsClient, TreeseedGatewayClient, } from './remote.ts';
+export { TREESEED_REMOTE_CONTRACT_HEADER, TREESEED_REMOTE_CONTRACT_VERSION, CloudflareQueuePullClient, CloudflareQueuePushClient, RemoteTreeseedClient, RemoteTreeseedAuthClient, RemoteTreeseedDispatchClient, RemoteTreeseedJobsClient, RemoteTreeseedRunnerClient, RemoteTreeseedSdkClient, RemoteTreeseedOperationsClient, } from './remote.ts';
 export { TRESEED_OPERATION_SPECS, findTreeseedOperation, listTreeseedOperationNames, } from './operations-registry.ts';
 export { TreeseedOperationsSdk } from './operations/runtime.ts';
 export { TreeseedWorkflowSdk } from './workflow.ts';
 export { getTreeseedVerifyDriverStatus, runTreeseedVerifyDriver } from './verification.ts';
-export type { SdkContentEntry, SdkCursorEntity, SdkFilterCondition, SdkFollowRequest, SdkGraphEdge, SdkGraphEdgeType, SdkGraphDslRelation, SdkGraphDslParseResult, SdkGraphModelConfig, SdkGraphNode, SdkGraphNodeType, SdkGraphPathExplanation, SdkGraphQueryStage, SdkGraphQueryView, SdkGraphQueryOptions, SdkGraphQueryRequest, SdkGraphQueryResult, SdkGraphRankingBuildInput, SdkGraphRankingDiagnostics, SdkGraphRankingIndex, SdkGraphRankingNodeResult, SdkGraphRankingProvider, SdkGraphRankingQueryRequest, SdkGraphRankingQueryResult, SdkGraphRankingSearchRequest, SdkGraphRefreshPayload, SdkGraphRefreshRequest, SdkGraphSearchOptions, SdkGraphSearchResult, SdkGraphSeed, SdkGraphSeedResolution, SdkGraphTraversalResult, SdkGraphWhereFilter, SdkContextPack, SdkContextPackRequest, SdkGetRequest, SdkJsonEnvelope, SdkLeaseEntity, SdkManagerContextPayload, SdkMessageEntity, SdkModelFieldBinding, SdkModelDefinition, SdkModelRegistry, SdkModelName, SdkMutationRequest, SdkOperation, SdkPickRequest, SdkPickResult, SdkQueueMessageEnvelope, SdkRunEntity, SdkSearchRequest, SdkTaskEntity, SdkTaskEventEntity, SdkTaskOutputEntity, SdkWorkDayEntity, SdkGraphRunEntity, SdkReportEntity, SdkSubscriptionEntity, SdkTemplateCatalogEntry, SdkTemplateCatalogPublisher, SdkTemplateCatalogResponse, SdkTemplateCatalogSource, SdkUpdateRequest, } from './sdk-types.ts';
+export type { SdkContentEntry, SdkDispatchCapability, SdkDispatchConfig, SdkDispatchCredentialSource, SdkDispatchExecutionClass, SdkDispatchNamespace, SdkDispatchPolicy, SdkDispatchRequest, SdkDispatchResult, SdkDispatchTarget, SdkCursorEntity, SdkFilterCondition, SdkFollowRequest, SdkGraphEdge, SdkGraphEdgeType, SdkGraphDslRelation, SdkGraphDslParseResult, SdkGraphModelConfig, SdkGraphNode, SdkGraphNodeType, SdkGraphPathExplanation, SdkGraphQueryStage, SdkGraphQueryView, SdkGraphQueryOptions, SdkGraphQueryRequest, SdkGraphQueryResult, SdkGraphRankingBuildInput, SdkGraphRankingDiagnostics, SdkGraphRankingIndex, SdkGraphRankingNodeResult, SdkGraphRankingProvider, SdkGraphRankingQueryRequest, SdkGraphRankingQueryResult, SdkGraphRankingSearchRequest, SdkGraphRefreshPayload, SdkGraphRefreshRequest, SdkGraphSearchOptions, SdkGraphSearchResult, SdkGraphSeed, SdkGraphSeedResolution, SdkGraphTraversalResult, SdkGraphWhereFilter, SdkContextPack, SdkContextPackRequest, SdkGetRequest, SdkJsonEnvelope, SdkLeaseEntity, SdkManagerContextPayload, SdkMessageEntity, SdkModelFieldBinding, SdkModelDefinition, SdkModelRegistry, SdkModelName, SdkMutationRequest, SdkOperation, SdkPickRequest, SdkPickResult, SdkQueueMessageEnvelope, SdkRunEntity, SdkSearchRequest, SdkTaskEntity, SdkTaskEventEntity, SdkTaskOutputEntity, SdkWorkDayEntity, SdkGraphRunEntity, SdkReportEntity, SdkSubscriptionEntity, SdkTemplateCatalogEntry, SdkTemplateCatalogPublisher, SdkTemplateCatalogResponse, SdkTemplateCatalogSource, SdkUpdateRequest, ProjectCapabilityGrant, ProjectConnection, ProjectConnectionMode, ProjectExecutionOwner, ProjectRunnerRegistrationState, RemoteJob, RemoteJobEvent, RemoteJobStatus, } from './sdk-types.ts';
 export type { TreeseedFieldAliasBinding, TreeseedFieldAliasRegistry, } from './field-aliases.ts';
 export type * from './operations-types.ts';
 export type * from './workflow.ts';

package/dist/index.js

@@ -12,6 +12,16 @@ import {
   resolveModelDefinition
 } from "./model-registry.js";
 import { normalizeAgentCliOptions, buildCopilotAllowToolArgs } from "./cli-tools.js";
+import {
+  findDispatchCapability,
+  listSdkDispatchCapabilities,
+  listWorkflowDispatchCapabilities
+} from "./dispatch.js";
+import {
+  executeSdkOperation,
+  findSdkOperation,
+  listSdkOperationNames
+} from "./sdk-dispatch.js";
 import { resolveSdkRecordVersion } from "./sdk-version.js";
 import {
   normalizeAliasedRecord,
@@ -33,11 +43,14 @@ import {
   TREESEED_REMOTE_CONTRACT_HEADER,
   TREESEED_REMOTE_CONTRACT_VERSION,
   CloudflareQueuePullClient,
+  CloudflareQueuePushClient,
   RemoteTreeseedClient,
   RemoteTreeseedAuthClient,
+  RemoteTreeseedDispatchClient,
+  RemoteTreeseedJobsClient,
+  RemoteTreeseedRunnerClient,
   RemoteTreeseedSdkClient,
-  RemoteTreeseedOperationsClient,
-  TreeseedGatewayClient
+  RemoteTreeseedOperationsClient
 } from "./remote.js";
 import {
   TRESEED_OPERATION_SPECS,
@@ -53,19 +66,22 @@ export {
   BUILTIN_MODEL_REGISTRY,
   CloudflareHttpD1Database,
   CloudflareQueuePullClient,
+  CloudflareQueuePushClient,
   ContentGraphRuntime,
   DEFAULT_GRAPH_RANKING_PROVIDER,
   MODEL_REGISTRY,
   RemoteTemplateCatalogClient,
   RemoteTreeseedAuthClient,
   RemoteTreeseedClient,
+  RemoteTreeseedDispatchClient,
+  RemoteTreeseedJobsClient,
   RemoteTreeseedOperationsClient,
+  RemoteTreeseedRunnerClient,
   RemoteTreeseedSdkClient,
   ScopedAgentSdk,
   TREESEED_REMOTE_CONTRACT_HEADER,
   TREESEED_REMOTE_CONTRACT_VERSION,
   TRESEED_OPERATION_SPECS,
-  TreeseedGatewayClient,
   TreeseedOperationsSdk,
   TreeseedWorkflowSdk,
   buildBuiltinModelRegistry,
@@ -74,9 +90,15 @@ export {
   buildScopedModelRegistry,
   canonicalizeFrontmatter,
   createDefaultGraphRankingProvider,
+  executeSdkOperation,
+  findDispatchCapability,
+  findSdkOperation,
   findTreeseedOperation,
   getTreeseedVerifyDriverStatus,
+  listSdkDispatchCapabilities,
+  listSdkOperationNames,
   listTreeseedOperationNames,
+  listWorkflowDispatchCapabilities,
   mergeModelRegistries,
   normalizeAgentCliOptions,
   normalizeAliasedRecord,

package/dist/operations/services/config-runtime.js

@@ -1181,14 +1181,14 @@ function syncTreeseedRailwayEnvironment({ tenantRoot, scope = "prod", dryRun = f
   const values = resolveTreeseedMachineEnvironmentValues(tenantRoot, scope);
   const registry = collectTreeseedEnvironmentContext(tenantRoot);
   const railwaySecretNames = registry.entries.filter((entry) => entry.scopes.includes(scope) && entry.targets.includes("railway-secret")).map((entry) => entry.id).filter((key) => typeof values[key] === "string" && values[key].length > 0);
-  const services = ["api", "agents", "manager", "worker", "workdayStart", "workdayReport"].map((serviceKey) => {
+  const services = ["api", "agents", "manager", "worker", "runner", "workdayStart", "workdayReport"].map((serviceKey) => {
     const service = deployConfig.services?.[serviceKey];
     if (!service || service.enabled === false || (service.provider ?? "railway") !== "railway") {
       return null;
     }
     const environment = service.environments?.[scope];
     const fallbackServiceName = serviceKey === "api" ? config.settings.services.railway.apiServiceName : serviceKey === "agents" ? config.settings.services.railway.agentsServiceName : "";
-    const defaultRootDir = ["api", "manager", "worker", "workdayStart", "workdayReport"].includes(serviceKey) ? "." : "packages/core";
+    const defaultRootDir = ["api", "manager", "worker", "runner", "workdayStart", "workdayReport"].includes(serviceKey) ? "." : "packages/core";
     return {
       service: serviceKey,
       projectName: service.railway?.projectName ?? config.settings.services.railway.projectName,

package/dist/operations/services/deploy.d.ts

@@ -23,7 +23,6 @@ export declare function ensureGeneratedWranglerConfig(tenantRoot: any, options?:
         cloudflare: {
             accountId: string;
             workerName: string | undefined;
-            gatewayWorkerName: string | undefined;
             queueName: string | undefined;
             dlqName: string | undefined;
             d1Binding: string | undefined;
@@ -126,7 +125,6 @@ export declare function validateDeployPrerequisites(tenantRoot: any, { requireRe
     cloudflare: {
         accountId: string;
         workerName: string | undefined;
-        gatewayWorkerName: string | undefined;
         queueName: string | undefined;
         dlqName: string | undefined;
         d1Binding: string | undefined;
@@ -210,7 +208,6 @@ export declare function validateDestroyPrerequisites(tenantRoot: any, { requireR
     cloudflare: {
         accountId: string;
         workerName: string | undefined;
-        gatewayWorkerName: string | undefined;
         queueName: string | undefined;
         dlqName: string | undefined;
         d1Binding: string | undefined;

package/dist/operations/services/deploy.js

@@ -10,7 +10,7 @@ const DEFAULT_COMPATIBILITY_FLAGS = ["nodejs_compat"];
 const GENERATED_ROOT = ".treeseed/generated";
 const STATE_ROOT = ".treeseed/state";
 const PERSISTENT_SCOPES = /* @__PURE__ */ new Set(["local", "staging", "prod"]);
-const MANAGED_SERVICE_KEYS = ["api", "agents", "gateway", "manager", "worker", "workdayStart", "workdayReport"];
+const MANAGED_SERVICE_KEYS = ["api", "agents", "manager", "worker", "runner", "workdayStart", "workdayReport"];
 const TRESEED_ENVELOPE_SCHEMA_GENERATION = "runtime-envelopes-v1";
 const TRESEED_MIGRATION_WAVE_ID = "0005_runtime_envelopes";
 const TRESEED_SUPPORTED_PAYLOAD_RANGE = { min: 1, max: 1 };

package/dist/operations/services/railway-deploy.js

@@ -5,7 +5,7 @@ import { loadCliDeployConfig } from "./runtime-tools.js";
 function normalizeScope(scope) {
   return scope === "prod" ? "prod" : scope === "staging" ? "staging" : "local";
 }
-const RAILWAY_SERVICE_KEYS = ["api", "agents", "manager", "worker", "workdayStart", "workdayReport"];
+const RAILWAY_SERVICE_KEYS = ["api", "agents", "manager", "worker", "runner", "workdayStart", "workdayReport"];
 function runRailway(args, { cwd, capture = false, allowFailure = false } = {}) {
   const result = spawnSync("railway", args, {
     cwd,
@@ -26,7 +26,7 @@ function configuredRailwayServices(tenantRoot, scope) {
     if (!service || service.enabled === false || (service.provider ?? "railway") !== "railway") {
       return null;
     }
-    const defaultRootDir = ["api", "manager", "worker", "workdayStart", "workdayReport"].includes(serviceKey) ? "." : "packages/core";
+    const defaultRootDir = ["api", "manager", "worker", "runner", "workdayStart", "workdayReport"].includes(serviceKey) ? "." : "packages/core";
     const serviceRoot = resolve(tenantRoot, service.railway?.rootDir ?? service.rootDir ?? defaultRootDir);
     const railwayEnvironment = service.environments?.[normalizedScope]?.railwayEnvironment ?? normalizedScope;
     const publicBaseUrl = service.environments?.[normalizedScope]?.baseUrl ?? service.publicBaseUrl ?? null;

package/dist/operations/services/runtime-tools.d.ts

@@ -38,7 +38,6 @@ export declare function loadCliDeployConfig(tenantRoot: any): {
     cloudflare: {
         accountId: string;
         workerName: string | undefined;
-        gatewayWorkerName: string | undefined;
         queueName: string | undefined;
         dlqName: string | undefined;
         d1Binding: string | undefined;

package/dist/operations/services/runtime-tools.js

@@ -50,7 +50,7 @@ const TREESEED_DEFAULT_PROVIDER_SELECTIONS = {
   },
   site: "default"
 };
-const TRESEED_MANAGED_SERVICE_KEYS = ["api", "agents", "gateway", "manager", "worker", "workdayStart", "workdayReport"];
+const TRESEED_MANAGED_SERVICE_KEYS = ["api", "agents", "manager", "worker", "runner", "workdayStart", "workdayReport"];
 const TRESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "core", "cli"];
 const CLOUDFLARE_ACCOUNT_ID_PLACEHOLDER = "replace-with-cloudflare-account-id";
 function parseServiceEnvironmentConfig(value) {
@@ -301,7 +301,6 @@ function parseFallbackDeployConfig(configPath) {
     cloudflare: {
       accountId: optionalCloudflareAccountId(cloudflare.accountId) ?? optionalCloudflareAccountId(process.env.CLOUDFLARE_ACCOUNT_ID) ?? CLOUDFLARE_ACCOUNT_ID_PLACEHOLDER,
       workerName: optionalString(cloudflare.workerName),
-      gatewayWorkerName: optionalString(cloudflare.gatewayWorkerName),
       queueName: optionalString(cloudflare.queueName),
       dlqName: optionalString(cloudflare.dlqName),
       d1Binding: optionalString(cloudflare.d1Binding),

package/dist/platform/contracts.d.ts

@@ -83,7 +83,7 @@ export interface TreeseedPluginReference {
     enabled?: boolean;
     config?: Record<string, unknown>;
 }
-export type TreeseedPlatformSurfaceName = 'web' | 'api' | 'gateway' | (string & {});
+export type TreeseedPlatformSurfaceName = 'web' | 'api' | (string & {});
 export type TreeseedPlatformResourceKind = 'pages' | 'styles' | 'components' | 'routes' | 'middleware' | 'handlers' | 'config';
 export interface TreeseedPlatformLayerDefinition {
     root: string;
@@ -135,7 +135,6 @@ export interface TreeseedManagedServicesConfig {
 export interface TreeseedPlatformSurfacesConfig {
     web?: TreeseedPlatformSurfaceConfig;
     api?: TreeseedPlatformSurfaceConfig;
-    gateway?: TreeseedPlatformSurfaceConfig;
     [key: string]: TreeseedPlatformSurfaceConfig | undefined;
 }
 export interface TreeseedProviderSelections {

package/dist/remote.d.ts

@@ -1,3 +1,4 @@
+import type { RemoteJob, RemoteJobEvent, SdkDispatchRequest, SdkDispatchResult } from './sdk-types.ts';
 export declare const TREESEED_REMOTE_CONTRACT_VERSION = 1;
 export declare const TREESEED_REMOTE_CONTRACT_HEADER = "x-treeseed-remote-contract-version";
 export type ApiScope = string;
@@ -111,6 +112,25 @@ export interface RemoteWorkflowOperationResponse {
     payload?: Record<string, unknown> | null;
     nextSteps?: RemoteWorkflowNextStep[];
 }
+export interface RemoteJobPullRequest {
+    limit?: number;
+    runnerId?: string;
+}
+export interface RemoteJobPullResponse {
+    ok: true;
+    payload: RemoteJob[];
+}
+export interface RemoteJobProgressRequest {
+    summary?: string;
+    data?: Record<string, unknown>;
+}
+export interface RemoteJobCompletionRequest {
+    output?: unknown;
+}
+export interface RemoteJobFailureRequest {
+    code?: string;
+    message: string;
+}
 export declare class RemoteTreeseedClient {
     readonly config: RemoteTreeseedConfig;
     private readonly fetchImpl;
@@ -141,15 +161,6 @@ export declare class RemoteTreeseedSdkClient {
     constructor(client: RemoteTreeseedClient);
     execute<T = unknown>(operation: string, request: RemoteSdkOperationRequest): Promise<T>;
 }
-export declare class TreeseedGatewayClient {
-    private readonly baseUrl;
-    private readonly token;
-    private readonly fetchImpl;
-    constructor(config: import('./sdk-types.ts').SdkGatewayClientConfig);
-    requestJson<T>(path: string, options?: RemoteGatewayRequest): Promise<T & {
-        error?: string;
-    }>;
-}
 export declare class CloudflareQueuePullClient {
     private readonly baseUrl;
     private readonly token;
@@ -170,8 +181,53 @@ export declare class CloudflareQueuePullClient {
         delaySeconds?: number;
     }>): Promise<unknown>;
 }
+export declare class CloudflareQueuePushClient {
+    private readonly baseUrl;
+    private readonly token;
+    private readonly fetchImpl;
+    constructor(config: import('./sdk-types.ts').SdkQueuePushClientConfig);
+    enqueue(request: import('./sdk-types.ts').SdkQueuePushRequest): Promise<void>;
+}
 export declare class RemoteTreeseedOperationsClient {
     private readonly client;
     constructor(client: RemoteTreeseedClient);
     execute(operation: string, request: RemoteWorkflowOperationRequest): Promise<RemoteWorkflowOperationResponse>;
 }
+export declare class RemoteTreeseedDispatchClient {
+    private readonly client;
+    constructor(client: RemoteTreeseedClient);
+    dispatch(projectId: string, request: SdkDispatchRequest): Promise<SdkDispatchResult>;
+}
+export declare class RemoteTreeseedJobsClient {
+    private readonly client;
+    constructor(client: RemoteTreeseedClient);
+    get(jobId: string): Promise<{
+        ok: true;
+        payload: RemoteJob;
+    }>;
+    cancel(jobId: string): Promise<{
+        ok: true;
+        payload: RemoteJob;
+    }>;
+    events(jobId: string): Promise<{
+        ok: true;
+        payload: RemoteJobEvent[];
+    }>;
+}
+export declare class RemoteTreeseedRunnerClient {
+    private readonly client;
+    constructor(client: RemoteTreeseedClient);
+    pull(projectId: string, request?: RemoteJobPullRequest): Promise<RemoteJobPullResponse>;
+    progress(jobId: string, request?: RemoteJobProgressRequest): Promise<{
+        ok: true;
+        payload: RemoteJob;
+    }>;
+    complete(jobId: string, request?: RemoteJobCompletionRequest): Promise<{
+        ok: true;
+        payload: RemoteJob;
+    }>;
+    fail(jobId: string, request: RemoteJobFailureRequest): Promise<{
+        ok: true;
+        payload: RemoteJob;
+    }>;
+}

package/dist/remote.js

@@ -100,32 +100,6 @@ class RemoteTreeseedSdkClient {
 function normalizeExternalBaseUrl(baseUrl) {
   return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
 }
-class TreeseedGatewayClient {
-  baseUrl;
-  token;
-  fetchImpl;
-  constructor(config) {
-    this.baseUrl = normalizeExternalBaseUrl(config.baseUrl);
-    this.token = config.bearerToken;
-    this.fetchImpl = config.fetchImpl ?? fetch;
-  }
-  async requestJson(path, options = {}) {
-    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
-      method: options.method ?? "POST",
-      headers: {
-        accept: "application/json",
-        authorization: `Bearer ${this.token}`,
-        ...options.body === void 0 ? {} : { "content-type": "application/json" }
-      },
-      body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
-    });
-    const payload = await response.json().catch(() => ({}));
-    if (!response.ok) {
-      throw new Error(typeof payload.error === "string" ? payload.error : `Gateway request failed with ${response.status}.`);
-    }
-    return payload;
-  }
-}
 class CloudflareQueuePullClient {
   baseUrl;
   token;
@@ -177,6 +151,36 @@ class CloudflareQueuePullClient {
     });
   }
 }
+class CloudflareQueuePushClient {
+  baseUrl;
+  token;
+  fetchImpl;
+  constructor(config) {
+    const apiBaseUrl = config.apiBaseUrl ?? "https://api.cloudflare.com/client/v4/accounts";
+    this.baseUrl = `${normalizeExternalBaseUrl(apiBaseUrl)}/${config.accountId}/queues/${config.queueId}`;
+    this.token = config.token;
+    this.fetchImpl = config.fetchImpl ?? fetch;
+  }
+  async enqueue(request) {
+    const response = await this.fetchImpl(`${this.baseUrl}/messages`, {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${this.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}.`);
+    }
+  }
+}
 class RemoteTreeseedOperationsClient {
   constructor(client) {
     this.client = client;
@@ -190,13 +194,85 @@ class RemoteTreeseedOperationsClient {
     });
   }
 }
+class RemoteTreeseedDispatchClient {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  dispatch(projectId, request) {
+    return this.client.requestJson(`/v1/projects/${encodeURIComponent(projectId)}/dispatch`, {
+      method: "POST",
+      body: request,
+      requireAuth: true
+    });
+  }
+}
+class RemoteTreeseedJobsClient {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  get(jobId) {
+    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}`, {
+      requireAuth: true
+    });
+  }
+  cancel(jobId) {
+    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/cancel`, {
+      method: "POST",
+      requireAuth: true
+    });
+  }
+  events(jobId) {
+    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/events`, {
+      requireAuth: true
+    });
+  }
+}
+class RemoteTreeseedRunnerClient {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  pull(projectId, request = {}) {
+    return this.client.requestJson(`/v1/projects/${encodeURIComponent(projectId)}/runner/jobs/pull`, {
+      method: "POST",
+      body: request,
+      requireAuth: true
+    });
+  }
+  progress(jobId, request = {}) {
+    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/progress`, {
+      method: "POST",
+      body: request,
+      requireAuth: true
+    });
+  }
+  complete(jobId, request = {}) {
+    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/complete`, {
+      method: "POST",
+      body: request,
+      requireAuth: true
+    });
+  }
+  fail(jobId, request) {
+    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/fail`, {
+      method: "POST",
+      body: request,
+      requireAuth: true
+    });
+  }
+}
 export {
   CloudflareQueuePullClient,
+  CloudflareQueuePushClient,
   RemoteTreeseedAuthClient,
   RemoteTreeseedClient,
+  RemoteTreeseedDispatchClient,
+  RemoteTreeseedJobsClient,
   RemoteTreeseedOperationsClient,
+  RemoteTreeseedRunnerClient,
   RemoteTreeseedSdkClient,
   TREESEED_REMOTE_CONTRACT_HEADER,
-  TREESEED_REMOTE_CONTRACT_VERSION,
-  TreeseedGatewayClient
+  TREESEED_REMOTE_CONTRACT_VERSION
 };

package/dist/sdk-dispatch.d.ts

@@ -0,0 +1,12 @@
+import type { AgentSdk } from './sdk.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 | null;
+export declare function executeSdkOperation(sdk: AgentSdk, operationName: string, input: JsonRecord): Promise<unknown>;
+export {};

package/dist/sdk-dispatch.js

@@ -0,0 +1,142 @@
+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: "listRawAgentSpecs",
+    aliases: ["list-raw-agent-specs"],
+    handler: (sdk, input) => sdk.listRawAgentSpecs(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;
+}
+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,
+  listSdkOperationNames
+};

package/dist/sdk-types.d.ts

@@ -3,12 +3,139 @@ export declare const SDK_MODEL_NAMES: readonly ["page", "note", "question", "boo
 export declare const SDK_OPERATIONS: readonly ["get", "read", "search", "follow", "pick", "create", "update"];
 export declare const SDK_STORAGE_BACKENDS: readonly ["content", "d1"];
 export declare const SDK_PICK_STRATEGIES: readonly ["latest", "highest_priority", "oldest"];
+export declare const SDK_DISPATCH_EXECUTION_CLASSES: readonly ["local_only", "remote_inline", "remote_job"];
+export declare const SDK_DISPATCH_TARGETS: readonly ["local", "project_api", "project_runner", "market_catalog"];
+export declare const SDK_DISPATCH_POLICIES: readonly ["auto", "prefer_local", "prefer_remote", "remote_only"];
+export declare const SDK_DISPATCH_NAMESPACES: readonly ["sdk", "workflow"];
+export declare const PROJECT_CONNECTION_MODES: readonly ["hosted", "self_hosted", "hybrid"];
+export declare const PROJECT_RUNNER_REGISTRATION_STATES: readonly ["pending", "registered", "offline"];
+export declare const PROJECT_EXECUTION_OWNERS: readonly ["project_api", "project_runner", "market"];
+export declare const REMOTE_JOB_STATUSES: readonly ["pending", "claimed", "running", "completed", "failed", "cancelled"];
 export type SdkBuiltinModelName = (typeof SDK_MODEL_NAMES)[number];
 export type SdkModelName = SdkBuiltinModelName | (string & {});
 export type SdkOperation = (typeof SDK_OPERATIONS)[number];
 export type SdkStorageBackend = (typeof SDK_STORAGE_BACKENDS)[number];
 export type SdkPickStrategy = (typeof SDK_PICK_STRATEGIES)[number];
 export type SdkComparableAs = 'string' | 'number' | 'date' | 'boolean' | 'string_array';
+export type SdkDispatchExecutionClass = (typeof SDK_DISPATCH_EXECUTION_CLASSES)[number];
+export type SdkDispatchTarget = (typeof SDK_DISPATCH_TARGETS)[number];
+export type SdkDispatchPolicy = (typeof SDK_DISPATCH_POLICIES)[number];
+export type SdkDispatchNamespace = (typeof SDK_DISPATCH_NAMESPACES)[number];
+export type ProjectConnectionMode = (typeof PROJECT_CONNECTION_MODES)[number];
+export type ProjectRunnerRegistrationState = (typeof PROJECT_RUNNER_REGISTRATION_STATES)[number];
+export type ProjectExecutionOwner = (typeof PROJECT_EXECUTION_OWNERS)[number];
+export type RemoteJobStatus = (typeof REMOTE_JOB_STATUSES)[number];
+export type RemoteJobRequestedByType = 'user' | 'team_api_key' | 'service' | 'runner' | 'system';
+export interface SdkDispatchCapability {
+    namespace: SdkDispatchNamespace;
+    operation: string;
+    executionClass: SdkDispatchExecutionClass;
+    allowedTargets: SdkDispatchTarget[];
+    defaultTarget: SdkDispatchTarget;
+    defaultDispatchMode: SdkDispatchPolicy;
+    summary?: string;
+}
+export interface ProjectConnection {
+    id: string;
+    projectId: string;
+    mode: ProjectConnectionMode;
+    projectApiBaseUrl: string | null;
+    runnerRegistrationState: ProjectRunnerRegistrationState;
+    executionOwner: ProjectExecutionOwner;
+    runnerRegisteredAt: string | null;
+    runnerLastSeenAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ProjectCapabilityGrant {
+    id: string;
+    projectId: string;
+    namespace: SdkDispatchNamespace;
+    operation: string;
+    executionClass: SdkDispatchExecutionClass;
+    allowedTargets: SdkDispatchTarget[];
+    defaultDispatchMode: SdkDispatchPolicy;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RemoteJobError {
+    code?: string | null;
+    message: string;
+}
+export interface RemoteJob {
+    id: string;
+    projectId: string;
+    namespace: SdkDispatchNamespace;
+    operation: string;
+    status: RemoteJobStatus;
+    preferredMode: SdkDispatchPolicy;
+    selectedTarget: SdkDispatchTarget;
+    input: Record<string, unknown>;
+    output?: unknown;
+    error?: RemoteJobError | null;
+    requestedByType: RemoteJobRequestedByType;
+    requestedById: string | null;
+    assignedRunnerId: string | null;
+    idempotencyKey: string | null;
+    capability?: SdkDispatchCapability | null;
+    pollUrl?: string | null;
+    streamUrl?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+    cancelledAt: string | null;
+}
+export interface RemoteJobEvent {
+    id: string;
+    jobId: string;
+    seq: number;
+    kind: string;
+    data?: Record<string, unknown>;
+    createdAt: string;
+}
+export interface SdkDispatchRequest {
+    namespace?: SdkDispatchNamespace;
+    operation: string;
+    input?: Record<string, unknown>;
+    preferredMode?: SdkDispatchPolicy;
+    idempotencyKey?: string;
+}
+export interface SdkDispatchInlineResult {
+    ok: true;
+    mode: 'inline';
+    namespace: SdkDispatchNamespace;
+    operation: string;
+    target: SdkDispatchTarget;
+    capability: SdkDispatchCapability;
+    payload: unknown;
+}
+export interface SdkDispatchJobResult {
+    ok: true;
+    mode: 'job';
+    namespace: SdkDispatchNamespace;
+    operation: string;
+    target: SdkDispatchTarget;
+    capability: SdkDispatchCapability;
+    job: RemoteJob;
+}
+export type SdkDispatchResult = SdkDispatchInlineResult | SdkDispatchJobResult;
+export type SdkDispatchCredentialSource = {
+    type: 'bearer';
+    token: string;
+} | {
+    type: 'resolver';
+    resolveToken: () => Promise<string | null> | string | null;
+};
+export interface SdkDispatchConfig {
+    projectId: string;
+    marketBaseUrl: string;
+    policy?: SdkDispatchPolicy;
+    credentialSource?: SdkDispatchCredentialSource;
+    fetchImpl?: typeof fetch;
+}
 export type SdkFilterOperator = 'eq' | 'in' | 'contains' | 'prefix' | 'gt' | 'gte' | 'lt' | 'lte' | 'updated_since' | 'related_to';
 export type TreeseedSchemaVersion = number;
 export type TreeseedRuntimeRecordType = 'subscription' | 'contact_submission' | 'agent_run' | 'message' | 'agent_cursor' | 'content_lease' | 'work_day' | 'task' | 'task_event' | 'task_output' | 'graph_run' | 'report';
@@ -701,12 +828,14 @@ export interface SdkManagerContextPayload {
     agent: Record<string, unknown> | null;
     graph: Record<string, unknown> | null;
 }
-export interface SdkGatewayClientConfig {
-    baseUrl: string;
-    bearerToken: string;
+export interface SdkQueuePullClientConfig {
+    accountId: string;
+    queueId: string;
+    token: string;
+    apiBaseUrl?: string;
     fetchImpl?: typeof fetch;
 }
-export interface SdkQueuePullClientConfig {
+export interface SdkQueuePushClientConfig {
     accountId: string;
     queueId: string;
     token: string;
@@ -738,6 +867,10 @@ export interface SdkPulledQueueMessage {
 export interface SdkQueuePullResult {
     messages: SdkPulledQueueMessage[];
 }
+export interface SdkQueuePushRequest {
+    message: SdkQueueMessageEnvelope;
+    delaySeconds?: number;
+}
 export interface SdkFollowResult<TItem> {
     items: TItem[];
     since: string;

package/dist/sdk-types.js

@@ -22,7 +22,23 @@ const SDK_MODEL_NAMES = [
 const SDK_OPERATIONS = ["get", "read", "search", "follow", "pick", "create", "update"];
 const SDK_STORAGE_BACKENDS = ["content", "d1"];
 const SDK_PICK_STRATEGIES = ["latest", "highest_priority", "oldest"];
+const SDK_DISPATCH_EXECUTION_CLASSES = ["local_only", "remote_inline", "remote_job"];
+const SDK_DISPATCH_TARGETS = ["local", "project_api", "project_runner", "market_catalog"];
+const SDK_DISPATCH_POLICIES = ["auto", "prefer_local", "prefer_remote", "remote_only"];
+const SDK_DISPATCH_NAMESPACES = ["sdk", "workflow"];
+const PROJECT_CONNECTION_MODES = ["hosted", "self_hosted", "hybrid"];
+const PROJECT_RUNNER_REGISTRATION_STATES = ["pending", "registered", "offline"];
+const PROJECT_EXECUTION_OWNERS = ["project_api", "project_runner", "market"];
+const REMOTE_JOB_STATUSES = ["pending", "claimed", "running", "completed", "failed", "cancelled"];
 export {
+  PROJECT_CONNECTION_MODES,
+  PROJECT_EXECUTION_OWNERS,
+  PROJECT_RUNNER_REGISTRATION_STATES,
+  REMOTE_JOB_STATUSES,
+  SDK_DISPATCH_EXECUTION_CLASSES,
+  SDK_DISPATCH_NAMESPACES,
+  SDK_DISPATCH_POLICIES,
+  SDK_DISPATCH_TARGETS,
   SDK_MODEL_NAMES,
   SDK_OPERATIONS,
   SDK_PICK_STRATEGIES,

package/dist/sdk.d.ts

@@ -2,7 +2,7 @@ import type { AgentPermissionConfig, AgentRuntimeSpec } from './types/agents.ts'
 import { ContentStore } from './content-store.ts';
 import { type AgentDatabase } from './d1-store.ts';
 import { type LoadedTreeseedPluginEntry } from './platform/plugins.ts';
-import type { SdkAckMessageRequest, SdkClaimMessageRequest, SdkClaimTaskRequest, SdkCloseWorkDayRequest, SdkCompleteTaskRequest, SdkCreateReportRequest, SdkCreateMessageRequest, SdkCreateTaskRequest, SdkCursorRequest, SdkFailTaskRequest, SdkFollowRequest, SdkGetRequest, SdkGetCursorRequest, SdkJsonEnvelope, SdkLeaseReleaseRequest, SdkManagerContextPayload, SdkMutationRequest, SdkGraphQueryOptions, SdkGraphQueryRequest, SdkGraphRefreshRequest, SdkGraphSearchOptions, SdkContextPackRequest, SdkGraphDslParseResult, SdkPickRequest, SdkRecordRunRequest, SdkSearchRequest, SdkStartWorkDayRequest, SdkTaskProgressRequest, SdkTaskSearchRequest, SdkUpdateRequest, SdkModelDefinition, SdkModelRegistry, SdkGraphRankingProvider } from './sdk-types.ts';
+import type { SdkAckMessageRequest, SdkClaimMessageRequest, SdkClaimTaskRequest, SdkCloseWorkDayRequest, SdkCompleteTaskRequest, SdkCreateReportRequest, SdkCreateMessageRequest, SdkCreateTaskRequest, SdkCursorRequest, SdkFailTaskRequest, SdkFollowRequest, SdkGetRequest, SdkGetCursorRequest, SdkJsonEnvelope, SdkLeaseReleaseRequest, SdkManagerContextPayload, SdkMutationRequest, SdkGraphQueryOptions, SdkGraphQueryRequest, SdkGraphRefreshRequest, SdkGraphSearchOptions, SdkContextPackRequest, SdkGraphDslParseResult, SdkPickRequest, SdkRecordRunRequest, SdkSearchRequest, SdkStartWorkDayRequest, SdkTaskProgressRequest, SdkTaskSearchRequest, SdkUpdateRequest, SdkModelDefinition, SdkModelRegistry, SdkGraphRankingProvider, SdkDispatchConfig, SdkDispatchRequest, SdkDispatchResult } from './sdk-types.ts';
 export interface AgentSdkOptions {
     repoRoot?: string;
     database?: AgentDatabase;
@@ -10,12 +10,15 @@ export interface AgentSdkOptions {
     modelRegistry?: SdkModelRegistry;
     graphRankingProvider?: SdkGraphRankingProvider;
     plugins?: LoadedTreeseedPluginEntry[];
+    dispatch?: SdkDispatchConfig;
 }
 export declare class AgentSdk {
+    readonly repoRoot: string;
     readonly database: AgentDatabase;
     readonly content: ContentStore;
     readonly models: SdkModelRegistry;
     private readonly graph;
+    private readonly dispatchConfig?;
     constructor(options?: AgentSdkOptions);
     static createLocal(options: {
         repoRoot?: string;
@@ -24,6 +27,9 @@ export declare class AgentSdk {
         models?: SdkModelDefinition[];
         modelRegistry?: SdkModelRegistry;
     }): AgentSdk;
+    private resolveDispatchToken;
+    private executeDispatchLocally;
+    dispatch(request: SdkDispatchRequest): Promise<SdkDispatchResult>;
     private envelope;
     get(request: SdkGetRequest): Promise<SdkJsonEnvelope<Record<string, unknown> | import("./sdk-types.ts").SdkContentEntry | null>>;
     read(request: SdkGetRequest): Promise<{

package/dist/sdk.js

@@ -5,6 +5,10 @@ import { CloudflareD1AgentDatabase, MemoryAgentDatabase } from "./d1-store.js";
 import { ContentGraphRuntime } from "./graph.js";
 import { loadTreeseedPlugins } from "./platform/plugins.js";
 import { buildScopedModelRegistry, resolveModelDefinition } from "./model-registry.js";
+import { findDispatchCapability } from "./dispatch.js";
+import { RemoteTreeseedClient, RemoteTreeseedDispatchClient } from "./remote.js";
+import { executeSdkOperation } from "./sdk-dispatch.js";
+import { TreeseedOperationsSdk } from "./operations/runtime.js";
 import { WranglerD1Database } from "./wrangler-d1.js";
 function normalizeAgentSpec(entry) {
   if (!entry) {
@@ -27,12 +31,15 @@ function operationAllowed(permissions, model, operation) {
   );
 }
 class AgentSdk {
+  repoRoot;
   database;
   content;
   models;
   graph;
+  dispatchConfig;
   constructor(options = {}) {
     const repoRoot = resolveSdkRepoRoot(options.repoRoot);
+    this.repoRoot = repoRoot;
     this.models = options.modelRegistry ?? buildScopedModelRegistry(repoRoot, options.models);
     this.database = options.database ?? new MemoryAgentDatabase();
     this.content = new ContentStore(repoRoot, this.database, this.models);
@@ -48,6 +55,7 @@ class AgentSdk {
       rankingProvider: options.graphRankingProvider,
       plugins
     });
+    this.dispatchConfig = options.dispatch;
   }
   static createLocal(options) {
     const repoRoot = resolveSdkRepoRoot(options.repoRoot);
@@ -63,6 +71,67 @@ class AgentSdk {
       modelRegistry: options.modelRegistry
     });
   }
+  async resolveDispatchToken(source) {
+    if (!source) {
+      return null;
+    }
+    if (source.type === "bearer") {
+      return source.token;
+    }
+    return await source.resolveToken();
+  }
+  async executeDispatchLocally(request) {
+    const namespace = request.namespace ?? "sdk";
+    if (namespace === "workflow") {
+      const operations = new TreeseedOperationsSdk();
+      return operations.execute({
+        operationName: request.operation,
+        input: request.input ?? {}
+      }, {
+        cwd: this.repoRoot,
+        env: process.env,
+        transport: "sdk"
+      });
+    }
+    return executeSdkOperation(this, request.operation, request.input ?? {});
+  }
+  async dispatch(request) {
+    const namespace = request.namespace ?? "sdk";
+    const capability = findDispatchCapability(namespace, request.operation);
+    if (!capability) {
+      throw new Error(`Unknown dispatch operation "${namespace}:${request.operation}".`);
+    }
+    const preferredMode = request.preferredMode ?? this.dispatchConfig?.policy ?? capability.defaultDispatchMode;
+    const dispatchConfig = this.dispatchConfig;
+    if (!dispatchConfig && preferredMode === "remote_only") {
+      throw new Error(`Dispatch for "${namespace}:${request.operation}" requires a remote market configuration.`);
+    }
+    const shouldStayLocal = capability.executionClass === "local_only" || !dispatchConfig || preferredMode === "prefer_local";
+    if (shouldStayLocal) {
+      return {
+        ok: true,
+        mode: "inline",
+        namespace,
+        operation: request.operation,
+        target: "local",
+        capability,
+        payload: await this.executeDispatchLocally({ ...request, namespace })
+      };
+    }
+    const token = await this.resolveDispatchToken(dispatchConfig.credentialSource);
+    const client = new RemoteTreeseedDispatchClient(new RemoteTreeseedClient({
+      hosts: [{ id: "market", baseUrl: dispatchConfig.marketBaseUrl }],
+      activeHostId: "market",
+      auth: token ? { accessToken: token } : void 0
+    }, {
+      fetchImpl: dispatchConfig.fetchImpl
+    }));
+    return client.dispatch(dispatchConfig.projectId, {
+      ...request,
+      namespace,
+      preferredMode
+    });
+  }
   envelope(model, operation, payload, meta) {
     return {
       ok: true,

package/dist/workflow-state.js

@@ -88,6 +88,7 @@ function resolveTreeseedWorkflowState(cwd) {
       agents: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
       manager: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
       worker: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
+      runner: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
       workdayStart: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
       workdayReport: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null }
     },
@@ -128,7 +129,7 @@ function resolveTreeseedWorkflowState(cwd) {
             url: typeof latestHistory?.url === "string" ? latestHistory.url : deployState.lastDeployedUrl ?? null
           });
         }
-        for (const serviceKey of ["api", "agents", "manager", "worker", "workdayStart", "workdayReport"]) {
+        for (const serviceKey of ["api", "agents", "manager", "worker", "runner", "workdayStart", "workdayReport"]) {
           const service = deployState.services?.[serviceKey];
           if (!service) continue;
           state.managedServices[serviceKey] = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "AGPL-3.0-only",
   "repository": {