@treeseed/sdk 0.10.28 → 0.12.4

package/dist/agent-tools.d.ts

@@ -0,0 +1,37 @@
+import type { SdkDispatchNamespace, SdkDispatchPolicy } from './sdk-types.js';
+import { type TreeseedContentAction, type TreeseedContentModel } from './content-operations.js';
+export type AgentToolExecutionTarget = 'sdk_dispatch' | 'treedx_proxy' | 'treeseed_content' | 'provider_runner';
+export type AgentToolMutability = 'read' | 'content_write' | 'worktree_write' | 'shared_state_write';
+export type AgentToolTelemetryCategory = 'treedx' | 'treeseed' | 'repository' | 'capacity' | 'content';
+export type AgentToolRequirement = 'treedx_proxy_handle' | 'assignment_worktree' | 'sdk_dispatch' | 'provider_runner_git' | 'treedx_writable_workspace' | 'content_access' | 'content_commit';
+export interface AgentToolDispatchMapping {
+    namespace: SdkDispatchNamespace;
+    operation: string;
+    preferredMode?: SdkDispatchPolicy;
+    assignmentPreferredMode?: SdkDispatchPolicy;
+}
+export interface AgentToolDefinition {
+    id: string;
+    title: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema: Record<string, unknown>;
+    executionTarget: AgentToolExecutionTarget;
+    mutability: AgentToolMutability;
+    telemetryCategory: AgentToolTelemetryCategory;
+    requirements: AgentToolRequirement[];
+    dispatch?: AgentToolDispatchMapping;
+    content?: {
+        action: TreeseedContentAction;
+        model?: TreeseedContentModel;
+        preset?: string;
+    };
+}
+export declare const TREESEED_AGENT_TOOL_DEFINITIONS: AgentToolDefinition[];
+export declare function findAgentToolDefinition(id: string | null | undefined): AgentToolDefinition | null;
+export declare function listAgentToolIds(): string[];
+export declare function assertKnownAgentToolIds(ids: string[]): {
+    known: string[];
+    unknown: string[];
+    duplicates: string[];
+};

package/dist/agent-tools.js

@@ -0,0 +1,301 @@
+import {
+  createTreeseedContentToolPresets,
+  genericTreeseedContentInputSchema
+} from "./content-operations.js";
+const EMPTY_OBJECT_SCHEMA = {
+  type: "object",
+  properties: {},
+  additionalProperties: false
+};
+const GENERIC_RESULT_SCHEMA = {
+  type: "object",
+  additionalProperties: true
+};
+const CONTENT_RESULT_SCHEMA = {
+  type: "object",
+  properties: {
+    ok: { type: "boolean" },
+    action: { type: "string" },
+    refs: { type: "array", items: { type: "object", additionalProperties: true } },
+    changedPaths: { type: "array", items: { type: "string" } },
+    diagnostics: { type: "array", items: { type: "object", additionalProperties: true } }
+  },
+  additionalProperties: true
+};
+function contentRequirements(action) {
+  if (action === "commit") return ["treedx_proxy_handle", "treedx_writable_workspace", "content_access", "content_commit"];
+  if (action === "create" || action === "update" || action === "link" || action === "validate") {
+    return ["treedx_proxy_handle", "treedx_writable_workspace", "content_access"];
+  }
+  return ["treedx_proxy_handle", "content_access"];
+}
+function contentMutability(action) {
+  return action === "describe" || action === "query" || action === "read" ? "read" : "content_write";
+}
+const GENERIC_CONTENT_TOOLS = [
+  ["describe", "Describe content model", "Describe TreeSeed content models, fields, relations, and allowed operations."],
+  ["query", "Query content", "Query TreeSeed content records through model-aware TreeDX access."],
+  ["read", "Read content", "Read a TreeSeed content record through model-aware TreeDX access."],
+  ["create", "Create content", "Create a TreeSeed content record using SDK frontmatter and markdown serialization."],
+  ["update", "Update content", "Update a TreeSeed content record using SDK frontmatter and markdown serialization."],
+  ["link", "Link content", "Create or update TreeSeed content relationships with model-aware validation."],
+  ["validate", "Validate content", "Validate a TreeSeed content record before committing it."],
+  ["commit", "Commit content workspace", "Commit staged TreeSeed content workspace changes when agent policy permits it."]
+].map(([action, title, description]) => ({
+  id: `treeseed.content.${action}`,
+  title,
+  description,
+  inputSchema: genericTreeseedContentInputSchema(action),
+  outputSchema: CONTENT_RESULT_SCHEMA,
+  executionTarget: "treeseed_content",
+  mutability: contentMutability(action),
+  telemetryCategory: "content",
+  requirements: contentRequirements(action),
+  content: { action }
+}));
+const PRESET_CONTENT_TOOLS = createTreeseedContentToolPresets().map((preset) => ({
+  id: preset.id,
+  title: preset.title,
+  description: preset.description,
+  inputSchema: preset.inputSchema,
+  outputSchema: CONTENT_RESULT_SCHEMA,
+  executionTarget: "treeseed_content",
+  mutability: contentMutability(preset.action),
+  telemetryCategory: "content",
+  requirements: contentRequirements(preset.action),
+  content: { action: preset.action, model: preset.model, preset: preset.id }
+}));
+const TREESEED_AGENT_TOOL_DEFINITIONS = [
+  {
+    id: "treedx.build_context",
+    title: "Build TreeDX context",
+    description: "Build assignment-scoped TreeDX repository context for a query or path set.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repoId: { type: "string" },
+        query: { type: "string" },
+        paths: { type: "array", items: { type: "string" } }
+      },
+      additionalProperties: false
+    },
+    outputSchema: GENERIC_RESULT_SCHEMA,
+    executionTarget: "treedx_proxy",
+    mutability: "read",
+    telemetryCategory: "treedx",
+    requirements: ["treedx_proxy_handle"]
+  },
+  {
+    id: "treedx.read_repository_files",
+    title: "Read TreeDX repository files",
+    description: "Read repository files through the assignment-scoped TreeDX proxy.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repoId: { type: "string" },
+        paths: { type: "array", items: { type: "string" } },
+        ref: { type: "string" }
+      },
+      required: ["paths"],
+      additionalProperties: false
+    },
+    outputSchema: GENERIC_RESULT_SCHEMA,
+    executionTarget: "treedx_proxy",
+    mutability: "read",
+    telemetryCategory: "treedx",
+    requirements: ["treedx_proxy_handle"]
+  },
+  {
+    id: "treedx.search_workspace",
+    title: "Search TreeDX workspace",
+    description: "Search the assignment-scoped TreeDX workspace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspaceId: { type: "string" },
+        query: { type: "string" }
+      },
+      required: ["query"],
+      additionalProperties: false
+    },
+    outputSchema: GENERIC_RESULT_SCHEMA,
+    executionTarget: "treedx_proxy",
+    mutability: "read",
+    telemetryCategory: "treedx",
+    requirements: ["treedx_proxy_handle"]
+  },
+  {
+    id: "treedx.read_workspace_file",
+    title: "Read TreeDX workspace file",
+    description: "Read a file from the assignment-scoped TreeDX workspace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspaceId: { type: "string" },
+        path: { type: "string" }
+      },
+      required: ["path"],
+      additionalProperties: false
+    },
+    outputSchema: GENERIC_RESULT_SCHEMA,
+    executionTarget: "treedx_proxy",
+    mutability: "read",
+    telemetryCategory: "treedx",
+    requirements: ["treedx_proxy_handle"]
+  },
+  {
+    id: "treedx.write_workspace_file",
+    title: "Write TreeDX workspace file",
+    description: "Write a file through the assignment-scoped TreeDX workspace proxy.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspaceId: { type: "string" },
+        path: { type: "string" },
+        content: { type: "string" }
+      },
+      required: ["path", "content"],
+      additionalProperties: false
+    },
+    outputSchema: GENERIC_RESULT_SCHEMA,
+    executionTarget: "treedx_proxy",
+    mutability: "content_write",
+    telemetryCategory: "treedx",
+    requirements: ["treedx_proxy_handle"]
+  },
+  {
+    id: "treedx.commit_workspace",
+    title: "Commit TreeDX workspace",
+    description: "Commit pending assignment-scoped TreeDX workspace changes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspaceId: { type: "string" },
+        message: { type: "string" }
+      },
+      required: ["message"],
+      additionalProperties: false
+    },
+    outputSchema: GENERIC_RESULT_SCHEMA,
+    executionTarget: "treedx_proxy",
+    mutability: "content_write",
+    telemetryCategory: "treedx",
+    requirements: ["treedx_proxy_handle"]
+  },
+  {
+    id: "treeseed.status",
+    title: "TreeSeed status",
+    description: "Inspect TreeSeed workspace and runtime status through SDK dispatch.",
+    inputSchema: EMPTY_OBJECT_SCHEMA,
+    outputSchema: GENERIC_RESULT_SCHEMA,
+    executionTarget: "sdk_dispatch",
+    mutability: "read",
+    telemetryCategory: "treeseed",
+    requirements: ["sdk_dispatch"],
+    dispatch: {
+      namespace: "workflow",
+      operation: "status",
+      preferredMode: "prefer_local",
+      assignmentPreferredMode: "auto"
+    }
+  },
+  {
+    id: "treeseed.dev_plan",
+    title: "TreeSeed dev plan",
+    description: "Inspect the local development plan without starting services.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        webRuntime: { type: "string" },
+        app: { type: "string" }
+      },
+      additionalProperties: false
+    },
+    outputSchema: GENERIC_RESULT_SCHEMA,
+    executionTarget: "sdk_dispatch",
+    mutability: "read",
+    telemetryCategory: "treeseed",
+    requirements: ["sdk_dispatch"],
+    dispatch: {
+      namespace: "workflow",
+      operation: "dev",
+      preferredMode: "prefer_local",
+      assignmentPreferredMode: "prefer_local"
+    }
+  },
+  {
+    id: "treeseed.changed_paths",
+    title: "Changed paths",
+    description: "Inspect changed paths in the assignment worktree.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        includeDiffSummary: { type: "boolean" }
+      },
+      additionalProperties: false
+    },
+    outputSchema: GENERIC_RESULT_SCHEMA,
+    executionTarget: "provider_runner",
+    mutability: "read",
+    telemetryCategory: "repository",
+    requirements: ["assignment_worktree", "provider_runner_git"]
+  },
+  {
+    id: "treeseed.verify",
+    title: "TreeSeed verify",
+    description: "Run assignment-scoped verification through SDK dispatch.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        commands: { type: "array", items: { type: "string" } },
+        reason: { type: "string" }
+      },
+      additionalProperties: false
+    },
+    outputSchema: GENERIC_RESULT_SCHEMA,
+    executionTarget: "sdk_dispatch",
+    mutability: "worktree_write",
+    telemetryCategory: "treeseed",
+    requirements: ["sdk_dispatch", "assignment_worktree"],
+    dispatch: {
+      namespace: "workflow",
+      operation: "test",
+      preferredMode: "prefer_local",
+      assignmentPreferredMode: "prefer_local"
+    }
+  },
+  ...GENERIC_CONTENT_TOOLS,
+  ...PRESET_CONTENT_TOOLS
+];
+const AGENT_TOOL_INDEX = new Map(TREESEED_AGENT_TOOL_DEFINITIONS.map((definition) => [definition.id, definition]));
+function findAgentToolDefinition(id) {
+  return id ? AGENT_TOOL_INDEX.get(id) ?? null : null;
+}
+function listAgentToolIds() {
+  return TREESEED_AGENT_TOOL_DEFINITIONS.map((definition) => definition.id);
+}
+function assertKnownAgentToolIds(ids) {
+  const seen = /* @__PURE__ */ new Set();
+  const known = [];
+  const unknown = [];
+  const duplicates = [];
+  for (const id of ids) {
+    if (seen.has(id)) {
+      duplicates.push(id);
+      continue;
+    }
+    seen.add(id);
+    if (AGENT_TOOL_INDEX.has(id)) {
+      known.push(id);
+    } else {
+      unknown.push(id);
+    }
+  }
+  return { known, unknown, duplicates };
+}
+export {
+  TREESEED_AGENT_TOOL_DEFINITIONS,
+  assertKnownAgentToolIds,
+  findAgentToolDefinition,
+  listAgentToolIds
+};

package/dist/api/app.d.ts

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

package/dist/api/auth/d1-database.d.ts

@@ -1,3 +1,3 @@
-import type { D1DatabaseLike } from '../../types/cloudflare.ts';
-import type { ApiConfig } from '../types.ts';
+import type { D1DatabaseLike } from '../../types/cloudflare.js';
+import type { ApiConfig } from '../types.js';
 export declare function resolveApiD1Database(config: ApiConfig): D1DatabaseLike;

package/dist/api/auth/d1-provider.d.ts

@@ -1,5 +1,5 @@
-import type { D1DatabaseLike } from '../../types/cloudflare.ts';
-import type { ApiAuthProvider, ApiConfig, ApiCredential, ApiPrincipal, DeviceCodeApproveRequest, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, TokenRefreshRequest, TokenRefreshResponse, TrustedUserAssertionClaims, UserIdentityProfileInput } from '../types.ts';
+import type { D1DatabaseLike } from '../../types/cloudflare.js';
+import type { ApiAuthProvider, ApiConfig, ApiCredential, ApiPrincipal, DeviceCodeApproveRequest, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, TokenRefreshRequest, TokenRefreshResponse, TrustedUserAssertionClaims, UserIdentityProfileInput } from '../types.js';
 export declare class D1AuthProvider implements ApiAuthProvider {
     private readonly config;
     readonly id = "d1";
@@ -69,8 +69,8 @@ export declare class D1AuthProvider implements ApiAuthProvider {
         name: string;
         roles?: string[];
         permissions?: string[];
-    }): Promise<import("./d1-store.ts").ServiceCredentialResult>;
-    rotateServiceToken(serviceId: string): Promise<import("./d1-store.ts").ServiceCredentialResult>;
+    }): Promise<import("./d1-store.js").ServiceCredentialResult>;
+    rotateServiceToken(serviceId: string): Promise<import("./d1-store.js").ServiceCredentialResult>;
     createTrustedUserAssertion(claims: TrustedUserAssertionClaims): string;
     verifyTrustedUserAssertion(assertion: string): TrustedUserAssertionClaims | null;
     exchangeTrustedUserAssertion(claims: TrustedUserAssertionClaims): Promise<{

package/dist/api/auth/d1-store.d.ts

@@ -1,5 +1,5 @@
-import type { D1DatabaseLike } from '../../types/cloudflare.ts';
-import type { ApiConfig, ApiCredential, ApiPrincipal, DeviceCodeApproveRequest, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, TokenRefreshRequest, TokenRefreshResponse, TrustedUserAssertionClaims, UserIdentityProfileInput } from '../types.ts';
+import type { D1DatabaseLike } from '../../types/cloudflare.js';
+import type { ApiConfig, ApiCredential, ApiPrincipal, DeviceCodeApproveRequest, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, TokenRefreshRequest, TokenRefreshResponse, TrustedUserAssertionClaims, UserIdentityProfileInput } from '../types.js';
 type PrincipalRecord = {
     principal: ApiPrincipal;
     userId: string;

package/dist/api/auth/memory-provider.d.ts

@@ -1,4 +1,4 @@
-import type { ApiAuthProvider, ApiConfig, ApiPrincipal, DeviceCodeApproveRequest, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, TokenRefreshRequest, TokenRefreshResponse, TrustedUserAssertionClaims, UserIdentityProfileInput } from '../types.ts';
+import type { ApiAuthProvider, ApiConfig, ApiPrincipal, DeviceCodeApproveRequest, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, TokenRefreshRequest, TokenRefreshResponse, TrustedUserAssertionClaims, UserIdentityProfileInput } from '../types.js';
 export declare class MemoryDeviceCodeAuthProvider implements ApiAuthProvider {
     private readonly config;
     readonly id = "memory";

package/dist/api/auth/tokens.d.ts

@@ -1,4 +1,4 @@
-import type { ApiPrincipal } from '../types.ts';
+import type { ApiPrincipal } from '../types.js';
 export interface AccessTokenPayload {
     sub: string;
     displayName?: string;

package/dist/api/config.d.ts

@@ -1,2 +1,4 @@
-import type { ApiConfig } from './types.ts';
+import type { ApiConfig } from './types.js';
+export declare function resolveLocalApiDatabaseUrl(env?: NodeJS.ProcessEnv): string;
+export declare function resolveApiDatabaseUrl(env?: NodeJS.ProcessEnv, baseUrl?: string): string | undefined;
 export declare function resolveApiConfig(env?: NodeJS.ProcessEnv): ApiConfig;

package/dist/api/config.js

@@ -3,6 +3,10 @@ import { resolve } from "node:path";
 const LOCAL_DEV_AUTH_TTL_SECONDS = 365 * 24 * 60 * 60;
 const DEFAULT_AUTH_TTL_SECONDS = 15 * 60;
 const DEFAULT_REFRESH_TTL_SECONDS = 7 * 24 * 60 * 60;
+const DEFAULT_LOCAL_API_DATABASE_PORT = "54329";
+const DEFAULT_LOCAL_API_DATABASE_NAME = "treeseed_api";
+const DEFAULT_LOCAL_API_DATABASE_USER = "treeseed";
+const DEFAULT_LOCAL_API_DATABASE_PASSWORD = "treeseed-local-dev";
 function parseInteger(value, fallback) {
   if (!value) return fallback;
   const parsed = Number.parseInt(value, 10);
@@ -35,6 +39,23 @@ function firstEnvValue(env, ...keys) {
   }
   return void 0;
 }
+function encodeDatabaseUrlPart(value) {
+  return encodeURIComponent(value);
+}
+function resolveLocalApiDatabaseUrl(env = process.env) {
+  const port = firstEnvValue(env, "TREESEED_MARKET_LOCAL_POSTGRES_PORT", "TREESEED_API_LOCAL_POSTGRES_PORT") || DEFAULT_LOCAL_API_DATABASE_PORT;
+  const database = firstEnvValue(env, "TREESEED_MARKET_LOCAL_POSTGRES_DATABASE", "TREESEED_API_LOCAL_POSTGRES_DATABASE") || DEFAULT_LOCAL_API_DATABASE_NAME;
+  const user = firstEnvValue(env, "TREESEED_MARKET_LOCAL_POSTGRES_USER", "TREESEED_API_LOCAL_POSTGRES_USER") || DEFAULT_LOCAL_API_DATABASE_USER;
+  const password = firstEnvValue(env, "TREESEED_MARKET_LOCAL_POSTGRES_PASSWORD", "TREESEED_API_LOCAL_POSTGRES_PASSWORD") || DEFAULT_LOCAL_API_DATABASE_PASSWORD;
+  return `postgres://${encodeDatabaseUrlPart(user)}:${encodeDatabaseUrlPart(password)}@127.0.0.1:${port}/${encodeDatabaseUrlPart(database)}`;
+}
+function resolveApiDatabaseUrl(env = process.env, baseUrl) {
+  const explicit = firstEnvValue(env, "TREESEED_DATABASE_URL");
+  if (explicit) return explicit;
+  const environment = firstEnvValue(env, "TREESEED_API_ENVIRONMENT", "TREESEED_ENVIRONMENT");
+  const localMode = env.TREESEED_LOCAL_DEV_MODE !== void 0 || environment === "local" || (baseUrl ? isLoopbackUrl(baseUrl) : false);
+  return localMode ? resolveLocalApiDatabaseUrl(env) : void 0;
+}
 function resolveBaseUrl(env, host, port) {
   if (env.TREESEED_API_BASE_URL?.trim()) {
     return normalizeUrl(env.TREESEED_API_BASE_URL.trim());
@@ -45,7 +66,7 @@ function resolveBaseUrl(env, host, port) {
   return normalizeUrl(`http://${host}:${port}`);
 }
 function resolveAuthApprovalBaseUrl(env, baseUrl) {
-  const explicit = env.TREESEED_API_AUTH_APPROVAL_BASE_URL?.trim() || env.TREESEED_SITE_URL?.trim() || env.BETTER_AUTH_URL?.trim();
+  const explicit = env.TREESEED_API_AUTH_APPROVAL_BASE_URL?.trim() || env.TREESEED_SITE_URL?.trim() || env.TREESEED_BETTER_AUTH_URL?.trim();
   const explicitIsLoopback = explicit ? isLoopbackUrl(explicit) : false;
   try {
     const url = new URL(baseUrl);
@@ -92,14 +113,15 @@ function resolveApiConfig(env = process.env) {
     projectApiKey: env.TREESEED_API_PROJECT_KEY?.trim() || void 0,
     projectApiLabel: env.TREESEED_API_PROJECT_LABEL?.trim() || "Project API Key",
     projectApiPermissions: parseCsv(env.TREESEED_API_PROJECT_KEY_PERMISSIONS).length > 0 ? parseCsv(env.TREESEED_API_PROJECT_KEY_PERMISSIONS) : ["sdk:execute:global", "agent:execute:global", "operations:execute:global"],
-    cloudflareAccountId: env.CLOUDFLARE_ACCOUNT_ID?.trim() || void 0,
-    cloudflareApiToken: env.CLOUDFLARE_API_TOKEN?.trim() || void 0,
+    cloudflareAccountId: env.TREESEED_CLOUDFLARE_ACCOUNT_ID?.trim() || void 0,
+    cloudflareApiToken: env.TREESEED_CLOUDFLARE_API_TOKEN?.trim() || void 0,
+    apiDatabaseUrl: resolveApiDatabaseUrl(env, baseUrl),
     d1DatabaseId: env.TREESEED_API_D1_DATABASE_ID?.trim() || void 0,
     d1DatabaseName: env.TREESEED_API_D1_DATABASE_NAME?.trim() || env.SITE_DATA_DB?.trim() || void 0,
     d1LocalPersistTo: env.TREESEED_API_D1_LOCAL_PERSIST_TO?.trim() || resolve(repoRoot, ".wrangler/state/v3/d1"),
     d1WranglerConfigPath: resolveLocalWranglerConfigPath(repoRoot, env),
-    webServiceId: firstEnvValue(env, "TREESEED_API_WEB_SERVICE_ID", "TREESEED_WEB_SERVICE_ID") || "web",
-    webServiceSecret: firstEnvValue(env, "TREESEED_API_WEB_SERVICE_SECRET", "TREESEED_WEB_SERVICE_SECRET") || "treeseed-web-service-dev-secret",
+    webServiceId: firstEnvValue(env, "TREESEED_WEB_SERVICE_ID", "TREESEED_API_WEB_SERVICE_ID") || "web",
+    webServiceSecret: firstEnvValue(env, "TREESEED_WEB_SERVICE_SECRET", "TREESEED_API_WEB_SERVICE_SECRET") || "treeseed-web-service-dev-secret",
     webAssertionSecret: firstEnvValue(env, "TREESEED_API_WEB_ASSERTION_SECRET", "TREESEED_WEB_ASSERTION_SECRET", "TREESEED_API_AUTH_SECRET") || "treeseed-web-assertion-dev-secret",
     webExchangeTtlSeconds: parseInteger(env.TREESEED_API_WEB_EXCHANGE_TTL, 300),
     bootstrapAdminAllowlist: parseCsv(env.TREESEED_API_BOOTSTRAP_ADMIN_ALLOWLIST),
@@ -111,15 +133,17 @@ function resolveApiConfig(env = process.env) {
     providers: {
       auth: env.TREESEED_API_PROVIDER_AUTH?.trim() || "d1",
       agents: {
-        execution: env.TREESEED_API_PROVIDER_AGENT_EXECUTION?.trim() || "stub",
+        execution: env.TREESEED_API_PROVIDER_AGENT_EXECUTION?.trim() || "codex",
         queue: env.TREESEED_API_PROVIDER_AGENT_QUEUE?.trim() || "memory",
-        notification: env.TREESEED_API_PROVIDER_AGENT_NOTIFICATION?.trim() || "stub",
-        repository: env.TREESEED_API_PROVIDER_AGENT_REPOSITORY?.trim() || "stub",
-        verification: env.TREESEED_API_PROVIDER_AGENT_VERIFICATION?.trim() || "stub"
+        notification: env.TREESEED_API_PROVIDER_AGENT_NOTIFICATION?.trim() || "sdk_message",
+        repository: env.TREESEED_API_PROVIDER_AGENT_REPOSITORY?.trim() || "git",
+        verification: env.TREESEED_API_PROVIDER_AGENT_VERIFICATION?.trim() || "local"
       }
     }
   };
 }
 export {
-  resolveApiConfig
+  resolveApiConfig,
+  resolveApiDatabaseUrl,
+  resolveLocalApiDatabaseUrl
 };

package/dist/api/http.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from 'hono';
-import type { ApiPrincipal, ApiScope } from '../remote.ts';
-import type { AppVariables } from './types.ts';
+import type { ApiPrincipal, ApiScope } from '../remote.js';
+import type { AppVariables } from './types.js';
 export type ApiContext = Context<{
     Variables: AppVariables;
 }>;

package/dist/api/index.d.ts

@@ -1,10 +1,10 @@
-export { createTreeseedApiApp, createTreeseedApiRouter } from './app.ts';
-export { resolveApiConfig } from './config.ts';
-export { createRailwayTreeseedApiServer, createTreeseedNodeServer } from './railway.ts';
-export { resolveApiRuntimeProviders } from './providers.ts';
-export { resolveApiD1Database } from './auth/d1-database.ts';
-export { loadTemplateCatalog } from './templates.ts';
-export { MemoryDeviceCodeAuthProvider } from './auth/memory-provider.ts';
-export { D1AuthProvider } from './auth/d1-provider.ts';
-export { bearerTokenFromRequest, jsonError, requireActorType, requireAuthentication, requirePermission, requireScope } from './http.ts';
-export type * from './types.ts';
+export { createTreeseedApiApp, createTreeseedApiRouter } from './app.js';
+export { resolveApiConfig, resolveApiDatabaseUrl, resolveLocalApiDatabaseUrl } from './config.js';
+export { createRailwayTreeseedApiServer, createTreeseedNodeServer } from './railway.js';
+export { resolveApiRuntimeProviders } from './providers.js';
+export { resolveApiD1Database } from './auth/d1-database.js';
+export { loadTemplateCatalog } from './templates.js';
+export { MemoryDeviceCodeAuthProvider } from './auth/memory-provider.js';
+export { D1AuthProvider } from './auth/d1-provider.js';
+export { bearerTokenFromRequest, jsonError, requireActorType, requireAuthentication, requirePermission, requireScope } from './http.js';
+export type * from './types.js';

package/dist/api/index.js

@@ -1,5 +1,5 @@
 import { createTreeseedApiApp, createTreeseedApiRouter } from "./app.js";
-import { resolveApiConfig } from "./config.js";
+import { resolveApiConfig, resolveApiDatabaseUrl, resolveLocalApiDatabaseUrl } from "./config.js";
 import { createRailwayTreeseedApiServer, createTreeseedNodeServer } from "./railway.js";
 import { resolveApiRuntimeProviders } from "./providers.js";
 import { resolveApiD1Database } from "./auth/d1-database.js";
@@ -23,5 +23,7 @@ export {
   requireScope,
   resolveApiConfig,
   resolveApiD1Database,
-  resolveApiRuntimeProviders
+  resolveApiDatabaseUrl,
+  resolveApiRuntimeProviders,
+  resolveLocalApiDatabaseUrl
 };

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

@@ -1,7 +1,7 @@
 import type { Hono } from 'hono';
-import type { AgentSdk } from '../sdk.ts';
-import { executeHttpWorkflowOperation } from './operations.ts';
-import type { ApiConfig } from './types.ts';
+import type { AgentSdk } from '../sdk.js';
+import { executeHttpWorkflowOperation } from './operations.js';
+import type { ApiConfig } from './types.js';
 export declare function registerOperationRoutes(app: Hono<any>, options: {
     config: ApiConfig;
     scope: string;

package/dist/api/operations.d.ts

@@ -1,3 +1,3 @@
-import type { ApiWorkflowOperationResponse, WorkflowHttpOperationRequest } from './types.ts';
+import type { ApiWorkflowOperationResponse, WorkflowHttpOperationRequest } from './types.js';
 export declare function isHttpWorkflowOperationAllowed(operation: string): boolean;
 export declare function executeHttpWorkflowOperation(operation: string, request: WorkflowHttpOperationRequest): Promise<ApiWorkflowOperationResponse>;

package/dist/api/providers.d.ts

@@ -1,2 +1,2 @@
-import type { ApiConfig, ApiRuntimeProviders, ResolvedApiRuntimeProviders } from './types.ts';
+import type { ApiConfig, ApiRuntimeProviders, ResolvedApiRuntimeProviders } from './types.js';
 export declare function resolveApiRuntimeProviders(config: ApiConfig, overrides?: ApiRuntimeProviders): ResolvedApiRuntimeProviders;

package/dist/api/providers.js

@@ -34,11 +34,28 @@ function resolveApiRuntimeProviders(config, overrides = {}) {
     }, { db: resolveApiD1Database(runtimeConfig) })
   }, "auth");
   addProviders(authRegistry, overrides.auth, "auth");
-  addProviders(agentExecution, { stub: { id: "stub" } }, "agent execution");
+  addProviders(agentExecution, {
+    codex: { id: "codex" },
+    codex_subscription: { id: "codex_subscription" },
+    copilot: { id: "copilot" },
+    jira: { id: "jira" },
+    jira_issue_queue: { id: "jira_issue_queue" },
+    human_issue_queue: { id: "human_issue_queue" },
+    github_issues: { id: "github_issues" },
+    github_issue_queue: { id: "github_issue_queue" },
+    issue_queue: { id: "issue_queue" },
+    discord: { id: "discord" },
+    discord_thread: { id: "discord_thread" },
+    workflow: { id: "workflow" },
+    workflow_operation: { id: "workflow_operation" },
+    deterministic_workflow: { id: "deterministic_workflow" },
+    github_actions: { id: "github_actions" },
+    github_actions_workflow: { id: "github_actions_workflow" }
+  }, "agent execution");
   addProviders(agentQueue, { memory: { id: "memory" } }, "agent queue");
-  addProviders(agentNotification, { stub: { id: "stub" } }, "agent notification");
-  addProviders(agentRepository, { stub: { id: "stub" } }, "agent repository");
-  addProviders(agentVerification, { stub: { id: "stub" } }, "agent verification");
+  addProviders(agentNotification, { sdk_message: { id: "sdk_message" } }, "agent notification");
+  addProviders(agentRepository, { git: { id: "git" } }, "agent repository");
+  addProviders(agentVerification, { local: { id: "local" } }, "agent verification");
   addProviders(agentExecution, overrides.agentExecution, "agent execution");
   addProviders(agentQueue, overrides.agentQueue, "agent queue");
   addProviders(agentNotification, overrides.agentNotification, "agent notification");

package/dist/api/railway.d.ts

@@ -1,9 +1,9 @@
 import { type Server } from 'node:http';
 import type { Hono } from 'hono';
-import type { ApiServerOptions } from './types.ts';
+import type { ApiServerOptions } from './types.js';
 export declare function createTreeseedNodeServer(options?: ApiServerOptions): Promise<{
     app: Hono<{
-        Variables: import("./types.ts").AppVariables;
+        Variables: import("./types.js").AppVariables;
     }, import("hono/types").BlankSchema, "/">;
     config: {
         providers: {
@@ -30,6 +30,7 @@ export declare function createTreeseedNodeServer(options?: ApiServerOptions): Pr
         projectApiPermissions: string[];
         cloudflareAccountId?: string;
         cloudflareApiToken?: string;
+        apiDatabaseUrl?: string;
         d1DatabaseId?: string;
         d1DatabaseName?: string;
         d1LocalPersistTo?: string;

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

@@ -1,6 +1,6 @@
-import type { RemoteSdkOperationRequest } from '../remote.ts';
-import type { AgentSdk } from '../sdk.ts';
-import { executeSdkOperation, findSdkOperation, listSdkOperationNames } from '../sdk-dispatch.ts';
-import type { ApiConfig } from './types.ts';
+import type { RemoteSdkOperationRequest } from '../remote.js';
+import type { AgentSdk } from '../sdk.js';
+import { executeSdkOperation, findSdkOperation, listSdkOperationNames } from '../sdk-dispatch.js';
+import type { ApiConfig } from './types.js';
 export { executeSdkOperation, findSdkOperation, listSdkOperationNames, };
 export declare function resolveSdkInstance(sharedSdk: AgentSdk | undefined, config: ApiConfig, request: RemoteSdkOperationRequest): AgentSdk;

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

@@ -1,6 +1,6 @@
 import type { Hono } from 'hono';
-import type { AgentSdk } from '../sdk.ts';
-import type { ApiConfig } from './types.ts';
+import type { AgentSdk } from '../sdk.js';
+import type { ApiConfig } from './types.js';
 interface RegisterSdkRoutesOptions {
     config: ApiConfig;
     sharedSdk?: AgentSdk;

package/dist/api/templates.d.ts

@@ -1,3 +1,3 @@
-import type { SdkTemplateCatalogResponse } from '../sdk-types.ts';
-import type { ApiConfig } from './types.ts';
+import type { SdkTemplateCatalogResponse } from '../sdk-types.js';
+import type { ApiConfig } from './types.js';
 export declare function loadTemplateCatalog(config: ApiConfig): SdkTemplateCatalogResponse;