@treeseed/sdk 0.8.8 → 0.8.9

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
 };

package/dist/scripts/tenant-d1-migrate-local.js

@@ -12,3 +12,4 @@ runLocalD1Migrations({
     wranglerConfig,
     migrationsRoot,
 });
+process.exit(0);

package/dist/sdk.d.ts

@@ -2,7 +2,7 @@ import type { AgentPermissionConfig, AgentRuntimeSpec } from './types/agents.ts'
 import { ContentStore } from './content-store.ts';
 import { type AgentDatabase } from './d1-store.ts';
 import { type LoadedTreeseedPluginEntry } from './platform/plugins.ts';
-import type { ReleaseDetail, ReleaseSummary, SharePackageStatus, WorkstreamDetail, WorkstreamEvent, WorkstreamSummary } from './knowledge-coop.ts';
+import type { ReleaseDetail, ReleaseSummary, SharePackageStatus, WorkstreamDetail, WorkstreamEvent, WorkstreamSummary } from './project-workflow.ts';
 import type { SdkAckMessageRequest, SdkClaimMessageRequest, SdkClaimTaskRequest, SdkCloseWorkDayRequest, SdkCompleteTaskRequest, SdkCreateReportRequest, SdkCreateMessageRequest, SdkCreatePrioritySnapshotRequest, SdkCreateTaskRequest, SdkCursorRequest, SdkFailTaskRequest, SdkFollowRequest, SdkGetRequest, SdkGetCursorRequest, SdkJsonEnvelope, SdkLeaseReleaseRequest, SdkManagerContextPayload, SdkMutationRequest, SdkGraphQueryOptions, SdkGraphQueryRequest, SdkGraphRefreshRequest, SdkGraphSearchOptions, SdkContextPackRequest, SdkGraphDslParseResult, SdkPickRequest, SdkPriorityOverrideRequest, SdkClaimWorkdayManagerLeaseRequest, SdkCreateWorkdayRequest, SdkRecordRepositoryClaimRequest, SdkRecordRunnerScaleDecisionRequest, SdkRecordWorkerRunnerRequest, SdkRecordRunRequest, SdkRecordScaleDecisionRequest, SdkRecordTaskCreditsRequest, SdkReleaseWorkdayManagerLeaseRequest, SdkSearchRequest, SdkStartWorkDayRequest, SdkTaskProgressRequest, SdkTaskSearchRequest, SdkUpsertWorkPolicyRequest, SdkUpdateWorkDayGraphRequest, SdkUpdateRequest, SdkModelDefinition, SdkModelRegistry, SdkGraphRankingProvider, SdkDispatchConfig, SdkDispatchRequest, SdkDispatchResult, PrioritySnapshot, RepositoryClaim, RunnerScaleDecision, ScaleDecision, TaskCreditLedgerEntry, WorkdayManagerLease, WorkdayPolicy, WorkdayRequest, WorkerRunner } from './sdk-types.ts';
 export interface AgentSdkOptions {
     repoRoot?: string;

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

@@ -1,6 +1,6 @@
-import type { ReleaseDetail, ReleaseSummary, SharePackageStatus, WorkstreamDetail, WorkstreamEvent, WorkstreamState, WorkstreamSummary, LinkedProjectRecordRef } from '../knowledge-coop.ts';
+import type { ReleaseDetail, ReleaseSummary, SharePackageStatus, WorkstreamDetail, WorkstreamEvent, WorkstreamState, WorkstreamSummary, LinkedProjectRecordRef } from '../project-workflow.ts';
 import { SqliteStoreBase } from './helpers.ts';
-export declare class MemoryKnowledgeCoopStore {
+export declare class MemoryProjectWorkflowStore {
     private readonly workstreams;
     private readonly workstreamEvents;
     private readonly releases;
@@ -19,7 +19,7 @@ export declare class MemoryKnowledgeCoopStore {
     getSharePackage(packageId: string): SharePackageStatus | null;
     upsertSharePackage(input: Partial<SharePackageStatus> & Pick<SharePackageStatus, 'projectId' | 'kind' | 'title'>): SharePackageStatus;
 }
-export declare class SqliteKnowledgeCoopStore extends SqliteStoreBase {
+export declare class SqliteProjectWorkflowStore extends SqliteStoreBase {
     private initialized;
     private ensureSchema;
     listWorkstreams(projectId: string): Promise<WorkstreamSummary[]>;

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

@@ -85,7 +85,7 @@ function sharePackageFromRow(row) {
     metadata: parseJson(row.metadata_json, {})
   };
 }
-class MemoryKnowledgeCoopStore {
+class MemoryProjectWorkflowStore {
   workstreams = /* @__PURE__ */ new Map();
   workstreamEvents = /* @__PURE__ */ new Map();
   releases = /* @__PURE__ */ new Map();
@@ -211,7 +211,7 @@ class MemoryKnowledgeCoopStore {
     return next;
   }
 }
-class SqliteKnowledgeCoopStore extends SqliteStoreBase {
+class SqliteProjectWorkflowStore extends SqliteStoreBase {
   initialized = false;
   async ensureSchema() {
     if (this.initialized) return;
@@ -477,6 +477,6 @@ class SqliteKnowledgeCoopStore extends SqliteStoreBase {
   }
 }
 export {
-  MemoryKnowledgeCoopStore,
-  SqliteKnowledgeCoopStore
+  MemoryProjectWorkflowStore,
+  SqliteProjectWorkflowStore
 };

package/dist/workflow/operations.js

@@ -973,14 +973,14 @@ async function connectTreeseedMarketProject(helpers, tenantRoot, input, context)
       "Treeseed config --connect-market requires a market base URL. Pass --market-base-url or configure an authenticated remote host first."
     );
   }
-  const hostId = normalizeOptionalString(marketSettings.hostId) ?? "knowledge-coop";
+  const hostId = normalizeOptionalString(marketSettings.hostId) ?? "treeseed-market";
   const activeRemoteSession = resolveTreeseedRemoteSession(tenantRoot, hostId) ?? resolveTreeseedRemoteSession(tenantRoot, remoteSettings.activeHostId) ?? resolveTreeseedRemoteSession(tenantRoot, "official");
   const accessToken = normalizeOptionalString(input.marketAccessToken) ?? normalizeOptionalString(activeRemoteSession?.accessToken);
   if (!accessToken) {
     workflowError(
       "config",
       "validation_failed",
-      "Treeseed config --connect-market requires a market access token. Authenticate to the Knowledge Coop control-plane first or pass --market-access-token."
+      "Treeseed config --connect-market requires a market access token. Authenticate to the TreeSeed control-plane first or pass --market-access-token."
     );
   }
   const projectId = normalizeOptionalString(input.marketProjectId) ?? normalizeOptionalString(marketSettings.projectId);
@@ -1018,7 +1018,7 @@ async function connectTreeseedMarketProject(helpers, tenantRoot, input, context)
   const hosts = Array.isArray(remoteSettings.hosts) ? [...remoteSettings.hosts] : [];
   const updatedHost = {
     id: hostId,
-    label: "Knowledge Coop",
+    label: "TreeSeed",
     baseUrl,
     official: false
   };
@@ -1051,7 +1051,7 @@ async function connectTreeseedMarketProject(helpers, tenantRoot, input, context)
       expiresAt: "",
       principal: {
         id: `runner:${projectId}`,
-        displayName: "Knowledge Coop Project Runner",
+        displayName: "TreeSeed Project Runner",
         scopes: [],
         roles: ["project_runner"],
         permissions: [],
@@ -1104,10 +1104,10 @@ async function connectTreeseedMarketProject(helpers, tenantRoot, input, context)
       runnerTokenIssued: Boolean(connectionResult.runnerToken)
     },
     {
-      summary: "Knowledge Coop project pairing completed.",
+      summary: "TreeSeed project pairing completed.",
       nextSteps: createNextSteps([
         { operation: "status", reason: "Confirm the new market connection, runner health, and current workstream posture." },
-        { operation: "tasks", reason: "Inspect the branch-backed workstreams that will now sync into the Knowledge Coop UI." }
+        { operation: "tasks", reason: "Inspect the branch-backed workstreams that will now sync into the TreeSeed UI." }
       ])
     }
   );

package/dist/workflow-state.js

@@ -703,8 +703,8 @@ function resolveTreeseedWorkflowState(cwd, options = {}) {
   state.marketConnection.verificationPosture = state.readiness.local.ready ? "ready" : state.files.machineConfig ? "blocked" : "pending";
   const registrationRequired = state.marketConnection.runtimeRegistration === "required";
   state.marketConnection.approvalBlockers = [
-    ...registrationRequired && !state.marketConnection.configured ? ["Knowledge Coop runtime attachment is not configured."] : [],
-    ...registrationRequired && !state.marketConnection.runtimeReady ? ["Knowledge Coop runtime credential is missing or not ready."] : []
+    ...registrationRequired && !state.marketConnection.configured ? ["TreeSeed runtime attachment is not configured."] : [],
+    ...registrationRequired && !state.marketConnection.runtimeReady ? ["TreeSeed runtime credential is missing or not ready."] : []
   ];
   state.recommendations = recommendTreeseedNextSteps(state);
   return state;

package/package.json

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