@treeseed/sdk 0.4.7 → 0.4.9

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/operations.d.ts

@@ -1,5 +1,6 @@
+import { checkTreeseedProviderConnections } from '../operations/services/config-runtime.ts';
 import { resolveTreeseedWorkflowState } from '../workflow-state.ts';
-import type { TreeseedCloseInput, TreeseedConfigInput, TreeseedDestroyInput, TreeseedReleaseInput, TreeseedSaveInput, TreeseedStageInput, TreeseedSwitchInput, TreeseedTaskBranchMetadata, TreeseedWorkflowContext, TreeseedWorkflowDevInput, TreeseedWorkflowNextStep, TreeseedWorkflowOperationId, TreeseedWorkflowResult } from '../workflow.ts';
+import type { TreeseedCloseInput, TreeseedConfigInput, TreeseedDestroyInput, TreeseedExportInput, TreeseedReleaseInput, TreeseedSaveInput, TreeseedStageInput, TreeseedSwitchInput, TreeseedTaskBranchMetadata, TreeseedWorkflowContext, TreeseedWorkflowDevInput, TreeseedWorkflowNextStep, TreeseedWorkflowOperationId, TreeseedWorkflowResult } from '../workflow.ts';
 type WorkflowWrite = NonNullable<TreeseedWorkflowContext['write']>;
 type WorkflowStatePayload = ReturnType<typeof resolveTreeseedWorkflowState>;
 export type TreeseedWorkflowErrorCode = 'validation_failed' | 'merge_conflict' | 'missing_runtime_auth' | 'deployment_timeout' | 'confirmation_required' | 'unsupported_transport' | 'unsupported_state';
@@ -22,10 +23,6 @@ export type WorkflowOperationHelpers = {
         tasks: TreeseedTaskBranchMetadata[];
     }>>;
 };
-type TreeseedRepairAction = {
-    id: string;
-    detail: string;
-};
 export declare function workflowStatus(helpers: WorkflowOperationHelpers): Promise<TreeseedWorkflowResult<import("../workflow-state.ts").TreeseedWorkflowState>>;
 export declare function workflowTasks(helpers: WorkflowOperationHelpers): Promise<TreeseedWorkflowResult<{
     tasks: TreeseedTaskBranchMetadata[];
@@ -36,7 +33,7 @@ export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?
     sync: "all" | "cloudflare" | "railway" | "none" | "github";
     configPath: string;
     keyPath: string;
-    repairs: TreeseedRepairAction[];
+    repairs: import("../operations/services/config-runtime.ts").TreeseedRepairAction[];
     preflight: {
         ok: boolean;
         requireAuth: boolean;
@@ -71,13 +68,45 @@ export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?
         actVerificationReady: any;
         remediation: string[];
     };
+    context: import("../operations/services/config-runtime.ts").TreeseedCollectedConfigContext;
     result: {
-        scopes: string[];
-        updated: never[];
-        synced: {};
-        initialized: never[];
-        connectionChecks: never[];
+        scopes: ("local" | "staging" | "prod")[];
+        synced: Record<string, unknown>;
+        initialized: Array<{
+            scope: import("../operations/services/config-runtime.ts").TreeseedConfigScope;
+            secrets: number;
+            target: string;
+        }>;
+        connectionChecks: ReturnType<typeof checkTreeseedProviderConnections>[];
+        validationByScope: Record<import("../operations/services/config-runtime.ts").TreeseedConfigScope, ReturnType<typeof import("../platform/environment.ts").validateTreeseedEnvironmentValues>>;
+        updated: {
+            scope: import("../operations/services/config-runtime.ts").TreeseedConfigScope | "shared";
+            id: string;
+            reused: boolean;
+            cleared: boolean;
+        }[];
+        envFiles: {
+            envLocalPath: string;
+            devVarsPath: string;
+        } | null;
     };
+    reports: {
+        scope: "local" | "staging" | "prod";
+        environment: {
+            scope: "local" | "staging" | "prod";
+            revealSecrets: boolean;
+            entries: any;
+        };
+        provider: {
+            scope: string;
+            ok: boolean;
+            checks: {
+                provider: any;
+                ready: any;
+                detail: any;
+            }[];
+        };
+    }[];
     state: import("../workflow-state.ts").TreeseedWorkflowState;
     readiness: {
         local: {
@@ -108,10 +137,22 @@ export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?
         secretsRevealed: boolean;
         reports: {
             scope: "local" | "staging" | "prod";
-            environmentReport: string;
-            providerReport: string;
+            environment: {
+                scope: "local" | "staging" | "prod";
+                revealSecrets: boolean;
+                entries: any;
+            };
+            provider: {
+                scope: string;
+                ok: boolean;
+                checks: {
+                    provider: any;
+                    ready: any;
+                    detail: any;
+                }[];
+            };
         }[];
-        repairs: TreeseedRepairAction[];
+        repairs: import("../operations/services/config-runtime.ts").TreeseedRepairAction[];
         preflight: {
             ok: boolean;
             requireAuth: boolean;
@@ -157,7 +198,7 @@ export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?
         scopes: ("local" | "staging" | "prod")[];
         sync: "all" | "cloudflare" | "railway" | "none" | "github";
         keyPath: string;
-        repairs: TreeseedRepairAction[];
+        repairs: import("../operations/services/config-runtime.ts").TreeseedRepairAction[];
         preflight: {
             ok: boolean;
             requireAuth: boolean;
@@ -197,6 +238,9 @@ export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?
     };
     nextSteps: TreeseedWorkflowNextStep[];
 }>;
+export declare function workflowExport(helpers: WorkflowOperationHelpers, input?: TreeseedExportInput): Promise<TreeseedWorkflowResult<import("../operations/services/export-runtime.ts").TreeseedExportResult & {
+    finalState: WorkflowStatePayload;
+}>>;
 export declare function workflowSwitch(helpers: WorkflowOperationHelpers, input: TreeseedSwitchInput): Promise<TreeseedWorkflowResult<{
     branchName: string;
     created: boolean;