@treeseed/sdk 0.8.7 → 0.8.9

package/dist/index.js

@@ -6,9 +6,14 @@ import { ControlPlaneClient } from "./control-plane-client.js";
 import {
   reservationHasCapacity,
   reserveCreditsForEstimate,
+  routeAndReserveCapacity,
   scoreCapacityLane,
   selectBestCapacityLane,
-  summarizeCapacityPlan
+  settleCapacityActuals,
+  createReservationReleaseEntry,
+  summarizeCapacityPlan,
+  summarizeProjectCapacityPlan,
+  summarizeTeamCapacityPlan
 } from "./capacity.js";
 import {
   executeKnowledgeHubProviderLaunch,
@@ -40,20 +45,20 @@ import {
   upsertRailwayVariables
 } from "./operations/services/railway-api.js";
 import {
-  buildKnowledgeCoopKnowledgePackPackage,
-  buildKnowledgeCoopTemplatePackage,
-  importKnowledgeCoopKnowledgePack
-} from "./operations/services/knowledge-coop-packaging.js";
+  buildKnowledgePackMarketPackage,
+  buildTemplateMarketPackage,
+  importKnowledgePack
+} from "./operations/services/market-packaging.js";
 import {
-  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,
+  RELEASE_STATES,
+  SHARE_PACKAGE_STATES,
+  PROJECT_TEAM_CAPABILITIES,
+  WORKSTREAM_STATES,
+  normalizeProjectJobStatus,
   normalizeRemoteJobStatus
-} from "./knowledge-coop.js";
+} from "./project-workflow.js";
 import {
   PUBLISHED_CONTENT_MANIFEST_SCHEMA_VERSION,
   EDITORIAL_PREVIEW_COOKIE,
@@ -194,6 +199,7 @@ import {
 import { getTreeseedVerifyDriverStatus, runTreeseedVerifyDriver } from "./verification.js";
 import { CloudflareHttpD1Database } from "./d1-http.js";
 export {
+  AGENT_MESSAGE_KINDS,
   AgentSdk,
   BUILTIN_MODEL_REGISTRY,
   CloudflareHttpD1Database,
@@ -204,16 +210,13 @@ export {
   DEFAULT_GRAPH_RANKING_PROVIDER,
   DEFAULT_TREESEED_MARKET_BASE_URL,
   EDITORIAL_PREVIEW_COOKIE,
-  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,
   MODEL_REGISTRY,
   MarketApiError,
   MarketClient,
+  PROJECT_JOB_STATUSES,
+  PROJECT_TEAM_CAPABILITIES,
   PUBLISHED_CONTENT_MANIFEST_SCHEMA_VERSION,
+  RELEASE_STATES,
   RemoteTemplateCatalogClient,
   RemoteTreeseedAuthClient,
   RemoteTreeseedClient,
@@ -222,6 +225,7 @@ export {
   RemoteTreeseedOperationsClient,
   RemoteTreeseedRunnerClient,
   RemoteTreeseedSdkClient,
+  SHARE_PACKAGE_STATES,
   ScopedAgentSdk,
   TREESEED_CATALOG_MARKET_API_BASE_URLS_ENV,
   TREESEED_CENTRAL_MARKET_API_BASE_URL_ENV,
@@ -233,13 +237,14 @@ export {
   TeamScopedR2OverlayContentRuntimeProvider,
   TreeseedOperationsSdk,
   TreeseedWorkflowSdk,
+  WORKSTREAM_STATES,
   addMarketProfile,
   buildBuiltinModelRegistry,
   buildCopilotAllowToolArgs,
-  buildKnowledgeCoopKnowledgePackPackage,
-  buildKnowledgeCoopTemplatePackage,
+  buildKnowledgePackMarketPackage,
   buildModelRegistry,
   buildScopedModelRegistry,
+  buildTemplateMarketPackage,
   canonicalizeFrontmatter,
   clearMarketSession,
   collectTreeseedDependencyStatus,
@@ -250,6 +255,7 @@ export {
   createFilesystemContentSource,
   createKnowledgeHubRepositories,
   createPublishedContentPipeline,
+  createReservationReleaseEntry,
   createTeamScopedR2OverlayContentPublishProvider,
   createTeamScopedR2OverlayContentRuntimeProvider,
   createTreeseedManagedToolEnv,
@@ -270,7 +276,7 @@ export {
   getRailwayAuthProfile,
   getTenantContentRoot,
   getTreeseedVerifyDriverStatus,
-  importKnowledgeCoopKnowledgePack,
+  importKnowledgePack,
   installTreeseedDependencies,
   isTeamScopedR2ContentEnabled,
   listIntegratedMarketCatalog,
@@ -289,9 +295,9 @@ export {
   normalizeAgentCliOptions,
   normalizeAliasedRecord,
   normalizeFilterFields,
-  normalizeKnowledgeCoopJobStatus,
   normalizeKnowledgeHubLaunchIntent,
   normalizeMutationData,
+  normalizeProjectJobStatus,
   normalizeRecordToCanonicalShape,
   normalizeRemoteJobStatus,
   normalizeSortFields,
@@ -336,14 +342,18 @@ export {
   resolveTreeseedTenantRoot,
   resolveTreeseedToolBinary,
   resolveTreeseedToolCommand,
+  routeAndReserveCapacity,
   runTreeseedCopilotTask,
   runTreeseedVerifyDriver,
   scoreCapacityLane,
   selectBestCapacityLane,
   setActiveMarketProfile,
   setMarketSession,
+  settleCapacityActuals,
   signEditorialPreviewToken,
   summarizeCapacityPlan,
+  summarizeProjectCapacityPlan,
+  summarizeTeamCapacityPlan,
   tenantFeatureEnabled,
   tenantModelRendered,
   upsertRailwayVariables,

package/dist/market-client.d.ts

@@ -165,6 +165,38 @@ export declare class MarketClient {
             environments: ProjectEnvironmentAccess[];
         };
     }>;
+    teamCapacity(teamId: string): Promise<{
+        ok: true;
+        payload: Record<string, unknown>;
+    }>;
+    launchManagedCapacityProvider(teamId: string, body?: Record<string, unknown>): Promise<{
+        ok: true;
+        payload: Record<string, unknown>;
+    }>;
+    capacityProvider(providerId: string): Promise<{
+        ok: true;
+        payload: Record<string, unknown>;
+    }>;
+    resetCapacityProviderApiKey(providerId: string, body?: Record<string, unknown>): Promise<{
+        ok: true;
+        payload: Record<string, unknown>;
+    }>;
+    revokeCapacityProviderApiKey(providerId: string, keyId: string): Promise<{
+        ok: true;
+        payload: Record<string, unknown>;
+    }>;
+    capacityGrants(teamId: string): Promise<{
+        ok: true;
+        payload: unknown[];
+    }>;
+    createCapacityGrant(teamId: string, body: Record<string, unknown>): Promise<{
+        ok: true;
+        payload: Record<string, unknown>;
+    }>;
+    enqueueAgentTask(projectId: string, body: Record<string, unknown>): Promise<{
+        ok: true;
+        payload: Record<string, unknown>;
+    }>;
     catalog(kind?: string | null): Promise<{
         ok: true;
         payload: unknown[];

package/dist/market-client.js

@@ -315,6 +315,54 @@ class MarketClient {
       { requireAuth: true }
     );
   }
+  teamCapacity(teamId) {
+    return this.request(
+      `/v1/teams/${encodeURIComponent(teamId)}/capacity`,
+      { requireAuth: true }
+    );
+  }
+  launchManagedCapacityProvider(teamId, body = {}) {
+    return this.request(
+      `/v1/teams/${encodeURIComponent(teamId)}/capacity/providers/managed`,
+      { method: "POST", body, requireAuth: true }
+    );
+  }
+  capacityProvider(providerId) {
+    return this.request(
+      `/v1/capacity/providers/${encodeURIComponent(providerId)}`,
+      { requireAuth: true }
+    );
+  }
+  resetCapacityProviderApiKey(providerId, body = {}) {
+    return this.request(
+      `/v1/capacity/providers/${encodeURIComponent(providerId)}/api-keys/reset`,
+      { method: "POST", body, requireAuth: true }
+    );
+  }
+  revokeCapacityProviderApiKey(providerId, keyId) {
+    return this.request(
+      `/v1/capacity/providers/${encodeURIComponent(providerId)}/api-keys/${encodeURIComponent(keyId)}/revoke`,
+      { method: "POST", requireAuth: true }
+    );
+  }
+  capacityGrants(teamId) {
+    return this.request(
+      `/v1/teams/${encodeURIComponent(teamId)}/capacity-grants`,
+      { requireAuth: true }
+    );
+  }
+  createCapacityGrant(teamId, body) {
+    return this.request(
+      `/v1/teams/${encodeURIComponent(teamId)}/capacity-grants`,
+      { method: "POST", body, requireAuth: true }
+    );
+  }
+  enqueueAgentTask(projectId, body) {
+    return this.request(
+      `/v1/projects/${encodeURIComponent(projectId)}/agent-tasks`,
+      { method: "POST", body, requireAuth: true }
+    );
+  }
   catalog(kind) {
     const query = kind ? `?kind=${encodeURIComponent(kind)}` : "";
     return this.request(`/v1/catalog${query}`, { requireAuth: Boolean(this.accessToken) });

package/dist/operations/services/config-runtime.js

@@ -1851,30 +1851,53 @@ function checkGitHubConnection({ tenantRoot, env }) {
   if (!gh) {
     return providerConnectionResult("github", false, "GitHub CLI `gh` is not installed.");
   }
-  const repository = maybeResolveGitHubRepositorySlug(tenantRoot);
-  const args = repository ? ["repo", "view", repository, "--json", "nameWithOwner", "--jq", ".nameWithOwner"] : ["api", "user", "--jq", ".login"];
+  const identityMode = env.TREESEED_GITHUB_IDENTITY_MODE === "account" ? "account" : "repository";
+  const repository = identityMode === "repository" ? maybeResolveGitHubRepositorySlug(tenantRoot) : null;
+  const owner = typeof env.TREESEED_HOSTED_HUBS_GITHUB_OWNER === "string" ? env.TREESEED_HOSTED_HUBS_GITHUB_OWNER.trim() : "";
+  const commandCandidates = repository ? [{
+    args: ["repo", "view", repository, "--json", "nameWithOwner", "--jq", ".nameWithOwner"],
+    successMessage: (resolved) => `GitHub token can access ${resolved || repository}.`
+  }] : owner ? [
+    {
+      args: ["api", `orgs/${owner}`, "--jq", ".login"],
+      successMessage: (resolved) => `GitHub token can access organization ${resolved || owner}.`,
+      optional: true
+    },
+    {
+      args: ["api", `users/${owner}`, "--jq", ".login"],
+      successMessage: (resolved) => `GitHub token can access user ${resolved || owner}.`,
+      optional: true
+    }
+  ] : [
+    {
+      args: ["api", "user", "--jq", ".login"],
+      successMessage: (resolved) => resolved ? `Authenticated as ${resolved}.` : "GitHub API check succeeded."
+    }
+  ];
+  let lastDetail = "";
   for (let attempt = 0; attempt < 3; attempt += 1) {
-    const result = spawnSync(gh, args, {
-      cwd: tenantRoot,
-      stdio: "pipe",
-      encoding: "utf8",
-      env: createTreeseedManagedToolEnv({ ...process.env, ...env }),
-      timeout: CLI_CHECK_TIMEOUT_MS
-    });
-    if (result.status === 0) {
-      const resolved = result.stdout.trim();
-      return providerConnectionResult(
-        "github",
-        true,
-        repository ? `GitHub token can access ${resolved || repository}.` : resolved ? `Authenticated as ${resolved}.` : "GitHub API check succeeded."
-      );
+    for (const candidate of commandCandidates) {
+      const result = spawnSync(gh, candidate.args, {
+        cwd: tenantRoot,
+        stdio: "pipe",
+        encoding: "utf8",
+        env: createTreeseedManagedToolEnv({ ...process.env, ...env }),
+        timeout: CLI_CHECK_TIMEOUT_MS
+      });
+      if (result.status === 0) {
+        return providerConnectionResult("github", true, candidate.successMessage(result.stdout.trim()));
+      }
+      lastDetail = formatCheckOutput(result) || "GitHub API check failed.";
+      if (candidate.optional && !isTransientProviderConnectionError(lastDetail)) {
+        continue;
+      }
+      break;
     }
-    const detail = formatCheckOutput(result) || "GitHub API check failed.";
-    if (attempt >= 2 || !isTransientProviderConnectionError(detail)) {
-      return providerConnectionResult("github", false, detail);
+    if (attempt >= 2 || !isTransientProviderConnectionError(lastDetail)) {
+      return providerConnectionResult("github", false, lastDetail || "GitHub API check failed.");
     }
   }
-  return providerConnectionResult("github", false, "GitHub API check failed.");
+  return providerConnectionResult("github", false, lastDetail || "GitHub API check failed.");
 }
 function checkCloudflareConnection({ tenantRoot, env }) {
   if (!env.CLOUDFLARE_API_TOKEN) {
@@ -1964,8 +1987,22 @@ async function checkRailwayConnection({ tenantRoot, env }) {
 }
 async function checkTreeseedProviderConnections({ tenantRoot, scope = "prod", env = process.env, valuesOverlay = {} } = {}) {
   const values = collectTreeseedConfigSeedValues(tenantRoot, scope, env, valuesOverlay);
+  const passthroughValue = (key) => {
+    const overlayValue = valuesOverlay?.[key];
+    if (typeof overlayValue === "string" && overlayValue.trim()) {
+      return overlayValue.trim();
+    }
+    const envValue = env?.[key];
+    if (typeof envValue === "string" && envValue.trim()) {
+      return envValue.trim();
+    }
+    const resolvedValue = values?.[key];
+    return typeof resolvedValue === "string" && resolvedValue.trim() ? resolvedValue.trim() : void 0;
+  };
   const rawCommandEnv = {
     GH_TOKEN: values.GH_TOKEN,
+    TREESEED_GITHUB_IDENTITY_MODE: passthroughValue("TREESEED_GITHUB_IDENTITY_MODE"),
+    TREESEED_HOSTED_HUBS_GITHUB_OWNER: passthroughValue("TREESEED_HOSTED_HUBS_GITHUB_OWNER"),
     CLOUDFLARE_API_TOKEN: values.CLOUDFLARE_API_TOKEN,
     CLOUDFLARE_ACCOUNT_ID: values.CLOUDFLARE_ACCOUNT_ID,
     RAILWAY_API_TOKEN: values.RAILWAY_API_TOKEN,

package/dist/operations/services/d1-migration.js

@@ -3,12 +3,14 @@ import { resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import { resolveWranglerBin } from "./runtime-tools.js";
 const DATABASE_BINDING = "SITE_DATA_DB";
+const WRANGLER_D1_TIMEOUT_MS = 12e4;
 function runWrangler(args, { cwd, capture = false } = {}) {
   return spawnSync(process.execPath, [resolveWranglerBin(), ...args], {
     cwd,
-    env: { ...process.env },
+    env: { ...process.env, WRANGLER_SEND_METRICS: "false" },
     stdio: capture ? ["ignore", "pipe", "pipe"] : "inherit",
-    encoding: capture ? "utf8" : void 0
+    encoding: capture ? "utf8" : void 0,
+    timeout: WRANGLER_D1_TIMEOUT_MS
   });
 }
 function executeSqlFile({ cwd, wranglerConfig, filePath, persistTo }) {
@@ -26,12 +28,18 @@ function executeSqlCommand({ cwd, wranglerConfig, command, persistTo, capture =
   if (persistTo) {
     args.push("--persist-to", persistTo);
   }
+  if (capture) {
+    args.push("--json");
+  }
   const result = runWrangler(args, { cwd, capture });
   if (result.status !== 0) {
     if (capture) {
       if (result.stdout) process.stdout.write(result.stdout);
       if (result.stderr) process.stderr.write(result.stderr);
     }
+    if (result.error && "code" in result.error && result.error.code === "ETIMEDOUT") {
+      console.error(`Wrangler D1 command timed out after ${Math.round(WRANGLER_D1_TIMEOUT_MS / 1e3)} seconds.`);
+    }
     process.exit(result.status ?? 1);
   }
   return result;

package/dist/operations/services/github-automation.js

@@ -221,7 +221,7 @@ async function createGitHubRepository(input, { env = process.env } = {}) {
 function initializeGitHubRepositoryWorkingTree(cwd, repository, {
   defaultBranch = "main",
   createStaging = true,
-  commitMessage = "Initialize Knowledge Coop hub",
+  commitMessage = "Initialize TreeSeed hub",
   remoteName = "origin",
   push = true
 } = {}) {

package/dist/operations/services/hosting-audit.d.ts

@@ -52,6 +52,7 @@ export type TreeseedHostingAuditOptions = {
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     valuesOverlay?: Record<string, string | undefined>;
     hostKinds?: TreeseedHostingAuditHostKind[];
+    providerConnectionChecks?: boolean;
     write?: (line: string) => void;
 };
 export declare function resolveTreeseedHostingAuditTarget({ tenantRoot, environment, }: {
@@ -63,5 +64,5 @@ export declare function resolveTreeseedHostingAuditTarget({ tenantRoot, environm
     target: TreeseedReconcileTarget;
     branchName: string | null;
 };
-export declare function runTreeseedHostingAudit({ tenantRoot, environment, repair, env, valuesOverlay, hostKinds: requestedHostKinds, write, }: TreeseedHostingAuditOptions): Promise<TreeseedHostingAuditReport>;
+export declare function runTreeseedHostingAudit({ tenantRoot, environment, repair, env, valuesOverlay, hostKinds: requestedHostKinds, providerConnectionChecks: shouldCheckProviderConnections, write, }: TreeseedHostingAuditOptions): Promise<TreeseedHostingAuditReport>;
 export declare function formatTreeseedHostingAuditReport(report: TreeseedHostingAuditReport): string;

package/dist/operations/services/hosting-audit.js

@@ -28,8 +28,8 @@ import {
 const HOST_KINDS = ["repository", "web", "processing", "email"];
 const HOST_GROUPS = {
   repository: /* @__PURE__ */ new Set(["auth", "github"]),
-  web: /* @__PURE__ */ new Set(["auth", "cloudflare", "hosting"]),
-  processing: /* @__PURE__ */ new Set(["auth", "railway", "hosting"]),
+  web: /* @__PURE__ */ new Set(["cloudflare", "hosting"]),
+  processing: /* @__PURE__ */ new Set(["railway", "hosting"]),
   email: /* @__PURE__ */ new Set(["smtp"])
 };
 function hasValue(value) {
@@ -486,6 +486,7 @@ async function runTreeseedHostingAudit({
   env = process.env,
   valuesOverlay = {},
   hostKinds: requestedHostKinds,
+  providerConnectionChecks: shouldCheckProviderConnections = true,
   write
 }) {
   const resolved = resolveTreeseedHostingAuditTarget({ tenantRoot, environment });
@@ -511,13 +512,21 @@ async function runTreeseedHostingAudit({
   const checks = [];
   appendManualConfigChecks(checks, values, hostKinds);
   appendRegistryConfigChecks({ checks, tenantRoot, scope: resolved.scope, values, hostKinds });
-  const connectionReport = await checkTreeseedProviderConnections({
-    tenantRoot,
-    scope: resolved.scope,
-    env: values,
-    valuesOverlay: values
-  });
-  checks.push(...providerConnectionChecks(connectionReport, hostKinds));
+  if (shouldCheckProviderConnections) {
+    const connectionReport = await checkTreeseedProviderConnections({
+      tenantRoot,
+      scope: resolved.scope,
+      env: {
+        ...values,
+        TREESEED_GITHUB_IDENTITY_MODE: "account"
+      },
+      valuesOverlay: {
+        ...values,
+        TREESEED_GITHUB_IDENTITY_MODE: "account"
+      }
+    });
+    checks.push(...providerConnectionChecks(connectionReport, hostKinds));
+  }
   if (hostKinds.includes("email")) {
     checks.push(await checkSmtpReachability(values));
   }

package/dist/operations/services/hub-provider-launch.d.ts

@@ -1,6 +1,6 @@
 import { checkTreeseedProviderConnections, syncTreeseedGitHubEnvironment } from './config-runtime.ts';
 import { configuredRailwayServices, deployRailwayService, ensureRailwayScheduledJobs, verifyRailwayScheduledJobs } from './railway-deploy.ts';
-import { buildKnowledgeCoopKnowledgePackPackage, buildKnowledgeCoopTemplatePackage } from './knowledge-coop-packaging.ts';
+import { buildKnowledgePackMarketPackage, buildTemplateMarketPackage } from './market-packaging.ts';
 export type KnowledgeHubProviderLaunchFailurePhase = 'repo_provision_failed' | 'content_bootstrap_failed' | 'workflow_bootstrap_failed' | 'hosting_registration_failed' | 'runtime_connection_failed';
 export interface KnowledgeHubProviderLaunchInput {
     projectId: string;
@@ -133,8 +133,8 @@ export interface KnowledgeHubProviderLaunchResult {
     projectMetadata: Record<string, unknown>;
     defaultWorkstream: Record<string, unknown>;
     phases: KnowledgeHubProviderLaunchPhaseRecord[];
-    templatePackage: ReturnType<typeof buildKnowledgeCoopTemplatePackage>;
-    knowledgePackPackage: ReturnType<typeof buildKnowledgeCoopKnowledgePackPackage>;
+    templatePackage: ReturnType<typeof buildTemplateMarketPackage>;
+    knowledgePackPackage: ReturnType<typeof buildKnowledgePackMarketPackage>;
 }
 export interface KnowledgeHubProviderLaunchPreflightReport {
     ok: boolean;

package/dist/operations/services/hub-provider-launch.js

@@ -16,7 +16,7 @@ import { configuredRailwayServices, deployRailwayService, ensureRailwayScheduled
 import { loadCliDeployConfig } from "./runtime-tools.js";
 import { templateCatalogRoot } from "./runtime-paths.js";
 import { scaffoldTemplateProject } from "./template-registry.js";
-import { buildKnowledgeCoopKnowledgePackPackage, buildKnowledgeCoopTemplatePackage, importKnowledgeCoopKnowledgePack } from "./knowledge-coop-packaging.js";
+import { buildKnowledgePackMarketPackage, buildTemplateMarketPackage, importKnowledgePack } from "./market-packaging.js";
 import { resolveTreeseedToolBinary } from "../../managed-dependencies.js";
 class KnowledgeHubProviderLaunchError extends Error {
   phase;
@@ -81,7 +81,7 @@ function updateYamlFile(path, updater) {
 function currentTemplateCatalogUrl() {
   return `file:${resolve(templateCatalogRoot, "catalog.fixture.json")}`;
 }
-function seedKnowledgeCoopContent(projectRoot, input) {
+function seedLaunchContent(projectRoot, input) {
   const objectiveId = `objective:launch-${slugify(input.projectSlug, "hub")}`;
   const questionId = `question:operating-${slugify(input.projectSlug, "hub")}`;
   const proposalId = `proposal:operating-${slugify(input.projectSlug, "hub")}`;
@@ -108,7 +108,7 @@ date: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}
 summary: Stand up the hub, connect the runtime, and make the first workstream visible to the team.
 status: live
 timeHorizon: near-term
-motivation: Knowledge Coop launches should create immediately usable hubs instead of leaving teams in setup limbo.
+motivation: TreeSeed launches should create immediately usable hubs instead of leaving teams in setup limbo.
 primaryContributor: ${stewardSlug}
 ---
 
@@ -205,7 +205,7 @@ audience:
 
 # ${input.projectName}
 
-This knowledge hub was launched from Knowledge Coop and is ready for Direct, Workstreams, Releases, and Share workflows.
+This knowledge hub was launched from TreeSeed and is ready for Direct, Workstreams, Releases, and Share workflows.
 `);
   writeText(resolve(projectRoot, "src/content/pages", "welcome.mdx"), `---
 title: Welcome
@@ -419,7 +419,7 @@ function createDefaultWorkstream(projectId, input, seed) {
     state: "saved_remote",
     branchName: "task/initial-launch",
     branchRef: "refs/heads/task/initial-launch",
-    owner: "Knowledge Coop",
+    owner: "TreeSeed",
     linkedItems: [
       { model: "objective", id: seed.objectiveId },
       { model: "question", id: seed.questionId },
@@ -433,7 +433,7 @@ function createDefaultWorkstream(projectId, input, seed) {
     createdAt: nowIso(),
     updatedAt: nowIso(),
     metadata: {
-      launchedBy: "knowledge_coop_market"
+      launchedBy: "treeseed_market"
     }
   };
 }
@@ -567,7 +567,7 @@ function buildProcessingHostEnvironmentOverlay(input, scope) {
   overlayValue(overlay, "TREESEED_WORKER_POOL_SCALER", overlay.TREESEED_WORKER_POOL_SCALER || "railway");
   return overlay;
 }
-function scaffoldKnowledgeCoopSource(projectRoot, input) {
+function scaffoldLaunchSource(projectRoot, input) {
   const repositoryName = slugify(input.repoName ?? input.projectSlug, "project");
   const templateId = input.sourceKind === "template" ? slugify(input.sourceRef ?? "starter-basic", "starter-basic") : "starter-basic";
   const templateCatalogEnv = { TREESEED_TEMPLATE_CATALOG_URL: currentTemplateCatalogUrl() };
@@ -585,7 +585,7 @@ function scaffoldKnowledgeCoopSource(projectRoot, input) {
       if (!input.sourceRef) {
         throw new Error("Knowledge pack launch requires sourceRef to point to a package manifest or directory.");
       }
-      return importKnowledgeCoopKnowledgePack(projectRoot, input.sourceRef);
+      return importKnowledgePack(projectRoot, input.sourceRef);
     });
   }
   return scaffoldTemplateProject(templateId, projectRoot, {
@@ -716,22 +716,22 @@ async function executeKnowledgeHubProviderLaunch(input, options = {}) {
       description: input.summary ?? `Knowledge Hub for ${input.projectName}`,
       visibility: input.repoVisibility ?? "private",
       homepageUrl: resolveManagedWebUrl(repoName),
-      topics: ["knowledge-coop", "treeseed", "knowledge-hub"]
+      topics: ["treeseed", "knowledge-hub", "market"]
     }, { env: githubEnv });
     await appendPhase(phases, "repo_provision", "completed", `${input.existingRepository?.url ? "Connected" : "Created"} ${repository.slug}.`, reportPhase);
     await appendPhase(phases, "content_bootstrap", "running", "Scaffolding the project and seeding initial content.", reportPhase);
-    await scaffoldKnowledgeCoopSource(workingRoot, input);
+    await scaffoldLaunchSource(workingRoot, input);
     ensureHostedProjectFiles(workingRoot);
     const managedDefaults = applyManagedProjectDefaults(workingRoot, input);
-    const seed = seedKnowledgeCoopContent(workingRoot, input);
-    packageSourceRoot = mkdtempSync(join(tmpdir(), `knowledge-coop-package-${slugify(input.projectSlug, "project")}-`));
+    const seed = seedLaunchContent(workingRoot, input);
+    packageSourceRoot = mkdtempSync(join(tmpdir(), `market-package-${slugify(input.projectSlug, "project")}-`));
     cpSync(workingRoot, packageSourceRoot, { recursive: true });
     await appendPhase(phases, "content_bootstrap", "completed", "Scaffolded the repo and seeded Direct content.", reportPhase);
     let contentRepository = null;
     let contentRepositoryWorkingRoot = null;
     if (input.contentRepository?.name) {
       await appendPhase(phases, "content_repository", "running", "Creating content repository.", reportPhase);
-      contentRepositoryWorkingRoot = mkdtempSync(join(tmpdir(), `knowledge-coop-content-${slugify(input.projectSlug, "project")}-`));
+      contentRepositoryWorkingRoot = mkdtempSync(join(tmpdir(), `market-content-${slugify(input.projectSlug, "project")}-`));
       prepareKnowledgeHubContentRepositoryRoot(workingRoot, contentRepositoryWorkingRoot, input);
       const createdContentRepository = input.contentRepository.url ? {
         slug: `${slugify(input.contentRepository.owner ?? repoOwner, "treeseed-ai")}/${slugify(input.contentRepository.name, `${repoName}-content`)}`,
@@ -745,7 +745,7 @@ async function executeKnowledgeHubProviderLaunch(input, options = {}) {
         description: input.summary ?? `Content source for ${input.projectName}`,
         visibility: input.contentRepository.visibility ?? input.repoVisibility ?? "private",
         homepageUrl: resolveManagedWebUrl(repoName),
-        topics: ["knowledge-coop", "treeseed", "knowledge-hub", "content"]
+        topics: ["treeseed", "knowledge-hub", "content"]
       }, { env: githubEnv });
       const contentInitResult = initializeGitHubRepositoryWorkingTree(contentRepositoryWorkingRoot, createdContentRepository, {
         defaultBranch: input.contentRepository.defaultBranch ?? "main",
@@ -835,7 +835,7 @@ async function executeKnowledgeHubProviderLaunch(input, options = {}) {
       { slug: repository.slug, url: repository.url }
     );
     const packageRoot = packageSourceRoot ?? workingRoot;
-    const templatePackage = buildKnowledgeCoopTemplatePackage(packageRoot, {
+    const templatePackage = buildTemplateMarketPackage(packageRoot, {
       projectSlug: input.projectSlug,
       title: `${input.projectName} template`,
       summary: input.summary ?? null,
@@ -848,7 +848,7 @@ async function executeKnowledgeHubProviderLaunch(input, options = {}) {
         }
       }
     });
-    const knowledgePackPackage = buildKnowledgeCoopKnowledgePackPackage(packageRoot, {
+    const knowledgePackPackage = buildKnowledgePackMarketPackage(packageRoot, {
       projectSlug: input.projectSlug,
       title: `${input.projectName} knowledge pack`,
       summary: input.summary ?? null,

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

@@ -1,4 +1,4 @@
-export interface KnowledgeCoopPackageManifest {
+export interface MarketPackageManifest {
     schemaVersion: 1;
     kind: 'template' | 'knowledge_pack';
     id: string;
@@ -24,36 +24,36 @@ export interface KnowledgeCoopPackageManifest {
         publishMetadata: Record<string, unknown>;
     };
 }
-export interface KnowledgeCoopPackageBuildResult {
+export interface MarketPackageBuildResult {
     outputRoot: string;
     payloadRoot: string;
     manifestPath: string;
     files: string[];
-    manifest: KnowledgeCoopPackageManifest;
+    manifest: MarketPackageManifest;
 }
-export interface KnowledgeCoopKnowledgePackImportResult {
-    manifest: KnowledgeCoopPackageManifest;
+export interface KnowledgePackImportResult {
+    manifest: MarketPackageManifest;
     manifestPath: string;
     payloadRoot: string;
     importedPaths: string[];
 }
-export declare function resolveKnowledgeCoopPackageOutputRoot(projectRoot: string, kind: 'template' | 'knowledge_pack', slug: string): string;
-export declare function buildKnowledgeCoopTemplatePackage(projectRoot: string, input?: {
+export declare function resolveMarketPackageOutputRoot(projectRoot: string, kind: 'template' | 'knowledge_pack', slug: string): string;
+export declare function buildTemplateMarketPackage(projectRoot: string, input?: {
     id?: string;
     title?: string;
     summary?: string | null;
     outputRoot?: string | null;
     projectSlug?: string | null;
-    market?: KnowledgeCoopPackageManifest['market'];
-}): KnowledgeCoopPackageBuildResult;
-export declare function buildKnowledgeCoopKnowledgePackPackage(projectRoot: string, input?: {
+    market?: MarketPackageManifest['market'];
+}): MarketPackageBuildResult;
+export declare function buildKnowledgePackMarketPackage(projectRoot: string, input?: {
     id?: string;
     title?: string;
     summary?: string | null;
     outputRoot?: string | null;
     projectSlug?: string | null;
     includePaths?: string[];
-    market?: KnowledgeCoopPackageManifest['market'];
-}): KnowledgeCoopPackageBuildResult;
-export declare function importKnowledgeCoopKnowledgePack(targetRoot: string, sourcePath: string): KnowledgeCoopKnowledgePackImportResult;
+    market?: MarketPackageManifest['market'];
+}): MarketPackageBuildResult;
+export declare function importKnowledgePack(targetRoot: string, sourcePath: string): KnowledgePackImportResult;
 export declare function relativePackageFiles(outputRoot: string): string[];