@treeseed/sdk 0.10.28 → 0.12.4

package/dist/operations-types.d.ts

@@ -1,5 +1,5 @@
 export type TreeseedOperationGroup = 'Workflow' | 'Local Development' | 'Validation' | 'Release Utilities' | 'Utilities' | 'Passthrough';
-export type TreeseedOperationId = 'workspace.status' | 'workspace.doctor' | 'branch.tasks' | 'branch.switch' | 'branch.save' | 'branch.close' | 'branch.stage' | 'deploy.release' | 'deploy.rollback' | 'deploy.destroy' | 'workspace.resume' | 'workspace.recover' | 'template.list' | 'template.show' | 'template.validate' | 'template.sync' | 'project.init' | 'project.config' | 'local.dev' | 'local.devWatch' | 'local.build' | 'local.check' | 'local.preview' | 'local.lint' | 'local.test' | 'validation.testUnit' | 'validation.preflight' | 'validation.authCheck' | 'auth.login' | 'auth.logout' | 'auth.whoami' | 'release.testE2e' | 'release.testE2eLocal' | 'release.testE2eStaging' | 'release.testE2eFull' | 'release.testFast' | 'release.verify' | 'release.publishChanged' | 'services.mailpitUp' | 'services.mailpitDown' | 'services.mailpitLogs' | 'data.d1MigrateLocal' | 'content.cleanupMarkdown' | 'content.cleanupMarkdownCheck' | 'project.export' | 'tools.astro' | 'tools.syncDevvars' | 'tools.starlightPatch' | 'agents.run';
+export type TreeseedOperationId = 'workspace.status' | 'workspace.doctor' | 'branch.tasks' | 'branch.switch' | 'branch.save' | 'branch.close' | 'branch.stage' | 'deploy.release' | 'deploy.rollback' | 'deploy.destroy' | 'workspace.resume' | 'workspace.recover' | 'template.list' | 'template.show' | 'template.validate' | 'template.sync' | 'project.init' | 'project.config' | 'local.dev' | 'local.devWatch' | 'local.build' | 'local.check' | 'local.preview' | 'local.lint' | 'local.test' | 'validation.testUnit' | 'validation.preflight' | 'validation.authCheck' | 'auth.login' | 'auth.logout' | 'auth.whoami' | 'release.testE2e' | 'release.testE2eLocal' | 'release.testE2eStaging' | 'release.testE2eFull' | 'release.testFast' | 'release.verify' | 'release.publishChanged' | 'data.d1MigrateLocal' | 'content.cleanupMarkdown' | 'content.cleanupMarkdownCheck' | 'project.export' | 'tools.astro' | 'tools.syncDevvars' | 'tools.starlightPatch' | 'agents.run';
 export type TreeseedOperationProviderId = 'default';
 export type TreeseedOperationMetadata = {
     id: TreeseedOperationId;

package/dist/operations.d.ts

@@ -1,11 +1,17 @@
-export { TRESEED_OPERATION_SPECS, findTreeseedOperation, listTreeseedOperationNames, } from './operations-registry.ts';
-export { collectTreeseedConfigSeedValues } from './operations/services/config-runtime.ts';
-export { createKnowledgeHubRepositories, defaultHubContentResolutionPolicy, executeKnowledgeHubLaunch, normalizeKnowledgeHubLaunchIntent, planKnowledgeHubLaunch, planKnowledgeHubRepositories, validateRepositoryHost, } from './operations/services/hub-launch.ts';
-export { TreeseedOperationsSdk } from './operations/runtime.ts';
-export { cancelGitHubWorkflowRun, dispatchGitHubWorkflowRun, formatGitHubWorkflowFailure, waitForGitHubWorkflowRunCompletion, type GitHubWorkflowCancellationResult, type GitHubWorkflowDispatchResult, type GitHubWorkflowFailureSummary, type GitHubWorkflowFailureSummaryInput, type GitHubWorkflowProgressEvent, } from './operations/services/github-api.ts';
-export type { HubContentResolutionPolicy, KnowledgeHubLaunchIntent, KnowledgeHubLaunchPhase, KnowledgeHubLaunchPlan, KnowledgeHubLaunchResult, KnowledgeHubRepositoryPlan, RepositoryHost, } from './operations/services/hub-launch.ts';
-export type { TreeseedOperationContext, TreeseedOperationImplementation, TreeseedOperationId, TreeseedOperationMetadata, TreeseedOperationProvider, TreeseedOperationProviderId, TreeseedOperationRequest, TreeseedOperationResult, TreeseedOperationGroup, } from './operations-types.ts';
-export { TreeseedOperationError } from './operations-types.ts';
-export { AGENT_OPERATION_MODES, AGENT_OPERATION_NAMES, createAgentOperationEvent, decideAgentOperationPermission, deniedAgentOperationResult, isAgentOperationName, resolveAgentOperationGrant, type AgentDeterministicOperationStep, type AgentOperationApprovalRef, type AgentOperationEvent, type AgentOperationGrant, type AgentOperationMergeFailure, type AgentOperationMode, type AgentOperationName, type AgentOperationPermissionCode, type AgentOperationPermissionDecision, type AgentOperationRequest, type AgentOperationResult, type AgentOperationStatus, } from './operations/agent-tools.ts';
-export { TreeseedWorkflowSdk } from './workflow.ts';
-export type * from './workflow.ts';
+export { TRESEED_OPERATION_SPECS, findTreeseedOperation, listTreeseedOperationNames, } from './operations-registry.js';
+export { collectTreeseedConfigSeedValues } from './operations/services/config-runtime.js';
+export { createKnowledgeHubRepositories, defaultHubContentResolutionPolicy, executeKnowledgeHubLaunch, normalizeKnowledgeHubLaunchIntent, planKnowledgeHubLaunch, planKnowledgeHubRepositories, validateRepositoryHost, } from './operations/services/hub-launch.js';
+export { TreeseedOperationsSdk } from './operations/runtime.js';
+export { cancelGitHubWorkflowRun, formatGitHubWorkflowFailure, waitForGitHubWorkflowRunCompletion, type GitHubWorkflowCancellationResult, type GitHubWorkflowFailureSummary, type GitHubWorkflowFailureSummaryInput, type GitHubWorkflowProgressEvent, } from './operations/services/github-api.js';
+export { computeProofInputHash, createProofRecord, proofIdFor, type TreeseedProofDriver, type TreeseedProofInput, type TreeseedProofRecord, type TreeseedProofStatus, type TreeseedProofSubject, type TreeseedProofSubjectKind, } from './operations/services/release-proof.js';
+export { cleanProofLedger, findReusableProof, invalidateProofs, readProofLedger, writeProofRecord, } from './operations/services/release-proof-ledger.js';
+export { buildTreeseedProofPlan, summarizeTreeseedProofLedger, type TreeseedProofPlan, type TreeseedProofPlanSubject, type TreeseedProofTarget, } from './operations/services/release-proof-planner.js';
+export { runTreeseedProof, type TreeseedProofRunResult, } from './operations/services/release-proof-runner.js';
+export { createTreeseedWorkflowTimer, formatTreeseedDuration, slowestTreeseedWorkflowPhases, type TreeseedWorkflowTiming, type TreeseedWorkflowTimingPhase, } from './operations/services/workflow-timing.js';
+export { classifyTreeseedGitMode, inspectTreeseedGitLocks, inspectTreeseedWorkspaceGitLocks, recoverTreeseedGitLocks, runTreeseedGit, runTreeseedGitBatch, runTreeseedGitOk, runTreeseedGitText, type TreeseedGitBatchOperation, type TreeseedGitLockDiagnostic, type TreeseedGitRunnerMode, type TreeseedGitRunnerResult, type TreeseedGitWorkspaceLockDiagnostics, } from './operations/services/git-runner.js';
+export type { HubContentResolutionPolicy, KnowledgeHubLaunchIntent, KnowledgeHubLaunchPhase, KnowledgeHubLaunchPlan, KnowledgeHubLaunchResult, KnowledgeHubRepositoryPlan, RepositoryHost, } from './operations/services/hub-launch.js';
+export type { TreeseedOperationContext, TreeseedOperationImplementation, TreeseedOperationId, TreeseedOperationMetadata, TreeseedOperationProvider, TreeseedOperationProviderId, TreeseedOperationRequest, TreeseedOperationResult, TreeseedOperationGroup, } from './operations-types.js';
+export { TreeseedOperationError } from './operations-types.js';
+export { AGENT_OPERATION_MODES, AGENT_OPERATION_NAMES, createAgentOperationEvent, decideAgentOperationPermission, deniedAgentOperationResult, isAgentOperationName, resolveAgentOperationGrant, type AgentDeterministicOperationStep, type AgentOperationEvent, type AgentOperationGrant, type AgentOperationMergeFailure, type AgentOperationMode, type AgentOperationName, type AgentOperationPermissionCode, type AgentOperationPermissionDecision, type AgentOperationRequest, type AgentOperationResult, type AgentOperationStatus, } from './operations/agent-tools.js';
+export { TreeseedWorkflowSdk } from './workflow.js';
+export type * from './workflow.js';

package/dist/operations.js

@@ -16,10 +16,43 @@ import {
 import { TreeseedOperationsSdk } from "./operations/runtime.js";
 import {
   cancelGitHubWorkflowRun,
-  dispatchGitHubWorkflowRun,
   formatGitHubWorkflowFailure,
   waitForGitHubWorkflowRunCompletion
 } from "./operations/services/github-api.js";
+import {
+  computeProofInputHash,
+  createProofRecord,
+  proofIdFor
+} from "./operations/services/release-proof.js";
+import {
+  cleanProofLedger,
+  findReusableProof,
+  invalidateProofs,
+  readProofLedger,
+  writeProofRecord
+} from "./operations/services/release-proof-ledger.js";
+import {
+  buildTreeseedProofPlan,
+  summarizeTreeseedProofLedger
+} from "./operations/services/release-proof-planner.js";
+import {
+  runTreeseedProof
+} from "./operations/services/release-proof-runner.js";
+import {
+  createTreeseedWorkflowTimer,
+  formatTreeseedDuration,
+  slowestTreeseedWorkflowPhases
+} from "./operations/services/workflow-timing.js";
+import {
+  classifyTreeseedGitMode,
+  inspectTreeseedGitLocks,
+  inspectTreeseedWorkspaceGitLocks,
+  recoverTreeseedGitLocks,
+  runTreeseedGit,
+  runTreeseedGitBatch,
+  runTreeseedGitOk,
+  runTreeseedGitText
+} from "./operations/services/git-runner.js";
 import { TreeseedOperationError } from "./operations-types.js";
 import {
   AGENT_OPERATION_MODES,
@@ -38,23 +71,44 @@ export {
   TreeseedOperationError,
   TreeseedOperationsSdk,
   TreeseedWorkflowSdk,
+  buildTreeseedProofPlan,
   cancelGitHubWorkflowRun,
+  classifyTreeseedGitMode,
+  cleanProofLedger,
   collectTreeseedConfigSeedValues,
+  computeProofInputHash,
   createAgentOperationEvent,
   createKnowledgeHubRepositories,
+  createProofRecord,
+  createTreeseedWorkflowTimer,
   decideAgentOperationPermission,
   defaultHubContentResolutionPolicy,
   deniedAgentOperationResult,
-  dispatchGitHubWorkflowRun,
   executeKnowledgeHubLaunch,
+  findReusableProof,
   findTreeseedOperation,
   formatGitHubWorkflowFailure,
+  formatTreeseedDuration,
+  inspectTreeseedGitLocks,
+  inspectTreeseedWorkspaceGitLocks,
+  invalidateProofs,
   isAgentOperationName,
   listTreeseedOperationNames,
   normalizeKnowledgeHubLaunchIntent,
   planKnowledgeHubLaunch,
   planKnowledgeHubRepositories,
+  proofIdFor,
+  readProofLedger,
+  recoverTreeseedGitLocks,
   resolveAgentOperationGrant,
+  runTreeseedGit,
+  runTreeseedGitBatch,
+  runTreeseedGitOk,
+  runTreeseedGitText,
+  runTreeseedProof,
+  slowestTreeseedWorkflowPhases,
+  summarizeTreeseedProofLedger,
   validateRepositoryHost,
-  waitForGitHubWorkflowRunCompletion
+  waitForGitHubWorkflowRunCompletion,
+  writeProofRecord
 };

package/dist/platform/book-export.js

@@ -217,6 +217,8 @@ async function renderRepomixMarkdown(stageRoot, outputPath) {
     output: outputPath,
     style: "markdown",
     ignore: "",
+    gitignore: false,
+    dotIgnore: false,
     quiet: true,
     skipLocalConfig: true,
     copy: false,

package/dist/platform/books-data.d.ts

@@ -1,4 +1,4 @@
-import type { TreeseedBookDefinition, TreeseedTenantConfig } from './contracts.ts';
+import type { TreeseedBookDefinition, TreeseedTenantConfig } from './contracts.js';
 export interface DocsLibraryDownload {
     downloadFileName: string;
     downloadHref: string;

package/dist/platform/config.d.ts

@@ -0,0 +1,27 @@
+import { discoverTreeseedApplications } from '../hosting/apps.js';
+import { discoverTreeseedPackageAdapters } from '../operations/services/package-adapters.js';
+import { collectTreeseedEnvironmentContext } from '../operations/services/config-runtime.js';
+import type { TreeseedDeployConfig } from './contracts.js';
+export type TreeseedPlatformConfigInput = {
+    tenantRoot: string;
+    environment: 'local' | 'staging' | 'prod';
+    env?: Record<string, string | undefined>;
+    capacityConfigPath?: string | null;
+};
+declare function loadCapacityLaunchFromPackageManifest(tenantRoot: string): {
+    path: string;
+    manifest: import("../capacity-provider.js").CapacityProviderLaunchManifest;
+    plan: import("../capacity-provider.js").CapacityProviderLaunchPlan;
+} | null;
+declare function loadTreeseedDevManifest(tenantRoot: string): Record<string, unknown>;
+export declare function loadTreeseedPlatformConfig(input: TreeseedPlatformConfigInput): {
+    tenantRoot: string;
+    environment: 'local' | 'staging' | 'prod';
+    deployConfig: TreeseedDeployConfig;
+    packages: ReturnType<typeof discoverTreeseedPackageAdapters>;
+    applications: ReturnType<typeof discoverTreeseedApplications>;
+    capacityLaunch: ReturnType<typeof loadCapacityLaunchFromPackageManifest>;
+    dev: ReturnType<typeof loadTreeseedDevManifest>;
+    envRegistry: ReturnType<typeof collectTreeseedEnvironmentContext> | null;
+};
+export {};

package/dist/platform/config.js

@@ -0,0 +1,100 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { parseCapacityProviderLaunchManifest, resolveCapacityProviderLaunchPlan } from "../capacity-provider.js";
+import { discoverTreeseedApplications } from "../hosting/apps.js";
+import { discoverTreeseedPackageAdapters } from "../operations/services/package-adapters.js";
+import { collectTreeseedEnvironmentContext } from "../operations/services/config-runtime.js";
+import { loadTreeseedDeployConfigFromPath, resolveTreeseedDeployConfigPathFromRoot } from "./deploy-config.js";
+function loadOptionalYaml(filePath) {
+  if (!existsSync(filePath)) return null;
+  return parseYaml(readFileSync(filePath, "utf8"));
+}
+function loadCapacityLaunchFromPackageManifest(tenantRoot) {
+  const agentManifestPath = resolve(tenantRoot, "packages", "agent", "treeseed.package.yaml");
+  const manifest = loadOptionalYaml(agentManifestPath);
+  const capacityProvider = manifest?.capacityProvider;
+  if (!capacityProvider || typeof capacityProvider !== "object" || Array.isArray(capacityProvider)) return null;
+  const local = capacityProvider.local ?? {};
+  const roles = capacityProvider.roles ?? {};
+  const launchManifest = {
+    schemaVersion: 1,
+    provider: {
+      dataDir: local.dataDir ?? ".treeseed/local-capacity-provider/data",
+      environment: "local"
+    },
+    runtime: {
+      images: {
+        roles: {
+          manager: { image: roles.manager?.image ?? "treeseed/agent-manager", tag: roles.manager?.tag ?? "latest" },
+          runner: { image: roles.runner?.image ?? "treeseed/agent-runner", tag: roles.runner?.tag ?? "latest" }
+        }
+      }
+    }
+  };
+  const parsed = parseCapacityProviderLaunchManifest(launchManifest);
+  return {
+    path: agentManifestPath,
+    manifest: parsed,
+    plan: resolveCapacityProviderLaunchPlan(parsed)
+  };
+}
+function loadCapacityLaunchFromPath(configPath) {
+  if (!configPath) return null;
+  const absolutePath = resolve(configPath);
+  if (!existsSync(absolutePath)) {
+    throw new Error(`Capacity launch config was not found: ${absolutePath}`);
+  }
+  const parsed = parseCapacityProviderLaunchManifest(readFileSync(absolutePath, "utf8"));
+  return {
+    path: absolutePath,
+    manifest: parsed,
+    plan: resolveCapacityProviderLaunchPlan(parsed)
+  };
+}
+function loadTreeseedDevManifest(tenantRoot) {
+  return loadOptionalYaml(resolve(tenantRoot, "treeseed.dev.yaml")) ?? {
+    schemaVersion: 1,
+    dev: {
+      processes: {
+        "market-web": { package: "@treeseed/market", cwd: ".", surface: "web" },
+        api: { package: "@treeseed/api", cwd: "packages/api", surface: "api" },
+        "operations-runner": { package: "@treeseed/api", cwd: "packages/api", surface: "operations-runner" }
+      }
+    }
+  };
+}
+function discoverPlatformPackages(tenantRoot) {
+  if (!existsSync(resolve(tenantRoot, "package.json"))) {
+    return [];
+  }
+  return discoverTreeseedPackageAdapters(tenantRoot);
+}
+function loadTreeseedPlatformConfig(input) {
+  const tenantRoot = resolve(input.tenantRoot);
+  const deployConfigPath = resolveTreeseedDeployConfigPathFromRoot(tenantRoot);
+  const deployConfig = loadTreeseedDeployConfigFromPath(deployConfigPath);
+  const packages = discoverPlatformPackages(tenantRoot);
+  const applications = discoverTreeseedApplications(tenantRoot);
+  const capacityLaunch = loadCapacityLaunchFromPath(input.capacityConfigPath ?? input.env?.TREESEED_CAPACITY_CONFIG_PATH) ?? loadCapacityLaunchFromPackageManifest(tenantRoot);
+  const dev = loadTreeseedDevManifest(tenantRoot);
+  let envRegistry = null;
+  try {
+    envRegistry = collectTreeseedEnvironmentContext(tenantRoot, input.environment, { env: input.env });
+  } catch {
+    envRegistry = null;
+  }
+  return {
+    tenantRoot,
+    environment: input.environment,
+    deployConfig,
+    packages,
+    applications,
+    capacityLaunch,
+    dev,
+    envRegistry
+  };
+}
+export {
+  loadTreeseedPlatformConfig
+};

package/dist/platform/content-runtime-source.d.ts

@@ -0,0 +1,54 @@
+import type { SeedContentRuntimeSource, SeedProjectArchitecture } from '../seeds/types.js';
+export type TreeseedEffectiveContentSource = SeedContentRuntimeSource | 'missing';
+export type TreeseedContentRuntimeMode = 'local' | 'treedx' | 'r2' | 'missing';
+export type TreeseedContentRuntimeDiagnosticStatus = 'ready' | 'missing' | 'site_not_prepared' | 'unsupported_structure';
+export type TreeseedContentRuntimeDiagnostic = {
+    code: string;
+    status: TreeseedContentRuntimeDiagnosticStatus;
+    source: TreeseedContentRuntimeMode;
+    summary: string;
+    relativePath?: string;
+};
+export type TreeseedLocalContentRuntimeSummary = {
+    requestedLocalContentMode?: 'auto' | 'none' | 'preview' | 'edit' | string;
+    materializationStatus?: string | null;
+    effectiveLocalPath?: string | null;
+    localPathExists?: boolean;
+};
+export type TreeseedR2ContentRuntimeMetadata = {
+    manifestKey?: string | null;
+    overlayKey?: string | null;
+    revision?: string | null;
+};
+export type TreeseedTreeDxContentRuntimeMetadata = {
+    libraryId?: string | null;
+    repositoryId?: string | null;
+    snapshotId?: string | null;
+};
+export type TreeseedContentRuntimeResolution = {
+    contentRuntimeSource: SeedContentRuntimeSource;
+    effectiveContentSource: TreeseedEffectiveContentSource;
+    mode: TreeseedContentRuntimeMode;
+    ready: boolean;
+    manifestKey: string | null;
+    overlayKey: string | null;
+    revision: string | null;
+    snapshotId: string | null;
+    diagnostics: TreeseedContentRuntimeDiagnostic[];
+    localPath?: string | null;
+};
+export declare function resolveTreeseedContentRuntimeSource(input: {
+    architecture: Pick<SeedProjectArchitecture, 'contentRuntimeSource' | 'contentPublishTarget'>;
+    local?: TreeseedLocalContentRuntimeSummary | null;
+    r2?: TreeseedR2ContentRuntimeMetadata | null;
+    treeDx?: TreeseedTreeDxContentRuntimeMetadata | null;
+    includeLocalPath?: boolean;
+}): TreeseedContentRuntimeResolution;
+export declare function inspectTreeseedContentStructure(input: {
+    projectRoot: string;
+    architecture: Pick<SeedProjectArchitecture, 'rootPath' | 'sitePath' | 'contentPath'>;
+}): TreeseedContentRuntimeDiagnostic;
+export declare function contentRuntimeMetadataFromTarget(target: unknown): {
+    r2: TreeseedR2ContentRuntimeMetadata;
+    treeDx: TreeseedTreeDxContentRuntimeMetadata;
+};

package/dist/platform/content-runtime-source.js

@@ -0,0 +1,169 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function text(value, fallback = "") {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function cleanRelativePath(value, fallback = ".") {
+  const raw = text(value, fallback).replace(/\\/gu, "/").replace(/^\/+/u, "");
+  const parts = raw.split("/").filter((part) => part && part !== ".");
+  if (parts.some((part) => part === "..")) return fallback;
+  return parts.length > 0 ? parts.join("/") : ".";
+}
+function contentRuntimeMode(source) {
+  if (source === "local_directory") return "local";
+  if (source === "treedx_snapshot") return "treedx";
+  if (source === "r2_published_manifest" || source === "r2_preview_overlay") return "r2";
+  return "missing";
+}
+function localStatusReady(status) {
+  return status === "existing_path_ready" || status === "managed_clone_ready" || status === "submodule_ready";
+}
+function localContentRequested(architecture, local) {
+  const mode = local?.requestedLocalContentMode;
+  return architecture.contentRuntimeSource === "local_directory" || mode === "preview" || mode === "edit";
+}
+function defaultManifestKey(architecture) {
+  const target = architecture.contentPublishTarget;
+  return target?.kind === "cloudflare_r2" && typeof target.manifestPath === "string" && target.manifestPath.trim() ? target.manifestPath.trim() : null;
+}
+function resolveTreeseedContentRuntimeSource(input) {
+  const diagnostics = [];
+  const localReady = input.local?.localPathExists === true || localStatusReady(input.local?.materializationStatus);
+  const localSelected = localReady && localContentRequested(input.architecture, input.local);
+  const source = localSelected ? "local_directory" : input.architecture.contentRuntimeSource ?? "r2_published_manifest";
+  const mode = contentRuntimeMode(source);
+  const manifestKey = input.r2?.manifestKey ?? defaultManifestKey(input.architecture);
+  const overlayKey = source === "r2_preview_overlay" ? input.r2?.overlayKey ?? null : null;
+  const snapshotId = source === "treedx_snapshot" ? input.treeDx?.snapshotId ?? null : null;
+  const revision = source === "r2_published_manifest" || source === "r2_preview_overlay" ? input.r2?.revision ?? null : null;
+  if (source === "local_directory") {
+    diagnostics.push({
+      code: localReady ? "local_content_ready" : "local_content_missing",
+      status: localReady ? "ready" : "missing",
+      source: "local",
+      summary: localReady ? "Local content path is available for runtime preview." : "Local content path is not available."
+    });
+  } else if (source === "treedx_snapshot") {
+    const ready = Boolean(snapshotId || input.treeDx?.libraryId || input.treeDx?.repositoryId);
+    diagnostics.push({
+      code: ready ? "treedx_snapshot_ready" : "treedx_snapshot_missing",
+      status: ready ? "ready" : "missing",
+      source: "treedx",
+      summary: ready ? "TreeDX content snapshot metadata is available." : "TreeDX content snapshot metadata is missing."
+    });
+  } else if (source === "r2_published_manifest" || source === "r2_preview_overlay") {
+    const ready = Boolean(manifestKey);
+    diagnostics.push({
+      code: ready ? "r2_manifest_ready" : "r2_manifest_missing",
+      status: ready ? "ready" : "missing",
+      source: "r2",
+      summary: ready ? "R2 published content manifest metadata is available." : "R2 published content manifest metadata is missing."
+    });
+    if (source === "r2_preview_overlay" && !overlayKey) {
+      diagnostics.push({
+        code: "r2_preview_overlay_missing",
+        status: "missing",
+        source: "r2",
+        summary: "R2 preview overlay metadata is missing."
+      });
+    }
+  }
+  return {
+    contentRuntimeSource: input.architecture.contentRuntimeSource,
+    effectiveContentSource: source,
+    mode,
+    ready: diagnostics.every((entry) => entry.status === "ready"),
+    manifestKey,
+    overlayKey,
+    revision,
+    snapshotId,
+    diagnostics,
+    ...input.includeLocalPath ? { localPath: input.local?.effectiveLocalPath ?? null } : {}
+  };
+}
+function hasMarkdownFile(root) {
+  if (!existsSync(root)) return false;
+  const stats = statSync(root);
+  if (stats.isFile()) return root.endsWith(".md") || root.endsWith(".mdx");
+  if (!stats.isDirectory()) return false;
+  return readdirSync(root, { withFileTypes: true }).some((entry) => {
+    const fullPath = resolve(root, entry.name);
+    if (entry.isDirectory()) return hasMarkdownFile(fullPath);
+    return entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"));
+  });
+}
+function inspectTreeseedContentStructure(input) {
+  const rootPath = cleanRelativePath(input.architecture.rootPath);
+  const sitePath = cleanRelativePath(input.architecture.sitePath);
+  const contentPath = input.architecture.contentPath ? cleanRelativePath(input.architecture.contentPath) : null;
+  const siteRoot = resolve(input.projectRoot, rootPath === "." ? "" : rootPath, sitePath === "." ? "" : sitePath);
+  if (!existsSync(siteRoot)) {
+    return {
+      code: "site_not_prepared",
+      status: "site_not_prepared",
+      source: "local",
+      summary: "Site path is not prepared yet.",
+      relativePath: sitePath
+    };
+  }
+  const candidatePaths = [
+    contentPath,
+    sitePath === "." ? "src/content" : `${sitePath}/src/content`,
+    sitePath,
+    "content"
+  ].filter((entry) => Boolean(entry));
+  for (const candidate of [...new Set(candidatePaths)]) {
+    const absolute = resolve(input.projectRoot, rootPath === "." ? "" : rootPath, candidate === "." ? "" : candidate);
+    if (!existsSync(absolute)) continue;
+    if (hasMarkdownFile(absolute)) {
+      return {
+        code: "content_structure_ready",
+        status: "ready",
+        source: "local",
+        summary: "Content structure contains Markdown or MDX files.",
+        relativePath: candidate
+      };
+    }
+    return {
+      code: "unsupported_content_structure",
+      status: "unsupported_structure",
+      source: "local",
+      summary: "Content path exists but does not contain Markdown or MDX files.",
+      relativePath: candidate
+    };
+  }
+  return {
+    code: "content_structure_missing",
+    status: "missing",
+    source: "local",
+    summary: "No supported local content path was found.",
+    relativePath: contentPath ?? "src/content"
+  };
+}
+function contentRuntimeMetadataFromTarget(target) {
+  const record = isRecord(target) ? target : {};
+  const contentRuntime = isRecord(record.contentRuntime) ? record.contentRuntime : {};
+  const contentPublish = isRecord(record.contentPublish) ? record.contentPublish : {};
+  const r2 = isRecord(contentRuntime.r2) ? contentRuntime.r2 : isRecord(contentPublish.r2) ? contentPublish.r2 : {};
+  const treeDx = isRecord(contentRuntime.treeDx) ? contentRuntime.treeDx : contentPublish.provider === "treedx" ? contentPublish : {};
+  return {
+    r2: {
+      manifestKey: text(contentRuntime.manifestKey) || text(r2.manifestKey) || text(r2.manifestPath) || null,
+      overlayKey: text(contentRuntime.overlayKey) || text(r2.overlayKey) || null,
+      revision: text(contentRuntime.revision) || text(r2.revision) || null
+    },
+    treeDx: {
+      libraryId: text(treeDx.libraryId) || null,
+      repositoryId: text(treeDx.repositoryId) || null,
+      snapshotId: text(treeDx.snapshotId) || text(contentPublish.snapshotId) || null
+    }
+  };
+}
+export {
+  contentRuntimeMetadataFromTarget,
+  inspectTreeseedContentStructure,
+  resolveTreeseedContentRuntimeSource
+};

package/dist/platform/contracts.d.ts

@@ -1,4 +1,4 @@
-import type { CapacityProviderRegistrationRequest } from '../capacity-provider.ts';
+import type { CapacityProviderRegistrationRequest } from '../capacity-provider.js';
 export type TreeseedFeatureName = 'docs' | 'books' | 'notes' | 'questions' | 'objectives' | 'proposals' | 'decisions' | 'agents' | 'forms';
 export type TreeseedContentCollection = 'pages' | 'notes' | 'questions' | 'objectives' | 'proposals' | 'decisions' | 'people' | 'agents' | 'books' | 'docs' | 'templates' | 'knowledge_packs' | 'workdays';
 export interface TreeseedFeatureModules {
@@ -177,9 +177,10 @@ export interface TreeseedCloudflarePagesConfig {
     previewProjectName?: string;
     productionBranch?: string;
     stagingBranch?: string;
+    buildCommand?: string;
     buildOutputDir?: string;
 }
-export type TreeseedHostingKind = 'market_control_plane' | 'hosted_project' | 'self_hosted_project';
+export type TreeseedHostingKind = 'treeseed_control_plane' | 'hosted_project' | 'self_hosted_project';
 export type TreeseedHostingRegistration = 'optional' | 'none';
 export type TreeseedHubMode = 'treeseed_hosted' | 'customer_hosted';
 export type TreeseedRuntimeMode = 'none' | 'byo_attached' | 'treeseed_managed';
@@ -225,6 +226,11 @@ export interface TreeseedManagedServiceRailwayConfig {
     serviceId?: string;
     serviceName?: string;
     rootDir?: string;
+    imageRef?: string;
+    sourceMode?: 'git' | 'image';
+    sourceRepo?: string;
+    sourceBranch?: string;
+    sourceRootDirectory?: string;
     buildCommand?: string;
     startCommand?: string;
     healthcheckPath?: string;
@@ -232,6 +238,15 @@ export interface TreeseedManagedServiceRailwayConfig {
     healthcheckIntervalSeconds?: number;
     restartPolicy?: string;
     runtimeMode?: string;
+    resourceType?: string;
+    environmentVariable?: string;
+    serviceTargets?: string[];
+    volumeMountPath?: string;
+    runnerPool?: {
+        bootstrapCount?: number;
+        maxRunners?: number;
+        volumeMountPath?: string;
+    };
     schedule?: string | string[];
 }
 export interface TreeseedManagedServiceConfig {
@@ -248,6 +263,14 @@ export interface TreeseedManagedServicesConfig {
     api?: TreeseedManagedServiceConfig;
     [key: string]: TreeseedManagedServiceConfig | undefined;
 }
+export interface TreeseedPublicTreeDxFederationConfig {
+    railway?: {
+        nodePool?: {
+            bootstrapCount?: number;
+            maxNodes?: number;
+        };
+    };
+}
 export interface TreeseedPlatformSurfacesConfig {
     web?: TreeseedPlatformSurfaceConfig;
     api?: TreeseedPlatformSurfaceConfig;
@@ -278,6 +301,14 @@ export interface TreeseedExportConfig {
     ignore?: string[];
     bundledPaths?: string[];
 }
+export interface TreeseedApiConnectionConfig {
+    proxyPrefix?: string;
+    localBaseUrl?: string;
+    environments?: Partial<Record<'local' | 'staging' | 'prod', {
+        baseUrl?: string;
+        domain?: string;
+    }>>;
+}
 export interface TreeseedDeployConfig {
     name: string;
     slug: string;
@@ -302,6 +333,11 @@ export interface TreeseedDeployConfig {
     providers: TreeseedProviderSelections;
     surfaces?: TreeseedPlatformSurfacesConfig;
     services?: TreeseedManagedServicesConfig;
+    publicTreeDxFederation?: TreeseedPublicTreeDxFederationConfig;
+    connections?: {
+        api?: TreeseedApiConnectionConfig;
+        [key: string]: unknown;
+    };
     processing?: TreeseedProcessingConfig;
     capacityProviders?: Record<string, CapacityProviderRegistrationRequest>;
     smtp?: {

package/dist/platform/deploy-config.d.ts

@@ -1,4 +1,4 @@
-import type { TreeseedDeployConfig, TreeseedWebCachePolicyConfig } from './contracts.ts';
+import type { TreeseedDeployConfig, TreeseedWebCachePolicyConfig } from './contracts.js';
 export declare function resolveTreeseedDeployConfigPath(configPath?: string): string;
 export declare function resolveTreeseedDeployConfigPathFromRoot(tenantRoot: string, configPath?: string): string;
 export declare function deriveCloudflareWorkerName(config: TreeseedDeployConfig): string;