@treeseed/core 0.4.9 → 0.4.11

package/dist/api/index.d.ts

@@ -1,8 +1,8 @@
 export { createTreeseedApiApp } from './app.ts';
-export { createTreeseedGatewayApp } from './gateway.ts';
 export { resolveApiConfig } from './config.ts';
 export { createRailwayTreeseedApiServer } 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';

package/dist/api/index.js

@@ -1,8 +1,8 @@
 import { createTreeseedApiApp } from "./app.js";
-import { createTreeseedGatewayApp } from "./gateway.js";
 import { resolveApiConfig } from "./config.js";
 import { createRailwayTreeseedApiServer } from "./railway.js";
 import { resolveApiRuntimeProviders } from "./providers.js";
+import { resolveApiD1Database } from "./auth/d1-database.js";
 import { loadTemplateCatalog } from "./templates.js";
 import { MemoryDeviceCodeAuthProvider } from "./auth/memory-provider.js";
 import { D1AuthProvider } from "./auth/d1-provider.js";
@@ -11,8 +11,8 @@ export {
   MemoryDeviceCodeAuthProvider,
   createRailwayTreeseedApiServer,
   createTreeseedApiApp,
-  createTreeseedGatewayApp,
   loadTemplateCatalog,
   resolveApiConfig,
+  resolveApiD1Database,
   resolveApiRuntimeProviders
 };

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

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

package/dist/api/operations-routes.js

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

package/dist/api/railway.d.ts

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

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

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

package/dist/api/sdk-dispatch.js

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

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

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

package/dist/api/sdk-routes.js

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

package/dist/api/types.d.ts

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

package/dist/components/site/RouteNotFound.astro

@@ -0,0 +1,25 @@
+---
+import MainLayout from '../../layouts/MainLayout.astro';
+
+const {
+	title = 'Page not found',
+	description = 'The requested Treeseed content could not be found.',
+	currentPath = '/404/',
+} = Astro.props;
+---
+
+<MainLayout title={title} description={description} currentPath={currentPath}>
+	<section class="mx-auto max-w-3xl space-y-6 py-20">
+		<p class="text-sm font-semibold uppercase tracking-[0.16em] text-[color:var(--site-accent-strong)]">404</p>
+		<h1 class="font-serif text-5xl text-[color:var(--site-text)]">{title}</h1>
+		<p class="text-lg leading-9 text-[color:var(--site-text-muted)]">{description}</p>
+		<div class="flex flex-wrap gap-4">
+			<a href="/" class="border border-[color:var(--site-accent)] bg-[color:var(--site-accent)] px-5 py-3 text-base font-semibold text-[color:var(--site-text)] transition hover:border-[color:var(--site-blue)] hover:bg-[color:var(--site-blue-soft)]">
+				Go home
+			</a>
+			<a href="/knowledge/" class="border border-[color:var(--site-border-strong)] px-5 py-3 text-base font-semibold text-[color:var(--site-text)] transition hover:border-[color:var(--site-blue)] hover:bg-[color:var(--site-blue-soft)]">
+				Open knowledge
+			</a>
+		</div>
+	</section>
+</MainLayout>

package/dist/content-config.d.ts

@@ -7,4 +7,5 @@ export declare function createTreeseedTenantCollections(manifestPath?: string):
 	agents: any;
 	books: any;
 	docs: any;
+	workdays?: any;
 };

package/dist/content.d.ts

@@ -0,0 +1 @@
+export declare function createTreeseedCollections(tenantConfig: any, dependencies: any): Record<string, any>;

package/dist/content.js

@@ -1,6 +1,7 @@
 import { defineCollection, reference } from "astro:content";
 import { z } from "astro/zod";
 import { glob } from "astro/loaders";
+import { existsSync, readdirSync } from "node:fs";
 import { AGENT_CLI_ALLOW_TOOLS } from "@treeseed/sdk/types/agents";
 import { loadTreeseedPluginRuntime } from "@treeseed/sdk/platform/plugins";
 import { loadTreeseedDeployConfig } from "@treeseed/sdk/platform/deploy-config";
@@ -22,6 +23,30 @@ const timeHorizonValues = ["near-term", "mid-term", "long-term"];
 const runtimeStatusValues = ["active", "experimental", "dormant"];
 const agentTriggerTypeValues = ["schedule", "message", "follow", "startup"];
 const agentPermissionOperationValues = ["get", "search", "follow", "pick", "create", "update"];
+function hasMarkdownContent(base) {
+  if (!existsSync(base)) {
+    return false;
+  }
+  for (const entry of readdirSync(base, { withFileTypes: true, recursive: true })) {
+    if (entry.isFile() && /\.(md|mdx)$/iu.test(entry.name)) {
+      return true;
+    }
+  }
+  return false;
+}
+function optionalMarkdownGlob(base) {
+  const delegate = glob({ pattern: "**/*.{md,mdx}", base });
+  return {
+    name: `treeseed-optional-markdown-glob:${base}`,
+    async load(context) {
+      if (!hasMarkdownContent(base)) {
+        context.store.clear();
+        return;
+      }
+      await delegate.load(context);
+    }
+  };
+}
 function withOptionalDefault(schema, defaultValue) {
   return defaultValue === void 0 ? schema : schema.default(defaultValue);
 }
@@ -244,8 +269,140 @@ function createTreeseedCollections(tenantConfig, { docsLoader, docsSchema }) {
     sidebarItems: z.array(sidebarItemSchema).min(1),
     tags: z.array(z.string()).default(BOOK_MODEL_DEFAULTS.tags ?? [])
   }));
+  const publisherSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    url: z.string().optional()
+  });
+  const templateGitSourceSchema = z.object({
+    kind: z.literal("git"),
+    repoUrl: z.string(),
+    directory: z.string(),
+    ref: z.string(),
+    integrity: z.string().optional()
+  });
+  const templateR2SourceSchema = z.object({
+    kind: z.literal("r2"),
+    bucket: z.string().optional(),
+    objectKey: z.string(),
+    version: z.string(),
+    publicUrl: z.string().optional(),
+    integrity: z.string().optional()
+  });
+  const templateProductSchema = z.object({
+    slug: z.string(),
+    title: z.string(),
+    description: z.string(),
+    summary: z.string(),
+    status: z.enum(["draft", "live", "archived"]),
+    featured: z.boolean().default(false),
+    teamId: z.string().optional(),
+    listingEnabled: z.boolean().default(true),
+    category: z.string(),
+    audience: z.array(z.string()).default([]),
+    tags: z.array(z.string()).default([]),
+    publisher: publisherSchema,
+    publisherVerified: z.boolean().default(false),
+    templateVersion: z.string(),
+    templateApiVersion: z.number().int().positive(),
+    minCliVersion: z.string(),
+    minCoreVersion: z.string(),
+    fulfillment: z.object({
+      mode: z.enum(["packaged", "git", "r2"]).default("packaged"),
+      source: z.union([templateGitSourceSchema, templateR2SourceSchema]),
+      hooksPolicy: z.enum(["builtin_only", "trusted_only", "disabled"]).default("builtin_only"),
+      supportsReconcile: z.boolean().default(true)
+    }),
+    offer: z.object({
+      priceModel: z.enum(["free", "paid", "contact", "one_time_current_version", "subscription_updates", "private"]).default("free"),
+      license: z.string().optional(),
+      support: z.string().optional()
+    }).default({ priceModel: "free" }),
+    relatedBooks: z.array(z.string()).default([]),
+    relatedKnowledge: z.array(z.string()).default([]),
+    relatedObjectives: z.array(z.string()).default([])
+  });
+  const knowledgePackSchema = z.object({
+    slug: z.string(),
+    title: z.string(),
+    description: z.string(),
+    status: z.enum(["draft", "live", "archived"]).default("draft")
+  });
+  const workdaySummaryTaskSchema = z.object({
+    id: z.string(),
+    agentId: z.string().optional(),
+    type: z.string().optional(),
+    state: z.string().optional(),
+    priority: z.number().optional(),
+    idempotencyKey: z.string().optional(),
+    createdAt: z.coerce.date().optional(),
+    startedAt: z.coerce.date().optional(),
+    completedAt: z.coerce.date().optional(),
+    lastErrorCode: z.string().nullable().optional(),
+    lastErrorMessage: z.string().nullable().optional(),
+    lastEventKind: z.string().optional(),
+    outputCount: z.number().int().optional(),
+    changedFiles: z.array(z.string()).default([])
+  });
+  const workdayPriorityItemSchema = z.object({
+    id: z.string(),
+    model: z.string(),
+    slug: z.string().optional(),
+    title: z.string().optional(),
+    status: z.string().optional(),
+    priority: z.number(),
+    estimatedCredits: z.number().optional(),
+    reason: z.string().optional()
+  });
+  const workdayReleaseSchema = z.object({
+    id: z.string().optional(),
+    deploymentKind: z.string(),
+    status: z.string(),
+    releaseTag: z.string().nullable().optional(),
+    commitSha: z.string().nullable().optional(),
+    sourceRef: z.string().nullable().optional(),
+    startedAt: z.coerce.date().optional(),
+    finishedAt: z.coerce.date().optional(),
+    createdAt: z.coerce.date().optional()
+  });
+  const workdaySchema = z.object({
+    title: z.string(),
+    slug: z.string(),
+    workDayId: z.string(),
+    reportVersion: z.string(),
+    reportKind: z.string().default("workday_summary"),
+    projectId: z.string(),
+    teamId: z.string().optional(),
+    environment: z.string(),
+    status: z.string().default("live"),
+    visibility: z.enum(["public", "authenticated", "team", "private"]).default("team"),
+    workdayState: z.string(),
+    startedAt: z.coerce.date(),
+    endedAt: z.coerce.date().nullable().optional(),
+    generatedAt: z.coerce.date(),
+    createdAt: z.coerce.date().optional(),
+    summary: z.string(),
+    dailyTaskCreditBudget: z.number().default(0),
+    usedTaskCredits: z.number().default(0),
+    remainingTaskCredits: z.number().default(0),
+    creditLedgerEntries: z.number().int().default(0),
+    prioritySnapshotId: z.string().nullable().optional(),
+    priorityItemCount: z.number().int().default(0),
+    priorityItems: z.array(workdayPriorityItemSchema).default([]),
+    totalTasks: z.number().int().default(0),
+    completedTasks: z.number().int().default(0),
+    failedTasks: z.number().int().default(0),
+    queuedTasks: z.number().int().default(0),
+    activeTasks: z.number().int().default(0),
+    taskItems: z.array(workdaySummaryTaskSchema).default([]),
+    changedFiles: z.array(z.string()).default([]),
+    releases: z.array(workdayReleaseSchema).default([]),
+    scaleDecision: z.record(z.any()).default({}),
+    scaleResult: z.record(z.any()).default({}),
+    metadata: z.record(z.any()).default({})
+  });
   const docsCollectionProvider = resolveDocsCollectionProvider(tenantConfig, { docsLoader, docsSchema });
-  return {
+  const collections = {
     pages: defineCollection({ loader: glob({ pattern: "**/*.{md,mdx}", base: tenantConfig.content.pages }), schema: pageSchema }),
     notes: defineCollection({ loader: glob({ pattern: "**/*.{md,mdx}", base: tenantConfig.content.notes }), schema: noteSchema }),
     questions: defineCollection({ loader: glob({ pattern: "**/*.{md,mdx}", base: tenantConfig.content.questions }), schema: questionSchema }),
@@ -258,6 +415,25 @@ function createTreeseedCollections(tenantConfig, { docsLoader, docsSchema }) {
       schema: docsCollectionProvider.schema
     })
   };
+  if (tenantConfig.content.workdays) {
+    collections.workdays = defineCollection({
+      loader: optionalMarkdownGlob(tenantConfig.content.workdays),
+      schema: workdaySchema
+    });
+  }
+  if (tenantConfig.content.templates) {
+    collections.templates = defineCollection({
+      loader: optionalMarkdownGlob(tenantConfig.content.templates),
+      schema: templateProductSchema
+    });
+  }
+  if (tenantConfig.content.knowledge_packs) {
+    collections.knowledge_packs = defineCollection({
+      loader: optionalMarkdownGlob(tenantConfig.content.knowledge_packs),
+      schema: knowledgePackSchema
+    });
+  }
+  return collections;
 }
 export {
   createTreeseedCollections

package/dist/dev.d.ts

@@ -3,7 +3,8 @@ export declare const TREESEED_DEFAULT_WEB_HOST = "127.0.0.1";
 export declare const TREESEED_DEFAULT_WEB_PORT = 4321;
 export declare const TREESEED_DEFAULT_API_HOST = "127.0.0.1";
 export declare const TREESEED_DEFAULT_API_PORT = 3000;
-export type TreeseedIntegratedDevSurface = 'integrated' | 'web' | 'api';
+export declare const TREESEED_DEFAULT_MANAGER_PORT = 3100;
+export type TreeseedIntegratedDevSurface = 'integrated' | 'services' | 'web' | 'api' | 'manager' | 'worker' | 'agents';
 export type TreeseedIntegratedDevOptions = {
     surface?: TreeseedIntegratedDevSurface;
     watch?: boolean;
@@ -14,9 +15,13 @@ export type TreeseedIntegratedDevOptions = {
     webPort?: number;
     apiHost?: string;
     apiPort?: number;
+    managerPort?: number;
+    includeServices?: boolean;
+    projectId?: string;
+    teamId?: string;
 };
 export type TreeseedIntegratedDevCommand = {
-    id: 'web' | 'api';
+    id: 'web' | 'api' | 'manager' | 'worker' | 'agents';
     label: string;
     command: string;
     args: string[];