@treeseed/sdk 0.10.23 → 0.10.24

package/dist/operations/services/bootstrap-runner.d.ts

@@ -1,3 +1,4 @@
+import { type TreeseedTimingEntry } from '../../timing.ts';
 export type TreeseedBootstrapExecution = 'parallel' | 'sequential';
 export type TreeseedBootstrapStream = 'stdout' | 'stderr';
 export type TreeseedBootstrapWriter = (line: string, stream?: TreeseedBootstrapStream) => void;
@@ -11,13 +12,16 @@ export type TreeseedBootstrapDagNode<TResult = unknown> = {
     id: string;
     dependencies?: string[];
     run: () => Promise<TResult> | TResult;
+    label?: string;
 };
 export declare function formatTreeseedBootstrapPrefix(prefix: TreeseedBootstrapTaskPrefix): string;
 export declare function formatTreeseedBootstrapLine(prefix: TreeseedBootstrapTaskPrefix, line: string): string;
 export declare function writeTreeseedBootstrapLine(write: TreeseedBootstrapWriter | undefined, prefix: TreeseedBootstrapTaskPrefix, line: string, stream?: TreeseedBootstrapStream): void;
-export declare function runTreeseedBootstrapDag<TResult = unknown>({ nodes, execution, }: {
+export declare function runTreeseedBootstrapDag<TResult = unknown>({ nodes, execution, write, timings, }: {
     nodes: Array<TreeseedBootstrapDagNode<TResult>>;
     execution?: TreeseedBootstrapExecution;
+    write?: TreeseedBootstrapWriter;
+    timings?: TreeseedTimingEntry[];
 }): Promise<Map<string, TResult>>;
 export declare function sleep(milliseconds: number): Promise<void>;
 export declare function runPrefixedCommand(command: string, args: string[], { cwd, env, input, write, prefix, }: {

package/dist/operations/services/bootstrap-runner.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { elapsedMs, formatDurationMs } from "../../timing.js";
 function formatTreeseedBootstrapPrefix(prefix) {
   return `[${prefix.scope}][${prefix.system}][${prefix.task}][${prefix.stage}]`;
 }
@@ -43,19 +44,47 @@ function dependencyLevels(nodes) {
 }
 async function runTreeseedBootstrapDag({
   nodes,
-  execution = "parallel"
+  execution = "parallel",
+  write,
+  timings
 }) {
   const results = /* @__PURE__ */ new Map();
+  const recordNode = async (node) => {
+    const label = node.label ?? node.id;
+    const startMs = performance.now();
+    const entry = {
+      name: `bootstrap:${label}`,
+      durationMs: 0,
+      status: "running",
+      metadata: { nodeId: node.id, dependencies: node.dependencies ?? [] }
+    };
+    timings?.push(entry);
+    write?.(`[bootstrap][${node.id}] started`);
+    try {
+      const result = await Promise.resolve(node.run());
+      entry.durationMs = elapsedMs(startMs);
+      entry.status = "success";
+      write?.(`[bootstrap][${node.id}] completed in ${formatDurationMs(entry.durationMs)}`);
+      results.set(node.id, result);
+    } catch (error) {
+      entry.durationMs = elapsedMs(startMs);
+      entry.status = "failed";
+      entry.metadata = {
+        ...entry.metadata ?? {},
+        error: error instanceof Error ? error.message : String(error)
+      };
+      write?.(`[bootstrap][${node.id}] failed after ${formatDurationMs(entry.durationMs)}`, "stderr");
+      throw error;
+    }
+  };
   for (const level of dependencyLevels(nodes)) {
     if (execution === "sequential") {
       for (const node of level) {
-        results.set(node.id, await Promise.resolve(node.run()));
+        await recordNode(node);
       }
       continue;
     }
-    await Promise.all(level.map(async (node) => {
-      results.set(node.id, await Promise.resolve(node.run()));
-    }));
+    await Promise.all(level.map(recordNode));
   }
   return results;
 }

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

@@ -385,6 +385,7 @@ export declare function initializeTreeseedPersistentEnvironment({ tenantRoot, sc
         plans: import("../../reconcile/contracts.ts").TreeseedReconcilePlan[];
         results: import("../../reconcile/contracts.ts").TreeseedReconcileResult[];
         state: import("../../reconcile/contracts.ts").TreeseedReconcileStateRecord;
+        timings: import("../../timing.ts").TreeseedTimingEntry[];
     };
     secrets: string[];
 }>;

package/dist/operations/services/project-platform.d.ts

@@ -1,3 +1,4 @@
+import { type TreeseedTimingEntry } from '../../timing.ts';
 import { type ControlPlaneReporter } from '../../control-plane.ts';
 import type { TreeseedRunnableBootstrapSystem } from '../../reconcile/index.ts';
 import { type TreeseedBootstrapExecution, type TreeseedBootstrapWriter } from './bootstrap-runner.ts';
@@ -59,6 +60,7 @@ export declare function provisionProjectPlatform(options: ProjectPlatformActionO
         plans: import("../../reconcile/contracts.ts").TreeseedReconcilePlan[];
         results: import("../../reconcile/contracts.ts").TreeseedReconcileResult[];
         state: import("../../reconcile/contracts.ts").TreeseedReconcileStateRecord;
+        timings: TreeseedTimingEntry[];
     };
     verification: {
         target: import("../../reconcile/contracts.ts").TreeseedReconcileTarget;
@@ -76,6 +78,7 @@ export declare function provisionProjectPlatform(options: ProjectPlatformActionO
             verification: import("../../reconcile/contracts.ts").TreeseedUnitVerificationResult | null;
         }[];
     };
+    timings: TreeseedTimingEntry[];
     railway: {
         services: any[];
         schedules: any[];
@@ -104,6 +107,10 @@ export declare function deployProjectPlatform(options: ProjectPlatformActionOpti
                 objectKey: string;
                 skipped?: undefined;
                 reason?: undefined;
+            } | {
+                ok: boolean;
+                skipped: boolean;
+                reason: string;
             };
             queue: {
                 ok: boolean;
@@ -241,6 +248,7 @@ export declare function deployProjectPlatform(options: ProjectPlatformActionOpti
                 };
             };
         };
+        timings: TreeseedTimingEntry[];
     };
     hostingRepair: {
         ok: boolean;
@@ -285,6 +293,7 @@ export declare function deployProjectPlatform(options: ProjectPlatformActionOpti
             } | null;
         } | null;
     } | undefined)[];
+    timings: TreeseedTimingEntry[];
 }>;
 export declare function resolveRailwayServiceDeployDependencies({ includeDataDependency, previousRailwayDeployNodeId, }: {
     includeDataDependency: boolean;
@@ -313,6 +322,10 @@ export declare function monitorProjectPlatform(options: ProjectPlatformActionOpt
             objectKey: string;
             skipped?: undefined;
             reason?: undefined;
+        } | {
+            ok: boolean;
+            skipped: boolean;
+            reason: string;
         };
         queue: {
             ok: boolean;
@@ -450,6 +463,7 @@ export declare function monitorProjectPlatform(options: ProjectPlatformActionOpt
             };
         };
     };
+    timings: TreeseedTimingEntry[];
 }>;
 export declare function syncControlPlaneState(options: ProjectPlatformActionOptions): Promise<void>;
 export declare function runProjectPlatformAction(action: ProjectPlatformAction, options: ProjectPlatformActionOptions): Promise<{
@@ -474,6 +488,10 @@ export declare function runProjectPlatformAction(action: ProjectPlatformAction,
             objectKey: string;
             skipped?: undefined;
             reason?: undefined;
+        } | {
+            ok: boolean;
+            skipped: boolean;
+            reason: string;
         };
         queue: {
             ok: boolean;
@@ -611,6 +629,7 @@ export declare function runProjectPlatformAction(action: ProjectPlatformAction,
             };
         };
     };
+    timings: TreeseedTimingEntry[];
 } | {
     ok: boolean;
     scope: ProjectPlatformScope;
@@ -628,6 +647,10 @@ export declare function runProjectPlatformAction(action: ProjectPlatformAction,
                 objectKey: string;
                 skipped?: undefined;
                 reason?: undefined;
+            } | {
+                ok: boolean;
+                skipped: boolean;
+                reason: string;
             };
             queue: {
                 ok: boolean;
@@ -765,6 +788,7 @@ export declare function runProjectPlatformAction(action: ProjectPlatformAction,
                 };
             };
         };
+        timings: TreeseedTimingEntry[];
     };
     hostingRepair: {
         ok: boolean;
@@ -809,5 +833,6 @@ export declare function runProjectPlatformAction(action: ProjectPlatformAction,
             } | null;
         } | null;
     } | undefined)[];
+    timings: TreeseedTimingEntry[];
 }>;
 export {};

package/dist/operations/services/project-platform.js

@@ -3,6 +3,7 @@ import { spawnSync } from "node:child_process";
 import { mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, extname, join, resolve } from "node:path";
+import { elapsedMs, formatTimingMarkdown, formatTimingSummary } from "../../timing.js";
 import {
   createControlPlaneReporter
 } from "../../control-plane.js";
@@ -52,6 +53,39 @@ const PROCESSING_PLATFORM_BOOTSTRAP_SYSTEMS = ["api", "agents"];
 function stableHash(value) {
   return createHash("sha256").update(value).digest("hex");
 }
+function recordTiming(timings, name, startMs, status = "success", metadata) {
+  const entry = {
+    name,
+    durationMs: elapsedMs(startMs),
+    status,
+    ...metadata ? { metadata } : {}
+  };
+  timings.push(entry);
+  return entry;
+}
+async function timedPhase(timings, name, run, metadata) {
+  const startMs = performance.now();
+  try {
+    const result = await Promise.resolve(run());
+    recordTiming(timings, name, startMs, "success", metadata);
+    return result;
+  } catch (error) {
+    recordTiming(timings, name, startMs, "failed", {
+      ...metadata ?? {},
+      error: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
+  }
+}
+function writeProviderTimingSummary(options, timings) {
+  const text = formatTimingSummary(timings);
+  options.write?.(text);
+  const summaryPath = String(options.env?.TREESEED_PROVIDER_TIMING_SUMMARY_PATH ?? process.env.TREESEED_PROVIDER_TIMING_SUMMARY_PATH ?? "").trim();
+  if (!summaryPath) {
+    return;
+  }
+  writeFileSync(summaryPath, formatTimingMarkdown(timings), { flag: "a" });
+}
 function inferEnvironmentFromBranch(tenantRoot) {
   const branch = currentManagedBranch(tenantRoot);
   if (branch === STAGING_BRANCH) {
@@ -1024,25 +1058,30 @@ async function publishContent(options, reporter, publishOptions = {}) {
   }
 }
 async function provisionProjectPlatform(options) {
+  const timings = [];
   const reporter = resolveReporter(options.tenantRoot, options.reporter);
   const target = createPersistentDeployTarget(options.scope === "local" ? "staging" : options.scope);
   const siteConfig = loadCliDeployConfig(options.tenantRoot);
   const bootstrapSystems = resolveProjectPlatformBootstrapSystems(options, siteConfig);
   const selectedSystems = new Set(bootstrapSystems);
   const env = { ...process.env, ...options.env ?? {} };
-  const summary = await reconcileTreeseedTarget({
+  const summary = await timedPhase(timings, "provision:reconcile", () => reconcileTreeseedTarget({
     tenantRoot: options.tenantRoot,
     target,
     env,
-    systems: bootstrapSystems
-  });
-  const verification = await collectTreeseedReconcileStatus({
+    systems: bootstrapSystems,
+    write: options.write
+  }));
+  timings.push(...summary.timings ?? []);
+  const verification = await timedPhase(timings, "provision:collect-reconcile-status", () => collectTreeseedReconcileStatus({
     tenantRoot: options.tenantRoot,
     target,
     env,
     systems: bootstrapSystems
+  }));
+  await timedPhase(timings, "provision:ensure-wrangler-config", () => {
+    ensureGeneratedWranglerConfig(options.tenantRoot, { target });
   });
-  ensureGeneratedWranglerConfig(options.tenantRoot, { target });
   const shouldValidateRailway = selectedSystems.has("api") || selectedSystems.has("agents");
   const railwayValidation = shouldValidateRailway ? options.scope === "local" ? validateRailwayServiceConfiguration(options.tenantRoot, options.scope) : validateRailwayDeployPrerequisites(options.tenantRoot, options.scope, { env }) : { services: [] };
   const railwaySchedules = [];
@@ -1173,6 +1212,7 @@ async function provisionProjectPlatform(options) {
       target: deployTargetLabel(target),
       summary,
       verification,
+      timings,
       reconcileActions: summary.results.map((result) => ({
         unitId: result.unit.unitId,
         action: result.action,
@@ -1190,6 +1230,7 @@ async function provisionProjectPlatform(options) {
     target: deployTargetLabel(target),
     summary,
     verification,
+    timings,
     railway: {
       services: railwayValidation.services.map((service) => service.key),
       schedules: railwaySchedules,
@@ -1198,6 +1239,8 @@ async function provisionProjectPlatform(options) {
   };
 }
 async function deployProjectPlatform(options) {
+  const timings = [];
+  const deployStartMs = performance.now();
   const reporter = resolveReporter(options.tenantRoot, options.reporter);
   const commitSha = currentCommit(options.tenantRoot);
   const branchName = currentRef(options.tenantRoot);
@@ -1216,7 +1259,8 @@ async function deployProjectPlatform(options) {
     metadata: { scope: options.scope }
   });
   if (!options.skipProvision) {
-    await provisionProjectPlatform({ ...options, reporter, bootstrapSystems });
+    const provision = await timedPhase(timings, "deploy:provision", () => provisionProjectPlatform({ ...options, reporter, bootstrapSystems }));
+    timings.push(...provision.timings ?? []);
   }
   const nodes = [];
   let cloudflareContext = null;
@@ -1335,7 +1379,7 @@ async function deployProjectPlatform(options) {
       }
     });
   }
-  await runTreeseedBootstrapDag({ nodes, execution });
+  await runTreeseedBootstrapDag({ nodes, execution, write, timings });
   const serviceResults = selectedRailwayServiceKeys.map((serviceKey) => serviceResultsByKey.get(serviceKey)).filter(Boolean);
   if (options.scope !== "local" && !options.dryRun && (selectedSystems.has("web") || serviceResults.length > 0)) {
     finalizeDeploymentState(options.tenantRoot, {
@@ -1358,8 +1402,11 @@ async function deployProjectPlatform(options) {
       scheduleVerification: railwayScheduleVerification
     });
   }
-  const monitor = await monitorProjectPlatform({ ...options, reporter, bootstrapSystems });
-  const hostingRepair = await repairHostingAfterSuccessfulDeploy(options, bootstrapSystems);
+  const monitor = await timedPhase(timings, "deploy:monitor", () => monitorProjectPlatform({ ...options, reporter, bootstrapSystems }));
+  timings.push(...monitor.timings ?? []);
+  const hostingRepair = await timedPhase(timings, "deploy:hosting-repair", () => repairHostingAfterSuccessfulDeploy(options, bootstrapSystems));
+  recordTiming(timings, "deploy:total", deployStartMs);
+  writeProviderTimingSummary(options, timings);
   await reportDeployment(reporter, {
     environment: options.scope,
     deploymentKind: "code",
@@ -1371,7 +1418,8 @@ async function deployProjectPlatform(options) {
       scope: options.scope,
       railway: options.scope === "local" ? [] : configuredRailwayServices(options.tenantRoot, options.scope).map((service) => service.key).filter((serviceKey) => serviceKey === "api" ? selectedSystems.has("api") : selectedSystems.has("agents")),
       monitor,
-      hostingRepair
+      hostingRepair,
+      timings
     },
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
@@ -1380,7 +1428,8 @@ async function deployProjectPlatform(options) {
     scope: options.scope,
     monitor,
     hostingRepair,
-    serviceResults
+    serviceResults,
+    timings
   };
 }
 function resolveRailwayServiceDeployDependencies({
@@ -1397,6 +1446,7 @@ async function publishProjectContent(options) {
   return publishContent(options, reporter);
 }
 async function monitorProjectPlatform(options) {
+  const timings = [];
   const reporter = resolveReporter(options.tenantRoot, options.reporter);
   const env = { ...process.env, ...options.env ?? {} };
   const target = createPersistentDeployTarget(options.scope === "local" ? "staging" : options.scope);
@@ -1408,23 +1458,23 @@ async function monitorProjectPlatform(options) {
   const webProbeUrl = resolveImmediatePagesProbeUrl(siteConfig, state, target);
   const apiBaseUrl = resolveImmediateApiProbeUrl(siteConfig, state, target);
   const apiMonitorEndpoints = resolveApiMonitorEndpoints(siteConfig, apiBaseUrl);
-  const railwayResources = options.scope === "local" || !apiSelected && !agentsSelected ? { ok: true, skipped: true, reason: options.scope === "local" ? "local_scope" : "railway_not_selected" } : await verifyRailwayManagedResources(options.tenantRoot, options.scope, {
+  const railwayResources = options.scope === "local" || !apiSelected && !agentsSelected ? { ok: true, skipped: true, reason: options.scope === "local" ? "local_scope" : "railway_not_selected" } : await timedPhase(timings, "monitor:railway-resources", () => verifyRailwayManagedResources(options.tenantRoot, options.scope, {
     env,
     settleDeployments: true,
     onProgress: options.write
-  });
+  }));
   const skippedApiCheck = apiSelected ? { ok: false, skipped: true, reason: "api_url_unconfigured" } : { ok: true, skipped: true, reason: "api_not_selected" };
   const skippedAgentCheck = agentsSelected ? { ok: false, skipped: true, reason: "api_url_unconfigured" } : { ok: true, skipped: true, reason: "agents_not_selected" };
   const skippedD1Check = apiMonitorEndpoints.processingAgentApi ? { ok: true, skipped: true, reason: "processing_agent_api" } : skippedApiCheck;
   const checks = {
-    pages: await probeHttp(webProbeUrl, { attempts: 3, delayMs: 5e3 }),
-    apiHealth: apiSelected && apiMonitorEndpoints.apiHealth ? await probeHttp(apiMonitorEndpoints.apiHealth, { attempts: 8, delayMs: 1e4 }) : skippedApiCheck,
-    apiReady: apiSelected && apiMonitorEndpoints.apiReady ? await probeHttp(apiMonitorEndpoints.apiReady, { attempts: 8, delayMs: 1e4 }) : skippedApiCheck,
-    d1Health: apiSelected && apiMonitorEndpoints.d1Health ? await probeHttp(apiMonitorEndpoints.d1Health, { attempts: 8, delayMs: 1e4 }) : skippedD1Check,
-    agentHealth: agentsSelected && apiMonitorEndpoints.agentHealth ? await probeHttp(apiMonitorEndpoints.agentHealth, { attempts: 8, delayMs: 1e4 }) : skippedAgentCheck,
-    r2: options.dryRun ? { ok: true, skipped: true, reason: "dry_run" } : probeR2(options.tenantRoot, siteConfig, state, target),
-    queue: options.dryRun ? Promise.resolve({ ok: true, skipped: true, reason: "dry_run" }) : probeQueue(siteConfig, state),
-    scaleProbe: probeScaleConfiguration(siteConfig, state),
+    pages: await timedPhase(timings, "monitor:probe-pages", () => probeHttp(webProbeUrl, { attempts: 3, delayMs: 5e3 })),
+    apiHealth: apiSelected && apiMonitorEndpoints.apiHealth ? await timedPhase(timings, "monitor:probe-api-health", () => probeHttp(apiMonitorEndpoints.apiHealth, { attempts: 8, delayMs: 1e4 })) : skippedApiCheck,
+    apiReady: apiSelected && apiMonitorEndpoints.apiReady ? await timedPhase(timings, "monitor:probe-api-ready", () => probeHttp(apiMonitorEndpoints.apiReady, { attempts: 8, delayMs: 1e4 })) : skippedApiCheck,
+    d1Health: apiSelected && apiMonitorEndpoints.d1Health ? await timedPhase(timings, "monitor:probe-d1-health", () => probeHttp(apiMonitorEndpoints.d1Health, { attempts: 8, delayMs: 1e4 })) : skippedD1Check,
+    agentHealth: agentsSelected && apiMonitorEndpoints.agentHealth ? await timedPhase(timings, "monitor:probe-agent-health", () => probeHttp(apiMonitorEndpoints.agentHealth, { attempts: 8, delayMs: 1e4 })) : skippedAgentCheck,
+    r2: options.dryRun ? { ok: true, skipped: true, reason: "dry_run" } : timedPhase(timings, "monitor:probe-r2", () => probeR2(options.tenantRoot, siteConfig, state, target)),
+    queue: options.dryRun ? Promise.resolve({ ok: true, skipped: true, reason: "dry_run" }) : timedPhase(timings, "monitor:probe-queue", () => probeQueue(siteConfig, state)),
+    scaleProbe: await timedPhase(timings, "monitor:probe-scale", () => probeScaleConfiguration(siteConfig, state)),
     railwayResources,
     readiness: state.readiness,
     apiMonitor: {
@@ -1464,14 +1514,16 @@ ${failedChecks.join("\n")}`);
     metadata: {
       mode: "monitor",
       target: deployTargetLabel(target),
-      checks: resolvedChecks
+      checks: resolvedChecks,
+      timings
     },
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   return {
     ok,
     target: deployTargetLabel(target),
-    checks: resolvedChecks
+    checks: resolvedChecks,
+    timings
   };
 }
 async function syncControlPlaneState(options) {

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

@@ -31,18 +31,47 @@ export declare function runRailway(args: any, { cwd, capture, allowFailure, inpu
     retryAttempts?: number | undefined;
     retryDelayMs?: number | undefined;
 }): import("child_process").SpawnSyncReturns<string> | null;
-export declare function waitForRailwayManagedDeploymentsSettled(tenantRoot: any, scope: any, { services, env, timeoutMs, pollMs, onProgress, }?: {
+export declare function waitForRailwayManagedDeploymentsSettled(tenantRoot: any, scope: any, { services, env, timeoutMs, pollMs, fetchImpl, onProgress, }?: {
     services?: unknown[] | undefined;
     env?: NodeJS.ProcessEnv | undefined;
     timeoutMs?: number | undefined;
     pollMs?: number | undefined;
+    fetchImpl?: typeof fetch | undefined;
 }): Promise<{
+    ok: boolean;
+    checks: {
+        type: string;
+        service: any;
+        serviceName: any;
+        environment: string;
+        ok: boolean;
+        status: string;
+        settle: {
+            durationMs: number;
+            pollCount: number;
+            finalStatus: string;
+        };
+        message: string;
+    }[];
+    settle?: undefined;
+    message?: undefined;
+} | {
     ok: boolean;
     checks: any;
+    settle: {
+        durationMs: number;
+        pollCount: number;
+        status: string;
+    };
     message?: undefined;
 } | {
     ok: boolean;
     checks: any;
+    settle: {
+        durationMs: number;
+        pollCount: number;
+        status: string;
+    };
     message: string;
 }>;
 export declare function setRailwaySecretVariable({ cwd, service, environment, key, value, env, capture, allowFailure }: {

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

@@ -24,6 +24,7 @@ import {
   resolveRailwayWorkspaceContext,
   upsertRailwayVariables
 } from "./railway-api.js";
+import { elapsedMs, formatDurationMs } from "../../timing.js";
 function normalizeScope(scope) {
   return scope === "prod" ? "prod" : scope === "staging" ? "staging" : "local";
 }
@@ -171,6 +172,26 @@ function collectRailwayDeploymentStatusChecks(statusPayload, scope, services) {
       };
     }
     const deployment = instance.latestDeployment ?? null;
+    if (!deployment) {
+      return {
+        type: "deployment-status",
+        service: service.key,
+        serviceName: service.serviceName,
+        environment: normalizeRailwayEnvironmentName(environment.name),
+        ok: true,
+        skipped: true,
+        status: "no_active_deployment",
+        observed: {
+          status: null,
+          deploymentId: null,
+          deploymentCreatedAt: null,
+          deploymentStopped: null,
+          instanceStatuses: [],
+          volumeMounts: []
+        },
+        message: `Railway service ${service.serviceName} has no active deployment to wait for.`
+      };
+    }
     const status = String(deployment?.status ?? "").trim().toUpperCase();
     const instanceStatuses = Array.isArray(deployment?.instances) ? deployment.instances.map((entry) => String(entry?.status ?? "").trim()).filter(Boolean) : [];
     const ok = railwayStatusDeploymentSettled(status);
@@ -183,6 +204,8 @@ function collectRailwayDeploymentStatusChecks(statusPayload, scope, services) {
       status: status || "missing_deployment",
       observed: {
         status: status || null,
+        deploymentId: deployment?.id ?? null,
+        deploymentCreatedAt: deployment?.createdAt ?? null,
         deploymentStopped: deployment?.deploymentStopped ?? null,
         instanceStatuses,
         volumeMounts: Array.isArray(deployment?.meta?.volumeMounts) ? deployment.meta.volumeMounts : []
@@ -474,8 +497,10 @@ async function waitForRailwayManagedDeploymentsSettled(tenantRoot, scope, {
   env = process.env,
   timeoutMs = 6e5,
   pollMs = 15e3,
+  fetchImpl = fetch,
   onProgress
 } = {}) {
+  const startMs = performance.now();
   const deadline = Date.now() + timeoutMs;
   const projectId = services.find((service) => typeof service.projectId === "string" && service.projectId.trim())?.projectId ?? null;
   if (!projectId) {
@@ -488,6 +513,11 @@ async function waitForRailwayManagedDeploymentsSettled(tenantRoot, scope, {
         environment: resolveRailwayEnvironmentForScope(scope),
         ok: false,
         status: "missing_project",
+        settle: {
+          durationMs: elapsedMs(startMs),
+          pollCount: 0,
+          finalStatus: "missing_project"
+        },
         message: `Railway deployment status for ${service.serviceName} cannot be checked without a project id.`
       }))
     };
@@ -495,12 +525,15 @@ async function waitForRailwayManagedDeploymentsSettled(tenantRoot, scope, {
   let checks = [];
   let lastError = null;
   let lastSummary = "";
+  let pollCount = 0;
   for (; ; ) {
     lastError = null;
+    pollCount += 1;
     try {
       const statusPayload = await fetchRailwayProjectDeploymentStatus({
         projectId,
-        env
+        env,
+        fetchImpl
       });
       checks = collectRailwayDeploymentStatusChecks(statusPayload, scope, services);
     } catch (error) {
@@ -512,28 +545,63 @@ async function waitForRailwayManagedDeploymentsSettled(tenantRoot, scope, {
         environment: resolveRailwayEnvironmentForScope(scope),
         ok: false,
         status: "status_error",
+        settle: {
+          durationMs: elapsedMs(startMs),
+          pollCount,
+          finalStatus: "status_error"
+        },
         message: error instanceof Error ? error.message : String(error)
       }));
     }
     const summary = formatRailwayDeploymentStatusSummary(scope, checks);
-    if (summary !== lastSummary || !checks.every((entry) => entry.ok === true)) {
-      onProgress?.(summary, "stdout");
-      lastSummary = summary;
+    const progress = `${summary} poll=${pollCount} elapsed=${formatDurationMs(elapsedMs(startMs))}`;
+    if (progress !== lastSummary || !checks.every((entry) => entry.ok === true || entry.skipped === true)) {
+      onProgress?.(progress, "stdout");
+      lastSummary = progress;
     }
-    if (checks.every((entry) => entry.ok === true)) {
-      return { ok: true, checks };
+    if (checks.every((entry) => entry.ok === true || entry.skipped === true)) {
+      return {
+        ok: true,
+        checks: checks.map((check) => ({
+          ...check,
+          settle: {
+            durationMs: elapsedMs(startMs),
+            pollCount,
+            finalStatus: check.status,
+            fastSkipped: check.skipped === true
+          }
+        })),
+        settle: {
+          durationMs: elapsedMs(startMs),
+          pollCount,
+          status: checks.every((entry) => entry.skipped === true) ? "skipped" : "settled"
+        }
+      };
     }
     if (Date.now() >= deadline) {
       return {
         ok: false,
-        checks,
+        checks: checks.map((check) => ({
+          ...check,
+          settle: {
+            durationMs: elapsedMs(startMs),
+            pollCount,
+            finalStatus: check.status,
+            timeout: true
+          }
+        })),
+        settle: {
+          durationMs: elapsedMs(startMs),
+          pollCount,
+          status: "timeout"
+        },
         message: lastError instanceof Error ? lastError.message : "Railway deployments did not settle before the monitor timeout."
       };
     }
     await sleep(pollMs);
   }
 }
-async function fetchRailwayProjectDeploymentStatus({ projectId, env = process.env }) {
+async function fetchRailwayProjectDeploymentStatus({ projectId, env = process.env, fetchImpl = fetch }) {
   const payload = await railwayGraphqlRequest({
     query: `
 query TreeseedRailwayDeploymentStatus($projectId: String!) {
@@ -571,7 +639,8 @@ query TreeseedRailwayDeploymentStatus($projectId: String!) {
 }
 `.trim(),
     variables: { projectId },
-    env
+    env,
+    fetchImpl
   });
   return payload.data?.project ?? null;
 }
@@ -1300,6 +1369,7 @@ async function verifyRailwayManagedResources(tenantRoot, scope, {
     const settled = await waitForRailwayManagedDeploymentsSettled(tenantRoot, scope, {
       services: deploymentStatusServices.length > 0 ? deploymentStatusServices : services,
       env: effectiveEnv,
+      fetchImpl,
       timeoutMs: settleTimeoutMs,
       pollMs: settlePollMs,
       onProgress

package/dist/operations/services/template-registry.js

@@ -11,6 +11,7 @@ import {
   cliPackageVersion,
   agentPackageVersion,
   corePackageVersion,
+  cliPackageRoot,
   localTemplateArtifactsRoot,
   sdkPackageVersion
 } from "./runtime-paths.js";
@@ -37,10 +38,31 @@ function listFiles(root) {
   return files;
 }
 function listTemplateArtifactIds() {
-  if (!existsSync(localTemplateArtifactsRoot)) {
-    return [];
+  const packagedIds = existsSync(localTemplateArtifactsRoot) ? readdirSync(localTemplateArtifactsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
+  const localStarterIds = listLocalStarterArtifacts().map((entry) => entry.id);
+  return [.../* @__PURE__ */ new Set([...packagedIds, ...localStarterIds])].sort((left, right) => left.localeCompare(right, void 0, { sensitivity: "base" }));
+}
+const LOCAL_STARTER_ID_TO_DIRECTORY = {
+  "starter-research": "research",
+  "starter-engineering": "engineering",
+  "starter-information-hub": "information-hub"
+};
+function localStartersRoot() {
+  return resolve(cliPackageRoot, "..", "..", "starters");
+}
+function resolveLocalStarterArtifactRoot(id) {
+  const directory = LOCAL_STARTER_ID_TO_DIRECTORY[id];
+  if (!directory) {
+    return null;
   }
-  return readdirSync(localTemplateArtifactsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((left, right) => left.localeCompare(right, void 0, { sensitivity: "base" }));
+  const artifactRoot = resolve(localStartersRoot(), directory);
+  return existsSync(resolve(artifactRoot, "template.config.json")) && existsSync(resolve(artifactRoot, "template")) ? artifactRoot : null;
+}
+function listLocalStarterArtifacts() {
+  return Object.keys(LOCAL_STARTER_ID_TO_DIRECTORY).map((id) => {
+    const artifactRoot = resolveLocalStarterArtifactRoot(id);
+    return artifactRoot ? { id, artifactRoot } : null;
+  }).filter((entry) => Boolean(entry));
 }
 function isTextFile(filePath) {
   return !/\.(png|jpe?g|gif|webp|ico|woff2?|ttf|eot|pdf|zip|gz)$/iu.test(filePath);
@@ -166,6 +188,14 @@ function materializeR2TemplateSource(product) {
   );
 }
 function resolveTemplateDefinitionPaths(product, options) {
+  const localStarterArtifactRoot = resolveLocalStarterArtifactRoot(product.id);
+  if (localStarterArtifactRoot) {
+    return {
+      artifactRoot: localStarterArtifactRoot,
+      manifestPath: resolve(localStarterArtifactRoot, "template.config.json"),
+      templateRoot: resolve(localStarterArtifactRoot, "template")
+    };
+  }
   if (existsSync(product.artifactManifestPath) && existsSync(product.templateRoot)) {
     return {
       artifactRoot: product.artifactRoot,

package/dist/platform/contracts.d.ts

@@ -283,6 +283,7 @@ export interface TreeseedDeployConfig {
     slug: string;
     siteUrl: string;
     contactEmail: string;
+    projectRoot?: string;
     hosting?: TreeseedHostingConfig;
     hub: TreeseedHubConfig;
     runtime: TreeseedRuntimeConfig;

package/dist/platform/deploy-config.js

@@ -9,7 +9,8 @@ import {
 } from "./plugins/constants.js";
 const deployConfigFieldAliases = {
   siteUrl: { key: "siteUrl", aliases: ["site_url"] },
-  contactEmail: { key: "contactEmail", aliases: ["contact_email"] }
+  contactEmail: { key: "contactEmail", aliases: ["contact_email"] },
+  projectRoot: { key: "projectRoot", aliases: ["project_root"] }
 };
 const hostingFieldAliases = {
   kind: { key: "kind", aliases: ["kind"] },
@@ -547,6 +548,7 @@ function parseDeployConfig(raw) {
     slug: expectString(parsed.slug, "slug"),
     siteUrl: expectString(parsed.siteUrl, "siteUrl"),
     contactEmail: expectString(parsed.contactEmail, "contactEmail"),
+    projectRoot: optionalString(parsed.projectRoot),
     hosting: compatibilityHosting,
     hub,
     runtime,
@@ -630,10 +632,15 @@ function loadTreeseedDeployConfig(configPath = "treeseed.site.yaml") {
 function loadTreeseedDeployConfigFromPath(resolvedConfigPath) {
   const tenantRoot = dirname(resolvedConfigPath);
   const parsed = parseDeployConfig(readFileSync(resolvedConfigPath, "utf8"));
+  const projectRoot = parsed.projectRoot ? resolve(tenantRoot, parsed.projectRoot) : tenantRoot;
   Object.defineProperty(parsed, "__tenantRoot", {
     value: tenantRoot,
     enumerable: false
   });
+  Object.defineProperty(parsed, "__projectRoot", {
+    value: projectRoot,
+    enumerable: false
+  });
   Object.defineProperty(parsed, "__configPath", {
     value: resolvedConfigPath,
     enumerable: false

package/dist/platform/deploy-runtime.js

@@ -6,6 +6,7 @@ function defaultDeployConfig() {
     slug: "treeseed-site",
     siteUrl: "https://example.com",
     contactEmail: "contact@example.com",
+    projectRoot: ".",
     cloudflare: {
       accountId: "",
       workerName: "treeseed-site"

package/dist/reconcile/engine.d.ts

@@ -1,5 +1,6 @@
 import type { TreeseedObservedUnitState, TreeseedReconcilePlan, TreeseedReconcileResult, TreeseedReconcileStateRecord, TreeseedReconcileTarget, TreeseedUnitVerificationResult } from './contracts.ts';
 import { type TreeseedRunnableBootstrapSystem } from './bootstrap-systems.ts';
+import { type TreeseedTimingEntry } from '../timing.ts';
 export declare function observeTreeseedUnits({ tenantRoot, target, env, systems, write, }: {
     tenantRoot: string;
     target: TreeseedReconcileTarget;
@@ -417,6 +418,7 @@ export declare function reconcileTreeseedTarget({ tenantRoot, target, env, syste
     plans: TreeseedReconcilePlan[];
     results: TreeseedReconcileResult[];
     state: TreeseedReconcileStateRecord;
+    timings: TreeseedTimingEntry[];
 }>;
 export declare function destroyTreeseedTargetUnits({ tenantRoot, target, env, write, }: {
     tenantRoot: string;

package/dist/reconcile/engine.js

@@ -3,6 +3,7 @@ import { deriveTreeseedDesiredUnits } from "./desired-state.js";
 import { ensureTreeseedPersistedUnitState, desiredUnitSpecHash, loadTreeseedReconcileState, updateTreeseedPersistedUnitState, writeTreeseedReconcileState } from "./state.js";
 import { reverseTopologicallySortedUnits, topologicallySortDesiredUnits } from "./units.js";
 import { filterTreeseedDesiredUnitsByBootstrapSystems } from "./bootstrap-systems.js";
+import { elapsedMs, formatDurationMs } from "../timing.js";
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -209,7 +210,9 @@ async function reconcileTreeseedTarget({
   const context = createRunContext(tenantRoot, target, env, write);
   const results = [];
   const verificationMap = /* @__PURE__ */ new Map();
+  const timingEntries = [];
   context.session.set("treeseed:verification-results", verificationMap);
+  context.session.set("treeseed:timings", timingEntries);
   const planByUnitId = new Map(planned.plans.map((plan) => [plan.unit.unitId, plan]));
   let persistChain = Promise.resolve();
   const persistVerifiedResult = async (persisted, verifiedResult) => {
@@ -221,20 +224,43 @@ async function reconcileTreeseedTarget({
   };
   await runByDependencyLevel(topologicallySortDesiredUnits(planned.units), async (unit) => {
     const plan = planByUnitId.get(unit.unitId);
-    write?.(`Reconciling ${plan.unit.provider}:${plan.unit.unitType}...`);
+    const unitTiming = {
+      name: `reconcile:${plan.unit.provider}:${plan.unit.unitType}:${plan.unit.logicalName}`,
+      durationMs: 0,
+      status: "running",
+      children: [],
+      metadata: { unitId: plan.unit.unitId, action: plan.diff.action }
+    };
+    const unitStartMs = performance.now();
+    timingEntries.push(unitTiming);
+    write?.(`Reconciling ${plan.unit.provider}:${plan.unit.unitType} (${plan.unit.logicalName})...`);
     const adapter = registry.get(plan.unit.unitType, plan.unit.provider);
     const persisted = ensureTreeseedPersistedUnitState(planned.state, plan.unit);
     try {
+      const stageStartMs = performance.now();
       await Promise.resolve(adapter.validate?.({
         context,
         unit: plan.unit,
         persistedState: persisted
       }));
+      unitTiming.children?.push({
+        name: `${unitTiming.name}:validate`,
+        durationMs: elapsedMs(stageStartMs),
+        status: "success"
+      });
     } catch (error) {
+      unitTiming.children?.push({
+        name: `${unitTiming.name}:validate`,
+        durationMs: elapsedMs(unitStartMs),
+        status: "failed"
+      });
+      unitTiming.durationMs = elapsedMs(unitStartMs);
+      unitTiming.status = "failed";
       wrapAdapterFailure("validate", plan.unit.provider, plan.unit.unitType, plan.unit.unitId, error);
     }
     let result;
     try {
+      const stageStartMs = performance.now();
       result = await Promise.resolve(adapter.reconcile({
         context,
         unit: plan.unit,
@@ -242,10 +268,22 @@ async function reconcileTreeseedTarget({
         observed: plan.observed,
         diff: plan.diff
       }));
+      unitTiming.children?.push({
+        name: `${unitTiming.name}:reconcile`,
+        durationMs: elapsedMs(stageStartMs),
+        status: "success"
+      });
     } catch (error) {
+      unitTiming.children?.push({
+        name: `${unitTiming.name}:reconcile`,
+        durationMs: elapsedMs(unitStartMs),
+        status: "failed"
+      });
+      unitTiming.durationMs = elapsedMs(unitStartMs);
+      unitTiming.status = "failed";
       wrapAdapterFailure("reconcile", plan.unit.provider, plan.unit.unitType, plan.unit.unitId, error);
     }
-    write?.(`Verifying ${plan.unit.provider}:${plan.unit.unitType}...`);
+    write?.(`Verifying ${plan.unit.provider}:${plan.unit.unitType} (${plan.unit.logicalName})...`);
     const postconditions = await Promise.resolve(adapter.requiredPostconditions?.({
       context,
       unit: plan.unit,
@@ -253,6 +291,7 @@ async function reconcileTreeseedTarget({
     }) ?? []);
     let verification;
     try {
+      const stageStartMs = performance.now();
       verification = await Promise.resolve(adapter.verify({
         context,
         unit: plan.unit,
@@ -262,7 +301,19 @@ async function reconcileTreeseedTarget({
         result,
         postconditions
       }));
+      unitTiming.children?.push({
+        name: `${unitTiming.name}:verify`,
+        durationMs: elapsedMs(stageStartMs),
+        status: verification.verified ? "success" : "failed"
+      });
     } catch (error) {
+      unitTiming.children?.push({
+        name: `${unitTiming.name}:verify`,
+        durationMs: elapsedMs(unitStartMs),
+        status: "failed"
+      });
+      unitTiming.durationMs = elapsedMs(unitStartMs);
+      unitTiming.status = "failed";
       wrapAdapterFailure("verify", plan.unit.provider, plan.unit.unitType, plan.unit.unitId, error);
     }
     const verifiedResult = {
@@ -274,6 +325,9 @@ async function reconcileTreeseedTarget({
       ]
     };
     verificationMap.set(plan.unit.unitId, verification);
+    unitTiming.durationMs = elapsedMs(unitStartMs);
+    unitTiming.status = verification.verified ? "success" : "failed";
+    write?.(`Finished ${plan.unit.provider}:${plan.unit.unitType} (${plan.unit.logicalName}) in ${formatDurationMs(unitTiming.durationMs)}.`);
     if (!verification.verified) {
       await persistVerifiedResult(persisted, verifiedResult);
       throw new Error(`Treeseed reconcile verification failed for ${plan.unit.provider}:${plan.unit.unitType} (${plan.unit.unitId}): ${formatVerificationFailure(verification)}`);
@@ -287,7 +341,8 @@ async function reconcileTreeseedTarget({
     units: planned.units,
     plans: planned.plans,
     results,
-    state: planned.state
+    state: planned.state,
+    timings: timingEntries
   };
 }
 async function destroyTreeseedTargetUnits({

package/dist/timing.d.ts

@@ -0,0 +1,20 @@
+export type TreeseedTimingEntry = {
+    name: string;
+    durationMs: number;
+    status?: string;
+    metadata?: Record<string, unknown>;
+    children?: TreeseedTimingEntry[];
+};
+export declare function nowMs(): number;
+export declare function elapsedMs(startMs: number): number;
+export declare function formatDurationMs(durationMs: number): string;
+export declare function summarizeSlowestTimings(entries: TreeseedTimingEntry[], limit?: number): TreeseedTimingEntry[];
+export declare function flattenTimings(entries: TreeseedTimingEntry[]): TreeseedTimingEntry[];
+export declare function formatTimingSummary(entries: TreeseedTimingEntry[], { title, limit }?: {
+    title?: string | undefined;
+    limit?: number | undefined;
+}): string;
+export declare function formatTimingMarkdown(entries: TreeseedTimingEntry[], { title, limit }?: {
+    title?: string | undefined;
+    limit?: number | undefined;
+}): string;

package/dist/timing.js

@@ -0,0 +1,73 @@
+function nowMs() {
+  return performance.now();
+}
+function elapsedMs(startMs) {
+  return Math.max(0, performance.now() - startMs);
+}
+function formatDurationMs(durationMs) {
+  const value = Math.max(0, Number(durationMs) || 0);
+  if (value < 1e3) {
+    return `${Math.round(value)}ms`;
+  }
+  if (value < 6e4) {
+    return `${(value / 1e3).toFixed(value < 1e4 ? 1 : 0)}s`;
+  }
+  const minutes = Math.floor(value / 6e4);
+  const seconds = Math.round(value % 6e4 / 1e3);
+  return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+}
+function summarizeSlowestTimings(entries, limit = 8) {
+  return flattenTimings(entries).sort((left, right) => right.durationMs - left.durationMs).slice(0, Math.max(0, limit));
+}
+function flattenTimings(entries) {
+  const flattened = [];
+  const visit = (entry) => {
+    flattened.push(entry);
+    for (const child of entry.children ?? []) {
+      visit(child);
+    }
+  };
+  for (const entry of entries) {
+    visit(entry);
+  }
+  return flattened;
+}
+function formatTimingSummary(entries, { title = "Provider deploy timing summary", limit = 12 } = {}) {
+  const slowest = summarizeSlowestTimings(entries, limit);
+  const lines = [`${title}:`];
+  if (slowest.length === 0) {
+    lines.push("- no timed steps recorded");
+    return lines.join("\n");
+  }
+  for (const entry of slowest) {
+    const status = entry.status ? ` [${entry.status}]` : "";
+    lines.push(`- ${entry.name}: ${formatDurationMs(entry.durationMs)}${status}`);
+  }
+  return lines.join("\n");
+}
+function formatTimingMarkdown(entries, { title = "Provider deploy timing summary", limit = 20 } = {}) {
+  const slowest = summarizeSlowestTimings(entries, limit);
+  const lines = [`### ${title}`, "", "| Step | Duration | Status |", "| --- | ---: | --- |"];
+  if (slowest.length === 0) {
+    lines.push("| No timed steps recorded | 0ms | skipped |");
+    return `${lines.join("\n")}
+`;
+  }
+  for (const entry of slowest) {
+    lines.push(`| ${escapeMarkdownCell(entry.name)} | ${formatDurationMs(entry.durationMs)} | ${escapeMarkdownCell(entry.status ?? "")} |`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function escapeMarkdownCell(value) {
+  return value.replace(/\\/gu, "\\\\").replace(/\|/gu, "\\|").replace(/\n/gu, " ");
+}
+export {
+  elapsedMs,
+  flattenTimings,
+  formatDurationMs,
+  formatTimingMarkdown,
+  formatTimingSummary,
+  nowMs,
+  summarizeSlowestTimings
+};

package/dist/treeseed/template-catalog/catalog.fixture.json

@@ -47,6 +47,156 @@
       "relatedBooks": [],
       "relatedKnowledge": [],
       "relatedObjectives": []
+    },
+    {
+      "id": "starter-research",
+      "displayName": "TreeSeed Research",
+      "description": "First-party TreeSeed starter for freestanding research projects and knowledge-pack publishing.",
+      "summary": "A research starter for building source-backed books, gathered assets, synthesis notes, and reusable knowledge packs.",
+      "status": "live",
+      "featured": true,
+      "category": "starter",
+      "audience": [
+        "researchers",
+        "maintainers"
+      ],
+      "tags": [
+        "starter",
+        "research",
+        "books",
+        "knowledge-packs",
+        "agents"
+      ],
+      "publisher": {
+        "id": "treeseed",
+        "name": "TreeSeed",
+        "url": "https://treeseed.ai"
+      },
+      "publisherVerified": true,
+      "templateVersion": "1.0.0",
+      "templateApiVersion": 1,
+      "minCliVersion": "0.1.1",
+      "minCoreVersion": "0.1.2",
+      "fulfillment": {
+        "mode": "git",
+        "source": {
+          "kind": "git",
+          "repoUrl": "https://github.com/treeseed-ai/starter-research.git",
+          "directory": ".",
+          "ref": "main",
+          "integrity": "pending-external-repo"
+        },
+        "hooksPolicy": "builtin_only",
+        "supportsReconcile": true
+      },
+      "offer": {
+        "priceModel": "free",
+        "license": "AGPL-3.0-only",
+        "support": "community"
+      },
+      "relatedBooks": [],
+      "relatedKnowledge": [],
+      "relatedObjectives": []
+    },
+    {
+      "id": "starter-engineering",
+      "displayName": "TreeSeed Engineering",
+      "description": "First-party TreeSeed starter for integrated software guidance, docs, and engineering agents.",
+      "summary": "An engineering starter for guiding software projects with research, architecture, implementation, review, and release agents.",
+      "status": "live",
+      "featured": true,
+      "category": "starter",
+      "audience": [
+        "engineers",
+        "maintainers"
+      ],
+      "tags": [
+        "starter",
+        "engineering",
+        "software",
+        "docs",
+        "agents"
+      ],
+      "publisher": {
+        "id": "treeseed",
+        "name": "TreeSeed",
+        "url": "https://treeseed.ai"
+      },
+      "publisherVerified": true,
+      "templateVersion": "1.0.0",
+      "templateApiVersion": 1,
+      "minCliVersion": "0.1.1",
+      "minCoreVersion": "0.1.2",
+      "fulfillment": {
+        "mode": "git",
+        "source": {
+          "kind": "git",
+          "repoUrl": "https://github.com/treeseed-ai/starter-engineering.git",
+          "directory": ".",
+          "ref": "main",
+          "integrity": "pending-external-repo"
+        },
+        "hooksPolicy": "builtin_only",
+        "supportsReconcile": true
+      },
+      "offer": {
+        "priceModel": "free",
+        "license": "AGPL-3.0-only",
+        "support": "community"
+      },
+      "relatedBooks": [],
+      "relatedKnowledge": [],
+      "relatedObjectives": []
+    },
+    {
+      "id": "starter-information-hub",
+      "displayName": "TreeSeed Information Hub",
+      "description": "First-party TreeSeed starter for recurring information retrieval, distillation, and downstream distribution.",
+      "summary": "An information distribution starter for retrieving updates over time, distilling derived knowledge, and packaging it for downstream projects.",
+      "status": "live",
+      "featured": true,
+      "category": "starter",
+      "audience": [
+        "curators",
+        "maintainers"
+      ],
+      "tags": [
+        "starter",
+        "information-hub",
+        "distribution",
+        "knowledge-packs",
+        "agents"
+      ],
+      "publisher": {
+        "id": "treeseed",
+        "name": "TreeSeed",
+        "url": "https://treeseed.ai"
+      },
+      "publisherVerified": true,
+      "templateVersion": "1.0.0",
+      "templateApiVersion": 1,
+      "minCliVersion": "0.1.1",
+      "minCoreVersion": "0.1.2",
+      "fulfillment": {
+        "mode": "git",
+        "source": {
+          "kind": "git",
+          "repoUrl": "https://github.com/treeseed-ai/starter-information-hub.git",
+          "directory": ".",
+          "ref": "main",
+          "integrity": "pending-external-repo"
+        },
+        "hooksPolicy": "builtin_only",
+        "supportsReconcile": true
+      },
+      "offer": {
+        "priceModel": "free",
+        "license": "AGPL-3.0-only",
+        "support": "community"
+      },
+      "relatedBooks": [],
+      "relatedKnowledge": [],
+      "relatedObjectives": []
     }
   ],
   "meta": {

package/package.json

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

package/templates/github/deploy-web.workflow.yml

@@ -120,7 +120,11 @@ __WORKING_DIRECTORY_BLOCK__  web:
         shell: bash
         run: |
           set -euo pipefail
+          TIMING_SUMMARY="${RUNNER_TEMP:-/tmp}/treeseed-provider-timing.md"
+          : > "${TIMING_SUMMARY}"
+          export TREESEED_PROVIDER_TIMING_SUMMARY_PATH="${TIMING_SUMMARY}"
           EXTRA_ARGS=()
           if [[ -n "${TREESEED_WORKFLOW_PROJECT:-}" ]]; then EXTRA_ARGS+=(--project-id "${TREESEED_WORKFLOW_PROJECT}"); fi
           if [[ -n "${TREESEED_WORKFLOW_PREVIEW_ID:-}" ]]; then EXTRA_ARGS+=(--preview-id "${TREESEED_WORKFLOW_PREVIEW_ID}"); fi
           node ./packages/sdk/scripts/run-ts.mjs ./packages/sdk/scripts/tenant-workflow-action.ts --action "${TREESEED_WORKFLOW_ACTION}" --environment "${TREESEED_WORKFLOW_ENVIRONMENT}" "${EXTRA_ARGS[@]}"
+          if [[ -n "${GITHUB_STEP_SUMMARY:-}" && -s "${TIMING_SUMMARY}" ]]; then cat "${TIMING_SUMMARY}" >> "${GITHUB_STEP_SUMMARY}"; fi