@treeseed/sdk 0.8.7 → 0.8.9

package/dist/operations/services/{knowledge-coop-packaging.js → market-packaging.js}

@@ -139,13 +139,13 @@ function buildManifest(projectRoot, input) {
     }
   };
 }
-function resolveKnowledgeCoopPackageOutputRoot(projectRoot, kind, slug) {
+function resolveMarketPackageOutputRoot(projectRoot, kind, slug) {
   return resolve(projectRoot, ".treeseed", "packages", kind, `${slug}-${nowStamp()}`);
 }
-function buildKnowledgeCoopTemplatePackage(projectRoot, input = {}) {
+function buildTemplateMarketPackage(projectRoot, input = {}) {
   const projectSlug = slugify(input.projectSlug ?? basename(projectRoot), "project");
   const packageId = slugify(input.id ?? `${projectSlug}-template`, "template");
-  const outputRoot = resolve(input.outputRoot ?? resolveKnowledgeCoopPackageOutputRoot(projectRoot, "template", packageId));
+  const outputRoot = resolve(input.outputRoot ?? resolveMarketPackageOutputRoot(projectRoot, "template", packageId));
   const payloadRoot = resolve(outputRoot, "payload");
   ensureDir(payloadRoot);
   const files = copySelectedPaths(projectRoot, payloadRoot, defaultTemplatePaths(projectRoot), TEMPLATE_IGNORES);
@@ -168,10 +168,10 @@ function buildKnowledgeCoopTemplatePackage(projectRoot, input = {}) {
     manifest
   };
 }
-function buildKnowledgeCoopKnowledgePackPackage(projectRoot, input = {}) {
+function buildKnowledgePackMarketPackage(projectRoot, input = {}) {
   const projectSlug = slugify(input.projectSlug ?? basename(projectRoot), "project");
   const packageId = slugify(input.id ?? `${projectSlug}-knowledge-pack`, "knowledge-pack");
-  const outputRoot = resolve(input.outputRoot ?? resolveKnowledgeCoopPackageOutputRoot(projectRoot, "knowledge_pack", packageId));
+  const outputRoot = resolve(input.outputRoot ?? resolveMarketPackageOutputRoot(projectRoot, "knowledge_pack", packageId));
   const payloadRoot = resolve(outputRoot, "payload");
   ensureDir(payloadRoot);
   const includePaths = (input.includePaths ?? KNOWLEDGE_PACK_DEFAULT_PATHS).filter((relativePath) => existsSync(resolve(projectRoot, relativePath)));
@@ -195,7 +195,7 @@ function buildKnowledgeCoopKnowledgePackPackage(projectRoot, input = {}) {
     manifest
   };
 }
-function importKnowledgeCoopKnowledgePack(targetRoot, sourcePath) {
+function importKnowledgePack(targetRoot, sourcePath) {
   const resolvedSource = resolve(sourcePath);
   const manifestPath = statSync(resolvedSource).isDirectory() ? resolve(resolvedSource, "manifest.json") : resolvedSource;
   const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
@@ -226,9 +226,9 @@ function relativePackageFiles(outputRoot) {
   return listFiles(outputRoot).map((entry) => relative(outputRoot, resolve(outputRoot, entry)) || basename(entry));
 }
 export {
-  buildKnowledgeCoopKnowledgePackPackage,
-  buildKnowledgeCoopTemplatePackage,
-  importKnowledgeCoopKnowledgePack,
+  buildKnowledgePackMarketPackage,
+  buildTemplateMarketPackage,
+  importKnowledgePack,
   relativePackageFiles,
-  resolveKnowledgeCoopPackageOutputRoot
+  resolveMarketPackageOutputRoot
 };

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

@@ -214,6 +214,22 @@ export declare function deployProjectPlatform(options: ProjectPlatformActionOpti
             readiness: any;
         };
     };
+    hostingRepair: {
+        ok: boolean;
+        phase: "repaired" | "already_ready";
+        environment: import("./hosting-audit.ts").TreeseedHostingAuditResolvedEnvironment;
+        repairMode: boolean;
+        repaired: boolean;
+        repairedChecks: number;
+        failedChecks: number;
+        blockers: string[];
+        warnings: string[];
+        checkedAt: string;
+    } | {
+        ok: boolean;
+        skipped: boolean;
+        reason: string;
+    };
     serviceResults: ({
         service: any;
         status: string;
@@ -641,6 +657,22 @@ export declare function runProjectPlatformAction(action: ProjectPlatformAction,
             readiness: any;
         };
     };
+    hostingRepair: {
+        ok: boolean;
+        phase: "repaired" | "already_ready";
+        environment: import("./hosting-audit.ts").TreeseedHostingAuditResolvedEnvironment;
+        repairMode: boolean;
+        repaired: boolean;
+        repairedChecks: number;
+        failedChecks: number;
+        blockers: string[];
+        warnings: string[];
+        checkedAt: string;
+    } | {
+        ok: boolean;
+        skipped: boolean;
+        reason: string;
+    };
     serviceResults: ({
         service: any;
         status: string;

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

@@ -15,6 +15,7 @@ import { createPublishedContentPipeline } from "../../platform/published-content
 import { collectTreeseedReconcileStatus, reconcileTreeseedTarget, resolveTreeseedBootstrapSelection } from "../../reconcile/index.js";
 import { loadTreeseedManifest } from "../../platform/tenant-config.js";
 import { applyTreeseedEnvironmentToProcess, assertTreeseedCommandEnvironment } from "./config-runtime.js";
+import { runTreeseedHostingAudit } from "./hosting-audit.js";
 import {
   assertDeploymentInitialized,
   createPersistentDeployTarget,
@@ -366,6 +367,92 @@ function statSafe(filePath) {
 async function reportDeployment(reporter, input) {
   await reporter.reportDeployment(input);
 }
+function summarizePostDeployHostingAudit(report, phase) {
+  const failedChecks = report.checks.filter((check) => check.status === "failed").length;
+  const repairedChecks = report.checks.filter((check) => check.status === "repaired").length;
+  return {
+    ok: report.ok,
+    phase,
+    environment: report.environment,
+    repairMode: report.repairMode,
+    repaired: report.repaired || repairedChecks > 0,
+    repairedChecks,
+    failedChecks,
+    blockers: report.blockers,
+    warnings: report.warnings,
+    checkedAt: report.checkedAt
+  };
+}
+function hostingAuditHostKindsForSystems(systems) {
+  const hostKinds = /* @__PURE__ */ new Set();
+  for (const system of systems) {
+    if (system === "github") {
+      hostKinds.add("repository");
+    } else if (system === "data" || system === "web") {
+      hostKinds.add("web");
+    } else if (system === "api" || system === "agents") {
+      hostKinds.add("processing");
+    }
+  }
+  return [...hostKinds];
+}
+async function repairHostingAfterSuccessfulDeploy(options, systems) {
+  if (options.scope === "local") {
+    return {
+      ok: true,
+      skipped: true,
+      reason: "local_environment"
+    };
+  }
+  if (options.dryRun) {
+    return {
+      ok: true,
+      skipped: true,
+      reason: "dry_run"
+    };
+  }
+  if (process.env.TREESEED_POST_DEPLOY_HOSTING_REPAIR === "off") {
+    return {
+      ok: true,
+      skipped: true,
+      reason: "disabled"
+    };
+  }
+  const hostKinds = hostingAuditHostKindsForSystems(systems);
+  if (hostKinds.length === 0) {
+    return {
+      ok: true,
+      skipped: true,
+      reason: "no_host_kinds"
+    };
+  }
+  const environment = options.scope === "prod" ? "prod" : "staging";
+  const env = { ...process.env, ...options.env ?? {} };
+  const audit = await runTreeseedHostingAudit({
+    tenantRoot: options.tenantRoot,
+    environment,
+    repair: false,
+    env,
+    hostKinds: [...hostKinds]
+  });
+  if (audit.ok) {
+    return summarizePostDeployHostingAudit(audit, "already_ready");
+  }
+  options.write?.(`[${environment}][hosting][repair] Hosting readiness needs repair after deploy for ${hostKinds.join(", ")}.`);
+  const repaired = await runTreeseedHostingAudit({
+    tenantRoot: options.tenantRoot,
+    environment,
+    repair: true,
+    env,
+    hostKinds: [...hostKinds],
+    write: (line) => options.write?.(`[${environment}][hosting][repair] ${line}`)
+  });
+  const summary = summarizePostDeployHostingAudit(repaired, "repaired");
+  if (!summary.ok) {
+    throw new Error(`Post-deploy hosting repair failed: ${summary.blockers[0] ?? `${summary.failedChecks} failed hosting readiness checks remain.`}`);
+  }
+  return summary;
+}
 function resolveReporter(tenantRoot, explicit) {
   if (explicit) {
     return explicit;
@@ -1191,6 +1278,7 @@ async function deployProjectPlatform(options) {
     });
   }
   const monitor = await monitorProjectPlatform({ ...options, reporter, bootstrapSystems });
+  const hostingRepair = await repairHostingAfterSuccessfulDeploy(options, bootstrapSystems);
   await reportDeployment(reporter, {
     environment: options.scope,
     deploymentKind: "code",
@@ -1201,7 +1289,8 @@ async function deployProjectPlatform(options) {
     metadata: {
       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
+      monitor,
+      hostingRepair
     },
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
@@ -1209,6 +1298,7 @@ async function deployProjectPlatform(options) {
     ok: true,
     scope: options.scope,
     monitor,
+    hostingRepair,
     serviceResults
   };
 }

package/dist/platform/contracts.d.ts

@@ -64,38 +64,60 @@ export interface TreeseedBookDefinition {
     tags?: string[];
     id?: string;
 }
+export type TreeseedThemeMode = 'light' | 'dark' | 'system';
+export type TreeseedColorSchemeId = 'fern' | 'lichen' | 'cedar' | 'tidepool' | (string & {});
+export interface TreeseedSemanticColorTokens {
+    canvas: string;
+    canvasSubtle: string;
+    surface: string;
+    surfaceMuted: string;
+    surfaceRaised: string;
+    surfaceOverlay: string;
+    text: string;
+    textMuted: string;
+    textSubtle: string;
+    textInverse: string;
+    link: string;
+    linkHover: string;
+    border: string;
+    borderMuted: string;
+    borderStrong: string;
+    focus: string;
+    accent: string;
+    accentHover: string;
+    accentStrong: string;
+    accentSoft: string;
+    accentText: string;
+    info: string;
+    infoSoft: string;
+    infoText: string;
+    infoBorder: string;
+    success: string;
+    successSoft: string;
+    successText: string;
+    successBorder: string;
+    warning: string;
+    warningSoft: string;
+    warningText: string;
+    warningBorder: string;
+    danger: string;
+    dangerSoft: string;
+    dangerText: string;
+    dangerBorder: string;
+    shadow: string;
+    grid: string;
+}
+export interface TreeseedSchemeTokens {
+    light: TreeseedSemanticColorTokens;
+    dark: TreeseedSemanticColorTokens;
+}
 export interface TreeseedThemeConfig {
-    surfaces?: {
-        background?: string;
-        backgroundElevated?: string;
-        backgroundSoft?: string;
-        panel?: string;
-        panelStrong?: string;
-    };
-    text?: {
-        body?: string;
-        muted?: string;
-        soft?: string;
-    };
-    border?: {
-        base?: string;
-        strong?: string;
-        grid?: string;
-    };
-    accent?: {
-        base?: string;
-        strong?: string;
-        soft?: string;
-    };
-    info?: {
-        base?: string;
-        strong?: string;
-        soft?: string;
-    };
-    warm?: {
-        base?: string;
-        strong?: string;
-    };
+    defaultScheme?: TreeseedColorSchemeId;
+    defaultMode?: TreeseedThemeMode;
+    schemes?: Record<TreeseedColorSchemeId, Partial<{
+        light: Partial<TreeseedSemanticColorTokens>;
+        dark: Partial<TreeseedSemanticColorTokens>;
+    }>>;
 }
 export interface TreeseedPluginReference {
     package: string;

package/dist/platform/utils/site-config-schema.js

@@ -51,6 +51,19 @@ function optionalRecord(value, path) {
 	return expectRecord(value, path);
 }
 
+function optionalEnum(value, path, allowed) {
+	if (value === undefined || value === null || value === '') {
+		return undefined;
+	}
+
+	const parsedValue = expectString(value, path);
+	if (!allowed.includes(parsedValue)) {
+		throw new Error(`Expected ${path} to be one of: ${allowed.join(', ')}.`);
+	}
+
+	return parsedValue;
+}
+
 function stringArray(value, path) {
 	if (value === undefined || value === null) {
 		return [];
@@ -103,66 +116,121 @@ function parseContactRouting(value, path) {
 	);
 }
 
+const BUILT_IN_THEME_SCHEMES = new Set(['fern', 'lichen', 'cedar', 'tidepool']);
+const THEME_TOKEN_NAMES = new Set([
+	'canvas',
+	'canvasSubtle',
+	'surface',
+	'surfaceMuted',
+	'surfaceRaised',
+	'surfaceOverlay',
+	'text',
+	'textMuted',
+	'textSubtle',
+	'textInverse',
+	'link',
+	'linkHover',
+	'border',
+	'borderMuted',
+	'borderStrong',
+	'focus',
+	'accent',
+	'accentHover',
+	'accentStrong',
+	'accentSoft',
+	'accentText',
+	'info',
+	'infoSoft',
+	'infoText',
+	'infoBorder',
+	'success',
+	'successSoft',
+	'successText',
+	'successBorder',
+	'warning',
+	'warningSoft',
+	'warningText',
+	'warningBorder',
+	'danger',
+	'dangerSoft',
+	'dangerText',
+	'dangerBorder',
+	'shadow',
+	'grid',
+]);
+
+function parseThemeSchemeId(value, path) {
+	const schemeId = expectString(value, path);
+	if (!/^[a-z][a-z0-9-]*$/u.test(schemeId)) {
+		throw new Error(`Expected ${path} to be a stable lowercase slug.`);
+	}
+	return schemeId;
+}
+
+function parseThemeTokenOverrides(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return undefined;
+	}
+
+	return Object.fromEntries(
+		Object.entries(record).map(([tokenName, tokenValue]) => {
+			if (!THEME_TOKEN_NAMES.has(tokenName)) {
+				throw new Error(`Unknown theme token ${path}.${tokenName}.`);
+			}
+			return [tokenName, expectString(tokenValue, `${path}.${tokenName}`)];
+		}),
+	);
+}
+
+function parseThemeScheme(value, path) {
+	const scheme = expectRecord(value, path);
+	const allowedKeys = new Set(['light', 'dark']);
+	for (const key of Object.keys(scheme)) {
+		if (!allowedKeys.has(key)) {
+			throw new Error(`Unknown theme scheme key ${path}.${key}.`);
+		}
+	}
+	return {
+		light: parseThemeTokenOverrides(scheme.light, `${path}.light`),
+		dark: parseThemeTokenOverrides(scheme.dark, `${path}.dark`),
+	};
+}
+
 function parseTheme(value, path) {
 	const theme = optionalRecord(value, path);
 	if (!theme) {
 		return undefined;
 	}
 
-	const surfaces = optionalRecord(theme.surfaces, `${path}.surfaces`);
-	const text = optionalRecord(theme.text, `${path}.text`);
-	const border = optionalRecord(theme.border, `${path}.border`);
-	const accent = optionalRecord(theme.accent, `${path}.accent`);
-	const info = optionalRecord(theme.info, `${path}.info`);
-	const warm = optionalRecord(theme.warm, `${path}.warm`);
+	const allowedKeys = new Set(['defaultScheme', 'defaultMode', 'schemes']);
+	for (const key of Object.keys(theme)) {
+		if (!allowedKeys.has(key)) {
+			throw new Error(`Unknown theme key ${path}.${key}.`);
+		}
+	}
+
+	const schemes = optionalRecord(theme.schemes, `${path}.schemes`);
+	const parsedSchemes = schemes
+		? Object.fromEntries(
+			Object.entries(schemes).map(([schemeId, scheme]) => [
+				parseThemeSchemeId(schemeId, `${path}.schemes.${schemeId}`),
+				parseThemeScheme(scheme, `${path}.schemes.${schemeId}`),
+			]),
+		)
+		: undefined;
+	const defaultScheme = optionalString(theme.defaultScheme, `${path}.defaultScheme`);
+	if (defaultScheme) {
+		parseThemeSchemeId(defaultScheme, `${path}.defaultScheme`);
+		if (!BUILT_IN_THEME_SCHEMES.has(defaultScheme) && !(parsedSchemes && defaultScheme in parsedSchemes)) {
+			throw new Error(`Expected ${path}.defaultScheme to reference a built-in or configured scheme.`);
+		}
+	}
 
 	return {
-		surfaces: surfaces
-			? {
-				background: optionalString(surfaces.background, `${path}.surfaces.background`),
-				backgroundElevated: optionalString(
-					surfaces.backgroundElevated,
-					`${path}.surfaces.backgroundElevated`,
-				),
-				backgroundSoft: optionalString(surfaces.backgroundSoft, `${path}.surfaces.backgroundSoft`),
-				panel: optionalString(surfaces.panel, `${path}.surfaces.panel`),
-				panelStrong: optionalString(surfaces.panelStrong, `${path}.surfaces.panelStrong`),
-			}
-			: undefined,
-		text: text
-			? {
-				body: optionalString(text.body, `${path}.text.body`),
-				muted: optionalString(text.muted, `${path}.text.muted`),
-				soft: optionalString(text.soft, `${path}.text.soft`),
-			}
-			: undefined,
-		border: border
-			? {
-				base: optionalString(border.base, `${path}.border.base`),
-				strong: optionalString(border.strong, `${path}.border.strong`),
-				grid: optionalString(border.grid, `${path}.border.grid`),
-			}
-			: undefined,
-		accent: accent
-			? {
-				base: optionalString(accent.base, `${path}.accent.base`),
-				strong: optionalString(accent.strong, `${path}.accent.strong`),
-				soft: optionalString(accent.soft, `${path}.accent.soft`),
-			}
-			: undefined,
-		info: info
-			? {
-				base: optionalString(info.base, `${path}.info.base`),
-				strong: optionalString(info.strong, `${path}.info.strong`),
-				soft: optionalString(info.soft, `${path}.info.soft`),
-			}
-			: undefined,
-		warm: warm
-			? {
-				base: optionalString(warm.base, `${path}.warm.base`),
-				strong: optionalString(warm.strong, `${path}.warm.strong`),
-			}
-			: undefined,
+		defaultScheme,
+		defaultMode: optionalEnum(theme.defaultMode, `${path}.defaultMode`, ['light', 'dark', 'system']),
+		schemes: parsedSchemes,
 	};
 }
 

package/dist/{knowledge-coop.d.ts → project-workflow.d.ts}

@@ -1,16 +1,16 @@
 import type { ProjectConnection, RemoteJobStatus } from './sdk-types.ts';
-export declare const KNOWLEDGE_COOP_TEAM_CAPABILITIES: readonly ["launch_projects", "edit_direct", "manage_workstreams", "stage_releases", "publish_releases", "publish_market_listings", "manage_products", "manage_billing", "approve_remote_execution"];
-export declare const KNOWLEDGE_COOP_JOB_STATUSES: readonly ["queued", "running", "waiting_for_approval", "failed", "completed", "rolled_back", "cancelled"];
-export declare const KNOWLEDGE_COOP_WORKSTREAM_STATES: readonly ["drafting", "active_local", "verifying", "saved_remote", "in_staging", "archived"];
-export declare const KNOWLEDGE_COOP_RELEASE_STATES: readonly ["drafting", "waiting_on_verification", "ready_to_publish", "published", "rolled_back"];
-export declare const KNOWLEDGE_COOP_SHARE_PACKAGE_STATES: readonly ["draft", "packaged", "ready_to_publish", "published", "archived", "failed"];
-export declare const KNOWLEDGE_COOP_AGENT_MESSAGE_KINDS: readonly ["informational", "warning", "action_requested", "release_readiness"];
-export type TeamCapability = (typeof KNOWLEDGE_COOP_TEAM_CAPABILITIES)[number];
-export type KnowledgeCoopJobStatus = (typeof KNOWLEDGE_COOP_JOB_STATUSES)[number];
-export type WorkstreamState = (typeof KNOWLEDGE_COOP_WORKSTREAM_STATES)[number];
-export type ReleaseState = (typeof KNOWLEDGE_COOP_RELEASE_STATES)[number];
-export type SharePackageState = (typeof KNOWLEDGE_COOP_SHARE_PACKAGE_STATES)[number];
-export type AgentMessageKind = (typeof KNOWLEDGE_COOP_AGENT_MESSAGE_KINDS)[number];
+export declare const PROJECT_TEAM_CAPABILITIES: readonly ["launch_projects", "edit_direct", "manage_workstreams", "stage_releases", "publish_releases", "publish_market_listings", "manage_products", "manage_billing", "approve_remote_execution"];
+export declare const PROJECT_JOB_STATUSES: readonly ["queued", "running", "waiting_for_approval", "failed", "completed", "rolled_back", "cancelled"];
+export declare const WORKSTREAM_STATES: readonly ["drafting", "active_local", "verifying", "saved_remote", "in_staging", "archived"];
+export declare const RELEASE_STATES: readonly ["drafting", "waiting_on_verification", "ready_to_publish", "published", "rolled_back"];
+export declare const SHARE_PACKAGE_STATES: readonly ["draft", "packaged", "ready_to_publish", "published", "archived", "failed"];
+export declare const AGENT_MESSAGE_KINDS: readonly ["informational", "warning", "action_requested", "release_readiness"];
+export type TeamCapability = (typeof PROJECT_TEAM_CAPABILITIES)[number];
+export type ProjectJobStatus = (typeof PROJECT_JOB_STATUSES)[number];
+export type WorkstreamState = (typeof WORKSTREAM_STATES)[number];
+export type ReleaseState = (typeof RELEASE_STATES)[number];
+export type SharePackageState = (typeof SHARE_PACKAGE_STATES)[number];
+export type AgentMessageKind = (typeof AGENT_MESSAGE_KINDS)[number];
 export interface LinkedProjectRecordRef {
     model: 'objective' | 'question' | 'note' | 'proposal' | 'decision';
     id: string;
@@ -185,7 +185,7 @@ export interface InboxItem {
     teamId: string;
     projectId: string | null;
     kind: string;
-    state: KnowledgeCoopJobStatus | string;
+    state: ProjectJobStatus | string;
     title: string;
     summary: string | null;
     href: string | null;
@@ -226,5 +226,5 @@ export interface LaunchProjectResult {
     launchJobId: string | null;
     overview: ProjectOverviewSummary | null;
 }
-export declare function normalizeKnowledgeCoopJobStatus(status: string | null | undefined): KnowledgeCoopJobStatus;
-export declare function normalizeRemoteJobStatus(status: RemoteJobStatus): KnowledgeCoopJobStatus;
+export declare function normalizeProjectJobStatus(status: string | null | undefined): ProjectJobStatus;
+export declare function normalizeRemoteJobStatus(status: RemoteJobStatus): ProjectJobStatus;

package/dist/{knowledge-coop.js → project-workflow.js}

@@ -1,4 +1,4 @@
-const KNOWLEDGE_COOP_TEAM_CAPABILITIES = [
+const PROJECT_TEAM_CAPABILITIES = [
   "launch_projects",
   "edit_direct",
   "manage_workstreams",
@@ -9,7 +9,7 @@ const KNOWLEDGE_COOP_TEAM_CAPABILITIES = [
   "manage_billing",
   "approve_remote_execution"
 ];
-const KNOWLEDGE_COOP_JOB_STATUSES = [
+const PROJECT_JOB_STATUSES = [
   "queued",
   "running",
   "waiting_for_approval",
@@ -18,7 +18,7 @@ const KNOWLEDGE_COOP_JOB_STATUSES = [
   "rolled_back",
   "cancelled"
 ];
-const KNOWLEDGE_COOP_WORKSTREAM_STATES = [
+const WORKSTREAM_STATES = [
   "drafting",
   "active_local",
   "verifying",
@@ -26,14 +26,14 @@ const KNOWLEDGE_COOP_WORKSTREAM_STATES = [
   "in_staging",
   "archived"
 ];
-const KNOWLEDGE_COOP_RELEASE_STATES = [
+const RELEASE_STATES = [
   "drafting",
   "waiting_on_verification",
   "ready_to_publish",
   "published",
   "rolled_back"
 ];
-const KNOWLEDGE_COOP_SHARE_PACKAGE_STATES = [
+const SHARE_PACKAGE_STATES = [
   "draft",
   "packaged",
   "ready_to_publish",
@@ -41,13 +41,13 @@ const KNOWLEDGE_COOP_SHARE_PACKAGE_STATES = [
   "archived",
   "failed"
 ];
-const KNOWLEDGE_COOP_AGENT_MESSAGE_KINDS = [
+const AGENT_MESSAGE_KINDS = [
   "informational",
   "warning",
   "action_requested",
   "release_readiness"
 ];
-function normalizeKnowledgeCoopJobStatus(status) {
+function normalizeProjectJobStatus(status) {
   switch (String(status ?? "").trim()) {
     case "running":
       return "running";
@@ -68,15 +68,15 @@ function normalizeKnowledgeCoopJobStatus(status) {
   }
 }
 function normalizeRemoteJobStatus(status) {
-  return normalizeKnowledgeCoopJobStatus(status);
+  return normalizeProjectJobStatus(status);
 }
 export {
-  KNOWLEDGE_COOP_AGENT_MESSAGE_KINDS,
-  KNOWLEDGE_COOP_JOB_STATUSES,
-  KNOWLEDGE_COOP_RELEASE_STATES,
-  KNOWLEDGE_COOP_SHARE_PACKAGE_STATES,
-  KNOWLEDGE_COOP_TEAM_CAPABILITIES,
-  KNOWLEDGE_COOP_WORKSTREAM_STATES,
-  normalizeKnowledgeCoopJobStatus,
+  AGENT_MESSAGE_KINDS,
+  PROJECT_JOB_STATUSES,
+  PROJECT_TEAM_CAPABILITIES,
+  RELEASE_STATES,
+  SHARE_PACKAGE_STATES,
+  WORKSTREAM_STATES,
+  normalizeProjectJobStatus,
   normalizeRemoteJobStatus
 };