@treeseed/core 0.10.20 → 0.10.21

package/README.md

@@ -71,6 +71,22 @@ What they do:
 - `build`: builds the internal fixture app in production-like mode
 - `test:smoke`: runs the packed-install smoke test
 
+### Integrated managed dev
+
+The published Core runtime also owns the integrated Treeseed dev supervisor used by the installable CLI:
+
+```bash
+npx trsd dev
+npx trsd dev start --web-runtime local --json
+npx trsd dev status --all --json
+npx trsd dev logs --follow
+npx trsd dev stop --json
+```
+
+`trsd dev` delegates to Core and runs the foreground supervisor. `trsd dev start` launches the same runtime as a worktree-scoped managed background instance, writing authoritative instance state under `.treeseed/dev/instances`, PID files under `.treeseed/dev/pids`, and logs under `.treeseed/logs`. The repository-family index under the git common dir is discovery-only and points back to those worktree-local records.
+
+Core should keep this runtime reusable by the CLI and by the root Market workspace. Do not duplicate process, port, PID, or log management in package-local callers.
+
 ### Full verification
 
 ```bash

package/dist/dev.d.ts

@@ -43,6 +43,7 @@ export type TreeseedIntegratedDevOptions = {
     plan?: boolean;
     reset?: boolean;
     force?: boolean;
+    forceConflicts?: boolean;
     json?: boolean;
     includeServices?: boolean;
     projectId?: string;
@@ -51,6 +52,12 @@ export type TreeseedIntegratedDevOptions = {
     processReadyGraceMs?: number;
     shutdownGraceMs?: number;
 };
+export type TreeseedManagedDevAction = 'start' | 'status' | 'logs' | 'stop' | 'restart';
+export type TreeseedManagedDevOptions = TreeseedIntegratedDevOptions & {
+    action: TreeseedManagedDevAction;
+    all?: boolean;
+    follow?: boolean;
+};
 export type TreeseedIntegratedDevCommand = {
     id: TreeseedIntegratedDevCommandId;
     label: string;
@@ -114,6 +121,29 @@ export type TreeseedIntegratedDevPlan = {
     };
     reset: TreeseedIntegratedDevResetPlan | null;
 };
+export type TreeseedDevInstanceStatus = 'starting' | 'ready' | 'degraded' | 'stopped' | 'stale';
+export type TreeseedDevInstanceRecord = {
+    schemaVersion: 1;
+    kind: 'treeseed.dev.instance';
+    projectRoot: string;
+    worktreeRoot: string;
+    branch: string | null;
+    gitCommonDir: string | null;
+    status: TreeseedDevInstanceStatus;
+    pid: number | null;
+    processGroupId: number | null;
+    startedAt: string;
+    updatedAt: string;
+    ports: Record<string, number>;
+    urls: Record<string, string>;
+    logPath: string;
+    runtimeScope: string;
+    surfaces: TreeseedIntegratedDevCommandId[];
+    readyChecks: TreeseedIntegratedDevReadinessCheck[];
+    instancePath: string;
+    pidPath: string;
+    staleReason?: string;
+};
 type SpawnLike = (command: string, args: string[], options: SpawnOptions) => ChildProcess;
 type SpawnSyncLike = typeof spawnSync;
 type SignalRegistrar = (signal: NodeJS.Signals, handler: () => void) => () => void;
@@ -138,6 +168,7 @@ type TreeseedIntegratedDevDependencies = {
     stopMarketPostgres: () => boolean;
     inspectPortOwners: (ports: readonly number[]) => TreeseedDevPortOwner[];
 };
+type ManagedStartDependencies = Pick<TreeseedIntegratedDevDependencies, 'spawn' | 'write' | 'fetch' | 'processIsAlive' | 'killProcess' | 'inspectPortOwners'>;
 export type TreeseedDevPortOwner = {
     port: number;
     pid: number | null;
@@ -151,6 +182,10 @@ export declare function createTreeseedIntegratedDevResetPlan(options: {
     enabled?: boolean;
 }): TreeseedIntegratedDevResetPlan | null;
 export declare function createTreeseedIntegratedDevPlan(options?: TreeseedIntegratedDevOptions): TreeseedIntegratedDevPlan;
+export declare function runTreeseedManagedDev(options: TreeseedManagedDevOptions, deps?: Partial<ManagedStartDependencies> & {
+    supervisorCommand?: string;
+    supervisorArgs?: string[];
+}): Promise<number>;
 export declare function runTreeseedIntegratedDevReset(reset: TreeseedIntegratedDevResetPlan | null, options: Pick<TreeseedIntegratedDevOptions, 'json'>, deps: Pick<TreeseedIntegratedDevDependencies, 'write' | 'removePath' | 'stopMailpitContainers' | 'resetMarketPostgres'>): {
     actions: TreeseedIntegratedDevResetAction[];
     enabled: boolean;

package/dist/dev.js

@@ -1,6 +1,8 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { createRequire } from "node:module";
+import { homedir } from "node:os";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { setTimeout as delay } from "node:timers/promises";
@@ -38,6 +40,9 @@ const TREESEED_DEFAULT_MARKET_POSTGRES_URL = `postgres://treeseed:treeseed@127.0
 const DEV_RELOAD_FILE = "public/__treeseed/dev-reload.json";
 const DEV_RUNTIME_DIR = ".treeseed/generated/dev";
 const DEV_RUNTIME_LEGACY_FILE = ".treeseed/generated/dev/runtime.json";
+const DEV_INSTANCE_DIR = ".treeseed/dev/instances";
+const DEV_PID_DIR = ".treeseed/dev/pids";
+const DEV_REPO_INDEX_RELATIVE_PATH = "treeseed/dev-index.json";
 const DEFAULT_READINESS_TIMEOUT_MS = 9e4;
 const DEFAULT_SETUP_STEP_TIMEOUT_MS = 3e5;
 const DEFAULT_PROCESS_READY_GRACE_MS = 1200;
@@ -176,6 +181,7 @@ function webUrlFor(host, port) {
   return `http://${browserHost(host)}:${port}`;
 }
 const CANONICAL_COMMAND_IDS = ["web", "api", "manager", "worker", "agents"];
+const ALL_COMMAND_IDS = ["web", "api", "manager", "worker", "agents", "market-runner"];
 const MARKET_DEV_COMMAND_IDS = ["web", "api", "market-runner"];
 function isMarketWorkspace(tenantRoot) {
   try {
@@ -726,8 +732,11 @@ function createTreeseedIntegratedDevPlan(options = {}) {
   const projectId = options.projectId ?? mergedEnv.TREESEED_PROJECT_ID ?? resolveSeededLocalProjectId(localD1PersistTo);
   const resolvedHostingTeamId = teamId ?? mergedEnv.TREESEED_HOSTING_TEAM_ID;
   const resolvedTeamId = mergedEnv.TREESEED_TEAM_ID ?? resolvedHostingTeamId ?? resolveSeededLocalTeamId(localD1PersistTo, projectId ?? null);
-  const marketDatabaseUrl = mergedEnv.TREESEED_MARKET_DATABASE_URL ?? TREESEED_DEFAULT_MARKET_POSTGRES_URL;
+  const marketPostgresPort = mergedEnv.TREESEED_MARKET_LOCAL_POSTGRES_PORT ?? String(TREESEED_DEFAULT_MARKET_POSTGRES_PORT);
+  const marketDatabaseUrl = mergedEnv.TREESEED_MARKET_DATABASE_URL ?? `postgres://treeseed:treeseed@127.0.0.1:${marketPostgresPort}/market_local`;
   const managedMarketPostgres = marketWorkspace && isTreeseedManagedMarketPostgresUrl(marketDatabaseUrl);
+  const mailpitSmtpPort = mergedEnv.TREESEED_MAILPIT_SMTP_PORT ?? String(TREESEED_DEFAULT_LOCAL_SMTP_PORT);
+  const mailpitUiPort = mergedEnv.TREESEED_MAILPIT_UI_PORT ?? String(TREESEED_DEFAULT_MAILPIT_UI_PORT);
   const webEntrypoint = resolveNodeEntrypoint(
     sdkPackageRoot,
     "scripts/tenant-astro-command.ts",
@@ -762,7 +771,7 @@ function createTreeseedIntegratedDevPlan(options = {}) {
       TREESEED_MARKET_DATABASE_URL: marketDatabaseUrl,
       TREESEED_MARKET_LOCAL_POSTGRES_CONTAINER: mergedEnv.TREESEED_MARKET_LOCAL_POSTGRES_CONTAINER ?? TREESEED_DEFAULT_MARKET_POSTGRES_CONTAINER,
       TREESEED_MARKET_LOCAL_POSTGRES_VOLUME: mergedEnv.TREESEED_MARKET_LOCAL_POSTGRES_VOLUME ?? TREESEED_DEFAULT_MARKET_POSTGRES_VOLUME,
-      TREESEED_MARKET_LOCAL_POSTGRES_PORT: mergedEnv.TREESEED_MARKET_LOCAL_POSTGRES_PORT ?? String(TREESEED_DEFAULT_MARKET_POSTGRES_PORT),
+      TREESEED_MARKET_LOCAL_POSTGRES_PORT: marketPostgresPort,
       TREESEED_MARKET_LOCAL_POSTGRES_MANAGED: managedMarketPostgres ? "true" : "false"
     } : {},
     TREESEED_PROJECT_ID: projectId ?? mergedEnv.TREESEED_PROJECT_ID,
@@ -780,12 +789,13 @@ function createTreeseedIntegratedDevPlan(options = {}) {
     TREESEED_BETTER_AUTH_SECRET: mergedEnv.TREESEED_BETTER_AUTH_SECRET ?? "treeseed-local-better-auth-secret-minimum-32-characters",
     ...devResetId ? { TREESEED_DEV_RESET_ID: devResetId } : {},
     TREESEED_SMTP_HOST: TREESEED_DEFAULT_LOCAL_SMTP_HOST,
-    TREESEED_SMTP_PORT: String(TREESEED_DEFAULT_LOCAL_SMTP_PORT),
+    TREESEED_SMTP_PORT: mailpitSmtpPort,
     TREESEED_SMTP_USERNAME: "",
     TREESEED_SMTP_PASSWORD: "",
     TREESEED_MAILPIT_SMTP_HOST: TREESEED_DEFAULT_LOCAL_SMTP_HOST,
-    TREESEED_MAILPIT_SMTP_PORT: String(TREESEED_DEFAULT_LOCAL_SMTP_PORT),
-    TREESEED_MAILPIT_UI_PORT: mergedEnv.TREESEED_MAILPIT_UI_PORT ?? String(TREESEED_DEFAULT_MAILPIT_UI_PORT),
+    TREESEED_MAILPIT_SMTP_PORT: mailpitSmtpPort,
+    TREESEED_MAILPIT_UI_PORT: mailpitUiPort,
+    TREESEED_MAILPIT_CONTAINER_NAME: mergedEnv.TREESEED_MAILPIT_CONTAINER_NAME,
     TREESEED_AUTH_EMAIL_FROM: mergedEnv.TREESEED_AUTH_EMAIL_FROM ?? "Treeseed Market <auth@treeseed.local>"
   };
   const reset = createTreeseedIntegratedDevResetPlan({
@@ -1033,6 +1043,505 @@ function resolveLocalMachineEnv(tenantRoot) {
     return {};
   }
 }
+function atomicWriteJson(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmpPath = `${path}.tmp-${process.pid}-${Date.now()}`;
+  writeFileSync(tmpPath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  renameSync(tmpPath, path);
+}
+function runGitText(cwd, args) {
+  const result = spawnSync("git", args, { cwd, encoding: "utf8" });
+  return (result.status ?? 1) === 0 ? String(result.stdout ?? "").trim() : null;
+}
+function resolveGitWorktreeInfo(tenantRoot) {
+  const worktreeRoot = runGitText(tenantRoot, ["rev-parse", "--show-toplevel"]) ?? tenantRoot;
+  const rawCommonDir = runGitText(tenantRoot, ["rev-parse", "--git-common-dir"]);
+  const gitCommonDir = rawCommonDir ? isAbsolute(rawCommonDir) ? rawCommonDir : resolve(tenantRoot, rawCommonDir) : null;
+  const rawBranch = runGitText(tenantRoot, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  const branch = rawBranch && rawBranch !== "HEAD" ? rawBranch : null;
+  return { worktreeRoot, gitCommonDir, branch };
+}
+function repositoryIndexId(tenantRoot, gitCommonDir) {
+  const source = gitCommonDir ?? tenantRoot;
+  return createHash("sha256").update(source).digest("hex").slice(0, 16);
+}
+function worktreeInstanceSuffix(tenantRoot) {
+  return createHash("sha256").update(resolve(tenantRoot)).digest("hex").slice(0, 10);
+}
+function repoFamilyIndexPath(tenantRoot, gitCommonDir) {
+  if (gitCommonDir) {
+    return resolve(gitCommonDir, DEV_REPO_INDEX_RELATIVE_PATH);
+  }
+  const cacheRoot = process.env.XDG_CACHE_HOME ? resolve(process.env.XDG_CACHE_HOME, "treeseed", "dev-instances") : resolve(homedir(), ".cache", "treeseed", "dev-instances");
+  return resolve(cacheRoot, `${repositoryIndexId(tenantRoot, null)}.json`);
+}
+function instanceRuntimeScope(plan) {
+  return runtimeScopeKey(plan.commands.map((command) => command.id));
+}
+function devInstanceDir(tenantRoot) {
+  return resolve(tenantRoot, DEV_INSTANCE_DIR);
+}
+function devPidDir(tenantRoot) {
+  return resolve(tenantRoot, DEV_PID_DIR);
+}
+function devInstancePath(tenantRoot, runtimeScope) {
+  return resolve(devInstanceDir(tenantRoot), `${runtimeScope}.json`);
+}
+function devPidPath(tenantRoot, runtimeScope) {
+  return resolve(devPidDir(tenantRoot), `${runtimeScope}.pid`);
+}
+function portFromReadyCheck(checks, id) {
+  const check = checks.find((entry) => entry.id === id);
+  return parsePortFromUrl(check?.url);
+}
+function portsFromPlan(plan) {
+  return Object.fromEntries(
+    Object.entries({
+      web: parsePortFromUrl(plan.webUrl ?? void 0),
+      api: parsePortFromUrl(plan.apiBaseUrl),
+      mailpit: portFromReadyCheck(plan.readyChecks, "mailpit"),
+      mailpitSmtp: Number(plan.commands[0]?.env.TREESEED_MAILPIT_SMTP_PORT ?? "") || null,
+      postgres: Number(plan.commands[0]?.env.TREESEED_MARKET_LOCAL_POSTGRES_PORT ?? "") || null
+    }).filter((entry) => Number.isInteger(entry[1]) && entry[1] > 0)
+  );
+}
+function urlsFromPlan(plan) {
+  return Object.fromEntries(
+    Object.entries({
+      web: plan.webUrl,
+      api: plan.apiBaseUrl,
+      apiHealth: `${plan.apiBaseUrl.replace(/\/+$/u, "")}/healthz`,
+      mailpit: plan.readyChecks.find((check) => check.id === "mailpit")?.url ?? null
+    }).filter((entry) => typeof entry[1] === "string" && entry[1].length > 0)
+  );
+}
+function createDevInstanceRecord(plan, status, pid, processGroupId = null, startedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const runtimeScope = instanceRuntimeScope(plan);
+  const git = resolveGitWorktreeInfo(plan.tenantRoot);
+  return {
+    schemaVersion: 1,
+    kind: "treeseed.dev.instance",
+    projectRoot: plan.tenantRoot,
+    worktreeRoot: git.worktreeRoot,
+    branch: git.branch,
+    gitCommonDir: git.gitCommonDir,
+    status,
+    pid,
+    processGroupId,
+    startedAt,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ports: portsFromPlan(plan),
+    urls: urlsFromPlan(plan),
+    logPath: plan.logPath,
+    runtimeScope,
+    surfaces: plan.commands.map((command) => command.id),
+    readyChecks: plan.readyChecks,
+    instancePath: devInstancePath(plan.tenantRoot, runtimeScope),
+    pidPath: devPidPath(plan.tenantRoot, runtimeScope)
+  };
+}
+function readDevInstanceFile(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.kind !== "treeseed.dev.instance" || typeof parsed.projectRoot !== "string" || typeof parsed.instancePath !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeDevInstance(record) {
+  const next = { ...record, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  atomicWriteJson(next.instancePath, next);
+  mkdirSync(dirname(next.pidPath), { recursive: true });
+  if (next.pid) {
+    writeFileSync(next.pidPath, `${next.pid}
+`, "utf8");
+  }
+  writeRepoFamilyIndexEntry(next);
+  return next;
+}
+function readRepoFamilyIndex(tenantRoot, gitCommonDir) {
+  const path = repoFamilyIndexPath(tenantRoot, gitCommonDir);
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.kind === "treeseed.dev.index" && Array.isArray(parsed.instances)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {
+    schemaVersion: 1,
+    kind: "treeseed.dev.index",
+    repositoryId: repositoryIndexId(tenantRoot, gitCommonDir),
+    gitCommonDir,
+    instances: []
+  };
+}
+function writeRepoFamilyIndex(index, tenantRoot, gitCommonDir) {
+  atomicWriteJson(repoFamilyIndexPath(tenantRoot, gitCommonDir), index);
+}
+function writeRepoFamilyIndexEntry(record) {
+  const index = readRepoFamilyIndex(record.projectRoot, record.gitCommonDir);
+  const entry = {
+    worktreeRoot: record.worktreeRoot,
+    instancePath: record.instancePath,
+    branch: record.branch,
+    pid: record.pid,
+    runtimeScope: record.runtimeScope,
+    updatedAt: record.updatedAt
+  };
+  const instances = index.instances.filter(
+    (candidate) => !(candidate.worktreeRoot === entry.worktreeRoot && candidate.runtimeScope === entry.runtimeScope)
+  );
+  instances.push(entry);
+  writeRepoFamilyIndex({ ...index, instances }, record.projectRoot, record.gitCommonDir);
+}
+function removeRepoFamilyIndexEntry(record) {
+  const index = readRepoFamilyIndex(record.projectRoot, record.gitCommonDir);
+  writeRepoFamilyIndex({
+    ...index,
+    instances: index.instances.filter(
+      (candidate) => !(candidate.worktreeRoot === record.worktreeRoot && candidate.runtimeScope === record.runtimeScope)
+    )
+  }, record.projectRoot, record.gitCommonDir);
+}
+function listWorktreeDevInstances(tenantRoot) {
+  try {
+    return readdirSync(devInstanceDir(tenantRoot)).filter((entry) => entry.endsWith(".json")).map((entry) => readDevInstanceFile(resolve(devInstanceDir(tenantRoot), entry))).filter((entry) => Boolean(entry));
+  } catch {
+    return [];
+  }
+}
+function listRepoFamilyDevInstances(tenantRoot) {
+  const git = resolveGitWorktreeInfo(tenantRoot);
+  const index = readRepoFamilyIndex(tenantRoot, git.gitCommonDir);
+  return index.instances.map((entry) => readDevInstanceFile(entry.instancePath)).filter((entry) => Boolean(entry));
+}
+function evaluateDevInstance(record, deps) {
+  if (!record.pid || !deps.processIsAlive(record.pid)) {
+    return { ...record, status: "stale", staleReason: record.pid ? `Process ${record.pid} is not running.` : "No supervisor pid is recorded." };
+  }
+  return record;
+}
+function removeDevInstanceRecord(record) {
+  rmSync(record.instancePath, { force: true });
+  rmSync(record.pidPath, { force: true });
+  removeRepoFamilyIndexEntry(record);
+}
+function usedPortsFromInstances(records, processIsAlive) {
+  const ports = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    const evaluated = evaluateDevInstance(record, { processIsAlive });
+    if (evaluated.status === "stale") continue;
+    for (const port of Object.values(record.ports)) {
+      if (Number.isInteger(port) && port > 0) ports.add(port);
+    }
+  }
+  return ports;
+}
+function managedPortBlock(blockIndex) {
+  const offset = blockIndex * 10;
+  return {
+    web: TREESEED_DEFAULT_WEB_PORT + offset,
+    api: TREESEED_DEFAULT_API_PORT + offset,
+    postgres: TREESEED_DEFAULT_MARKET_POSTGRES_PORT + offset,
+    mailpitSmtp: TREESEED_DEFAULT_LOCAL_SMTP_PORT + offset,
+    mailpitUi: TREESEED_DEFAULT_MAILPIT_UI_PORT + offset
+  };
+}
+function resolveManagedPortOverrides(tenantRoot, options, deps) {
+  const existing = listWorktreeDevInstances(tenantRoot).map((record) => evaluateDevInstance(record, deps)).find((record) => record.status !== "stale");
+  if (existing && options.webPort == null && options.apiPort == null) {
+    return {
+      webPort: existing.ports.web,
+      apiPort: existing.ports.api,
+      env: {
+        TREESEED_MARKET_LOCAL_POSTGRES_PORT: existing.ports.postgres ? String(existing.ports.postgres) : void 0,
+        TREESEED_MAILPIT_SMTP_PORT: existing.ports.mailpitSmtp ? String(existing.ports.mailpitSmtp) : void 0,
+        TREESEED_MAILPIT_UI_PORT: existing.ports.mailpit ? String(existing.ports.mailpit) : void 0,
+        TREESEED_MARKET_LOCAL_POSTGRES_CONTAINER: `treeseed-market-local-postgres-${worktreeInstanceSuffix(tenantRoot)}`,
+        TREESEED_MARKET_LOCAL_POSTGRES_VOLUME: `treeseed-market-local-postgres-data-${worktreeInstanceSuffix(tenantRoot)}`,
+        TREESEED_MAILPIT_CONTAINER_NAME: `treeseed-mailpit-${worktreeInstanceSuffix(tenantRoot)}`
+      }
+    };
+  }
+  const repoInstances = listRepoFamilyDevInstances(tenantRoot);
+  const usedPorts = usedPortsFromInstances(repoInstances, deps.processIsAlive);
+  for (const owner of deps.inspectPortOwners([
+    TREESEED_DEFAULT_WEB_PORT,
+    TREESEED_DEFAULT_API_PORT,
+    TREESEED_DEFAULT_MARKET_POSTGRES_PORT,
+    TREESEED_DEFAULT_LOCAL_SMTP_PORT,
+    TREESEED_DEFAULT_MAILPIT_UI_PORT
+  ])) {
+    if (owner.pid) usedPorts.add(owner.port);
+  }
+  for (let block = 0; block < 100; block += 1) {
+    const candidate = managedPortBlock(block);
+    const requestedWeb = options.webPort ?? candidate.web;
+    const requestedApi = options.apiPort ?? candidate.api;
+    const candidatePorts = [requestedWeb, requestedApi, candidate.postgres, candidate.mailpitSmtp, candidate.mailpitUi];
+    const liveOwners = deps.inspectPortOwners(candidatePorts).filter((owner) => owner.pid && owner.pid !== process.pid);
+    const blocked = candidatePorts.some((port) => usedPorts.has(port)) || liveOwners.length > 0;
+    if (!blocked || options.forceConflicts === true) {
+      return {
+        webPort: requestedWeb,
+        apiPort: requestedApi,
+        env: {
+          TREESEED_MARKET_LOCAL_POSTGRES_PORT: String(candidate.postgres),
+          TREESEED_MAILPIT_SMTP_PORT: String(candidate.mailpitSmtp),
+          TREESEED_MAILPIT_UI_PORT: String(candidate.mailpitUi),
+          TREESEED_MARKET_LOCAL_POSTGRES_CONTAINER: `treeseed-market-local-postgres-${worktreeInstanceSuffix(tenantRoot)}`,
+          TREESEED_MARKET_LOCAL_POSTGRES_VOLUME: `treeseed-market-local-postgres-data-${worktreeInstanceSuffix(tenantRoot)}`,
+          TREESEED_MAILPIT_CONTAINER_NAME: `treeseed-mailpit-${worktreeInstanceSuffix(tenantRoot)}`
+        }
+      };
+    }
+  }
+  throw new Error("Unable to allocate a free Treeseed dev port block for this worktree.");
+}
+function renderManagedDevStatus(records) {
+  if (records.length === 0) return "No managed Treeseed dev instances found.";
+  return records.map((record) => {
+    const url = record.urls.web ?? record.urls.api ?? "(no url)";
+    const branch = record.branch ? ` ${record.branch}` : "";
+    return `${record.status.padEnd(8)} pid ${record.pid ?? "-"}${branch} ${url} log ${record.logPath}`;
+  }).join("\n");
+}
+function renderDevLogJsonEventForHuman(parsed) {
+  if (parsed.kind === "treeseed.dev.log" && parsed.type === "start") {
+    const startedAt = typeof parsed.startedAt === "string" ? ` at ${parsed.startedAt}` : "";
+    return `[dev] Log session started${startedAt}.`;
+  }
+  if (parsed.kind !== "treeseed.dev.event") {
+    return null;
+  }
+  const surface = typeof parsed.surface === "string" ? `[${parsed.surface}]` : parsed.type === "setup" ? "[setup]" : "[dev]";
+  const message = typeof parsed.message === "string" ? parsed.message : typeof parsed.status === "string" ? parsed.status : "";
+  if (!message) {
+    return null;
+  }
+  if (surface === "[market-runner]") {
+    try {
+      const runner = JSON.parse(message);
+      if (runner.ok === true && runner.claimed === false && runner.operation == null) {
+        return null;
+      }
+    } catch {
+    }
+  }
+  return `${surface} ${message}`;
+}
+function renderDevLogForHuman(raw) {
+  const rendered = [];
+  for (const line of raw.split(/\r?\n/u)) {
+    if (!line) {
+      rendered.push(line);
+      continue;
+    }
+    if (line.trimStart().startsWith("{")) {
+      try {
+        const parsed = JSON.parse(line);
+        const human = renderDevLogJsonEventForHuman(parsed);
+        if (human) rendered.push(human);
+        continue;
+      } catch {
+      }
+    }
+    rendered.push(line);
+  }
+  return rendered.join("\n");
+}
+function readRecentDevLog(path, maxLines = 300, maxBytes = 256 * 1024) {
+  const stats = statSync(path);
+  const start = Math.max(0, stats.size - maxBytes);
+  const fd = openSync(path, "r");
+  try {
+    const buffer = Buffer.alloc(stats.size - start);
+    readSync(fd, buffer, 0, buffer.length, start);
+    const lines = buffer.toString("utf8").split(/\r?\n/u);
+    return lines.slice(Math.max(0, lines.length - maxLines)).join("\n");
+  } finally {
+    closeSync(fd);
+  }
+}
+async function waitForManagedInstanceReady(instancePath, options, deps) {
+  const startedAt = Date.now();
+  const timeoutMs = options.readinessTimeoutMs ?? DEFAULT_READINESS_TIMEOUT_MS;
+  while (Date.now() - startedAt < timeoutMs) {
+    const record2 = readDevInstanceFile(instancePath);
+    if (record2) {
+      const evaluated = evaluateDevInstance(record2, deps);
+      if (evaluated.status === "ready" || evaluated.status === "degraded" || evaluated.status === "stale") {
+        return evaluated;
+      }
+    }
+    await delay(500);
+  }
+  const record = readDevInstanceFile(instancePath);
+  return record ? { ...record, status: "degraded", staleReason: "Timed out waiting for readiness." } : null;
+}
+function managedDevResult(kind, ok, payload, options, write) {
+  if (options.json) {
+    write(`${JSON.stringify({ schemaVersion: 1, kind, ok, payload }, null, 2)}
+`, "stdout");
+  } else if (typeof payload === "string") {
+    write(`${payload}
+`, "stdout");
+  } else if (Array.isArray(payload)) {
+    write(`${renderManagedDevStatus(payload)}
+`, "stdout");
+  } else {
+    write(`${renderManagedDevStatus([payload])}
+`, "stdout");
+  }
+  return ok ? 0 : 1;
+}
+async function stopDevInstance(record, options, deps) {
+  if (!record.pid || !deps.processIsAlive(record.pid)) {
+    removeDevInstanceRecord(record);
+    return { ...record, status: "stale", staleReason: "Process was not running." };
+  }
+  const targetPid = record.processGroupId && process.platform !== "win32" ? -record.processGroupId : record.pid;
+  try {
+    deps.killProcess(targetPid, "SIGTERM");
+  } catch {
+  }
+  if (!await waitForProcessExit(record.pid, deps.processIsAlive, options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS)) {
+    try {
+      deps.killProcess(targetPid, "SIGKILL");
+    } catch {
+    }
+    await waitForProcessExit(record.pid, deps.processIsAlive, DEFAULT_KILL_GRACE_MS);
+  }
+  removeDevInstanceRecord(record);
+  return { ...record, status: "stopped", updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+async function runTreeseedManagedDev(options, deps = {}) {
+  const tenantRoot = resolve(options.cwd ?? process.cwd());
+  const write = deps.write ?? defaultWrite;
+  const spawnProcess = deps.spawn ?? spawn;
+  const fetchFn = deps.fetch ?? globalThis.fetch.bind(globalThis);
+  const processIsAlive = deps.processIsAlive ?? defaultProcessIsAlive;
+  const killProcess = deps.killProcess ?? defaultKillProcess;
+  const inspectPortOwners = deps.inspectPortOwners ?? defaultInspectPortOwners;
+  const baseDeps = { processIsAlive, inspectPortOwners };
+  if (options.action === "status") {
+    const records = (options.all ? listRepoFamilyDevInstances(tenantRoot) : listWorktreeDevInstances(tenantRoot)).map((record) => evaluateDevInstance(record, { processIsAlive }));
+    return managedDevResult("treeseed.dev.status", true, records, options, write);
+  }
+  if (options.action === "logs") {
+    const record = listWorktreeDevInstances(tenantRoot).map((entry) => evaluateDevInstance(entry, { processIsAlive })).find((entry) => entry.status !== "stale") ?? listWorktreeDevInstances(tenantRoot)[0];
+    if (!record) {
+      return managedDevResult("treeseed.dev.logs", false, "No managed Treeseed dev instance found for this worktree.", options, write);
+    }
+    if (options.json) {
+      return managedDevResult("treeseed.dev.logs", true, { logPath: record.logPath, exists: existsSync(record.logPath) }, options, write);
+    }
+    if (!existsSync(record.logPath)) {
+      write(`Log file does not exist yet: ${record.logPath}
+`, "stderr");
+      return 1;
+    }
+    if (options.follow) {
+      const tail = spawnProcess("tail", ["-f", record.logPath], { cwd: record.projectRoot, stdio: "inherit" });
+      return await new Promise((resolvePromise) => {
+        tail.on("exit", (code) => resolvePromise(code ?? 0));
+      });
+    }
+    write(renderDevLogForHuman(readRecentDevLog(record.logPath)), "stdout");
+    return 0;
+  }
+  if (options.action === "stop") {
+    const records = options.all ? listRepoFamilyDevInstances(tenantRoot) : listWorktreeDevInstances(tenantRoot);
+    const stopped = [];
+    for (const record of records) {
+      stopped.push(await stopDevInstance(record, options, { killProcess, processIsAlive }));
+    }
+    return managedDevResult("treeseed.dev.stop", true, stopped, options, write);
+  }
+  if (options.action === "restart") {
+    await runTreeseedManagedDev({ ...options, action: "stop" }, { ...deps, write: () => {
+    } });
+    return runTreeseedManagedDev({ ...options, action: "start" }, deps);
+  }
+  const allocated = resolveManagedPortOverrides(tenantRoot, options, baseDeps);
+  const effectiveEnv = {
+    ...options.env ?? {},
+    ...allocated.env
+  };
+  const plan = createTreeseedIntegratedDevPlan({
+    ...options,
+    cwd: tenantRoot,
+    webPort: allocated.webPort,
+    apiPort: allocated.apiPort,
+    env: effectiveEnv
+  });
+  const runtimeScope = instanceRuntimeScope(plan);
+  const instancePath = devInstancePath(tenantRoot, runtimeScope);
+  const logPath = plan.logPath;
+  const existing = readDevInstanceFile(instancePath);
+  if (existing && evaluateDevInstance(existing, { processIsAlive }).status !== "stale" && options.force !== true) {
+    return managedDevResult("treeseed.dev.start", true, evaluateDevInstance(existing, { processIsAlive }), options, write);
+  }
+  if (existing && options.force === true) {
+    await stopDevInstance(existing, options, { killProcess, processIsAlive });
+  }
+  mkdirSync(dirname(logPath), { recursive: true });
+  writeFileSync(logPath, "", { flag: "a" });
+  const supervisorCommand = deps.supervisorCommand ?? process.execPath;
+  const supervisorArgs = [
+    ...deps.supervisorArgs ?? process.argv.slice(1).filter((arg) => !["start", "restart", "status", "stop", "logs"].includes(arg)),
+    "--port",
+    String(allocated.webPort),
+    "--api-port",
+    String(allocated.apiPort),
+    ...options.webHost ? ["--host", options.webHost] : [],
+    ...options.apiHost ? ["--api-host", options.apiHost] : [],
+    ...options.webRuntime ? ["--web-runtime", options.webRuntime] : [],
+    ...options.surfaces ? ["--surfaces", options.surfaces] : options.surface ? ["--surface", options.surface] : [],
+    ...options.setupMode ? ["--setup", options.setupMode] : [],
+    ...options.feedbackMode ? ["--feedback", options.feedbackMode] : [],
+    ...options.openMode ? ["--open", options.openMode] : [],
+    ...options.reset ? ["--reset"] : [],
+    ...options.forceConflicts ? ["--force"] : [],
+    ...options.projectId ? ["--project-id", options.projectId] : [],
+    ...options.teamId ? ["--team-id", options.teamId] : []
+  ];
+  const logFd = openSync(logPath, "a");
+  const child = spawnProcess(supervisorCommand, supervisorArgs, {
+    cwd: tenantRoot,
+    env: {
+      ...process.env,
+      ...effectiveEnv,
+      TREESEED_MANAGED_DEV_INSTANCE: "1",
+      TREESEED_MANAGED_DEV_SUPPRESS_STDIO: "1"
+    },
+    stdio: ["ignore", logFd, logFd],
+    detached: true
+  });
+  closeSync(logFd);
+  child.unref?.();
+  const childPid = typeof child.pid === "number" ? child.pid : null;
+  const starting = writeDevInstance(createDevInstanceRecord(plan, "starting", childPid, childPid && process.platform !== "win32" ? childPid : null));
+  const ready = await waitForManagedInstanceReady(instancePath, options, { processIsAlive });
+  if (!ready) {
+    return managedDevResult("treeseed.dev.start", false, { ...starting, status: "degraded", staleReason: "Supervisor did not publish an instance record." }, options, write);
+  }
+  if (ready.status === "stale") {
+    return managedDevResult("treeseed.dev.start", false, ready, options, write);
+  }
+  for (const check of ready.readyChecks.filter((entry) => entry.required && entry.strategy === "http" && entry.url)) {
+    if (!await fetchOk(fetchFn, check.url, 2e3)) {
+      const degraded = writeDevInstance({ ...ready, status: "degraded", staleReason: `${check.label} is not reachable at ${check.url}.` });
+      return managedDevResult("treeseed.dev.start", false, degraded, options, write);
+    }
+  }
+  return managedDevResult("treeseed.dev.start", ready.status === "ready", ready, options, write);
+}
 function devRuntimeStateDir(tenantRoot) {
   return resolve(tenantRoot, DEV_RUNTIME_DIR);
 }
@@ -1052,7 +1561,7 @@ function readDevRuntimeStateFile(path) {
     if (!Number.isInteger(parsed.pid) || typeof parsed.tenantRoot !== "string" || typeof parsed.startedAt !== "string") {
       return null;
     }
-    const commandIds = Array.isArray(parsed.commandIds) ? parsed.commandIds.filter((id) => CANONICAL_COMMAND_IDS.includes(id)) : void 0;
+    const commandIds = Array.isArray(parsed.commandIds) ? parsed.commandIds.filter((id) => ALL_COMMAND_IDS.includes(id)) : void 0;
     return {
       pid: parsed.pid,
       tenantRoot: parsed.tenantRoot,
@@ -1135,7 +1644,9 @@ function requiredDevPorts(plan) {
 function formatPortOwner(owner) {
   return `port ${owner.port}${owner.pid ? ` pid ${owner.pid}` : ""}${owner.processName ? ` (${owner.processName})` : ""}`;
 }
-function writeCurrentDevRuntimeState(tenantRoot, commandIds) {
+function writeCurrentDevRuntimeState(plan, status = "starting") {
+  const tenantRoot = plan.tenantRoot;
+  const commandIds = plan.commands.map((command) => command.id);
   const outputPath = devRuntimeStatePath(tenantRoot, runtimeScopeKey(commandIds));
   mkdirSync(dirname(outputPath), { recursive: true });
   writeFileSync(
@@ -1149,15 +1660,30 @@ function writeCurrentDevRuntimeState(tenantRoot, commandIds) {
 `,
     "utf8"
   );
+  const managedProcessGroupId = process.env.TREESEED_MANAGED_DEV_INSTANCE === "1" && process.platform !== "win32" ? process.pid : null;
+  writeDevInstance(createDevInstanceRecord(plan, status, process.pid, managedProcessGroupId));
   return outputPath;
 }
-function removeCurrentDevRuntimeState(tenantRoot, commandIds) {
+function updateCurrentDevRuntimeState(plan, status, staleReason) {
+  const existing = readDevInstanceFile(devInstancePath(plan.tenantRoot, instanceRuntimeScope(plan)));
+  if (!existing || existing.pid !== process.pid) {
+    return;
+  }
+  writeDevInstance({ ...existing, status, staleReason });
+}
+function removeCurrentDevRuntimeState(plan) {
+  const tenantRoot = plan.tenantRoot;
+  const commandIds = plan.commands.map((command) => command.id);
   const statePath = devRuntimeStatePath(tenantRoot, runtimeScopeKey(commandIds));
   const state = readDevRuntimeStateFile(statePath);
   if (!state || state.pid !== process.pid) {
-    return;
+  } else {
+    rmSync(statePath, { force: true });
+  }
+  const instance = readDevInstanceFile(devInstancePath(tenantRoot, instanceRuntimeScope(plan)));
+  if (instance?.pid === process.pid) {
+    removeDevInstanceRecord(instance);
   }
-  rmSync(statePath, { force: true });
 }
 async function waitForProcessExit(pid, processIsAlive, timeoutMs) {
   const startedAt = Date.now();
@@ -1283,15 +1809,13 @@ function emitEvent(options, write, event, stream = event.type === "error" ? "std
 }
 function createDevLogWrite(baseWrite, logPath) {
   mkdirSync(dirname(logPath), { recursive: true });
-  appendFileSync(logPath, `${JSON.stringify({
-    schemaVersion: 1,
-    kind: "treeseed.dev.log",
-    type: "start",
-    startedAt: (/* @__PURE__ */ new Date()).toISOString()
-  })}
+  appendFileSync(logPath, `[dev] Log session started at ${(/* @__PURE__ */ new Date()).toISOString()}.
 `, "utf8");
+  const suppressBaseWrite = process.env.TREESEED_MANAGED_DEV_SUPPRESS_STDIO === "1";
   return (line, stream) => {
-    baseWrite(line, stream);
+    if (!suppressBaseWrite) {
+      baseWrite(line, stream);
+    }
     appendFileSync(logPath, line, "utf8");
   };
 }
@@ -1870,7 +2394,7 @@ async function runTreeseedIntegratedDev(options = {}, deps = {}) {
     });
     return 1;
   }
-  writeCurrentDevRuntimeState(tenantRoot, commandIds);
+  writeCurrentDevRuntimeState(plan, "starting");
   const children = /* @__PURE__ */ new Map();
   const commandsById = new Map(plan.commands.map((command) => [command.id, command]));
   const requiredSurfaceIds = new Set(plan.readyChecks.filter((check) => check.required).map((check) => check.id));
@@ -1935,7 +2459,7 @@ async function runTreeseedIntegratedDev(options = {}, deps = {}) {
       for (const dispose of disposers) {
         dispose();
       }
-      removeCurrentDevRuntimeState(tenantRoot, commandIds);
+      removeCurrentDevRuntimeState(plan);
       emitEvent(
         options,
         write,
@@ -2212,10 +2736,12 @@ async function runTreeseedIntegratedDev(options = {}, deps = {}) {
       }
       readinessInProgress = false;
       if (!allRequiredReady) {
+        updateCurrentDevRuntimeState(plan, "degraded", "One or more required readiness checks failed.");
         startLiveWatch();
         return;
       }
       readinessComplete = true;
+      updateCurrentDevRuntimeState(plan, "ready");
       if (plan.webUrl) {
         emitEvent(options, write, { type: "ready", url: plan.webUrl, message: `Treeseed dev ready at ${plan.webUrl}.` });
       }
@@ -2269,5 +2795,6 @@ export {
   createTreeseedIntegratedDevPlan,
   createTreeseedIntegratedDevResetPlan,
   runTreeseedIntegratedDev,
-  runTreeseedIntegratedDevReset
+  runTreeseedIntegratedDevReset,
+  runTreeseedManagedDev
 };

package/dist/index.d.ts

@@ -2,5 +2,5 @@ export { buildTreeseedSiteLayers, resolveTreeseedPageEntrypoint, resolveTreeseed
 export { buildTreeseedPlatformLayers, resolveTreeseedPlatformResource, TREESEED_PLATFORM_RESOURCE_KINDS, } from './platform-resources';
 export { parseSiteConfig } from './utils/site-config-schema.js';
 export { executeKnowledgeHubProviderLaunch, validateKnowledgeHubProviderLaunchPrerequisites, } from './launch';
-export { createTreeseedIntegratedDevPlan, runTreeseedIntegratedDev, type TreeseedIntegratedDevCommand, type TreeseedIntegratedDevOptions, type TreeseedIntegratedDevPlan, type TreeseedIntegratedDevSurface, } from './dev';
+export { createTreeseedIntegratedDevPlan, runTreeseedManagedDev, runTreeseedIntegratedDev, type TreeseedIntegratedDevCommand, type TreeseedIntegratedDevOptions, type TreeseedIntegratedDevPlan, type TreeseedIntegratedDevSurface, type TreeseedManagedDevOptions, type TreeseedDevInstanceRecord, } from './dev';
 export { filterSiteRenderedModels, isSiteRenderedModel, siteModelRendered, } from './utils/site-models.ts';

package/dist/index.js

@@ -17,6 +17,7 @@ import {
 } from "./launch.js";
 import {
   createTreeseedIntegratedDevPlan,
+  runTreeseedManagedDev,
   runTreeseedIntegratedDev
 } from "./dev.js";
 import {
@@ -39,6 +40,7 @@ export {
   resolveTreeseedSiteResource,
   resolveTreeseedStyleEntrypoint,
   runTreeseedIntegratedDev,
+  runTreeseedManagedDev,
   siteModelRendered,
   validateKnowledgeHubProviderLaunchPrerequisites
 };

package/dist/platform.d.ts

@@ -1,2 +1,2 @@
 export { buildTreeseedPlatformLayers, resolveTreeseedPlatformResource, TREESEED_PLATFORM_RESOURCE_KINDS, type TreeseedPlatformLayer, } from './platform-resources';
-export { createTreeseedIntegratedDevPlan, runTreeseedIntegratedDev, type TreeseedIntegratedDevCommand, type TreeseedIntegratedDevOptions, type TreeseedIntegratedDevPlan, type TreeseedIntegratedDevSurface, } from './dev';
+export { createTreeseedIntegratedDevPlan, runTreeseedManagedDev, runTreeseedIntegratedDev, type TreeseedIntegratedDevCommand, type TreeseedIntegratedDevOptions, type TreeseedIntegratedDevPlan, type TreeseedIntegratedDevSurface, type TreeseedManagedDevOptions, type TreeseedDevInstanceRecord, } from './dev';

package/dist/platform.js

@@ -5,6 +5,7 @@ import {
 } from "./platform-resources.js";
 import {
   createTreeseedIntegratedDevPlan,
+  runTreeseedManagedDev,
   runTreeseedIntegratedDev
 } from "./dev.js";
 export {
@@ -12,5 +13,6 @@ export {
   buildTreeseedPlatformLayers,
   createTreeseedIntegratedDevPlan,
   resolveTreeseedPlatformResource,
-  runTreeseedIntegratedDev
+  runTreeseedIntegratedDev,
+  runTreeseedManagedDev
 };

package/dist/scripts/dev-platform.js

@@ -1,6 +1,12 @@
 #!/usr/bin/env node
-import { runTreeseedIntegratedDev, } from '../dev.js';
-const args = process.argv.slice(2);
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runTreeseedManagedDev, runTreeseedIntegratedDev, } from '../dev.js';
+const rawArgs = process.argv.slice(2);
+const managedActions = new Set(['start', 'status', 'logs', 'stop', 'restart']);
+const action = managedActions.has(rawArgs[0] ?? '') ? rawArgs[0] : null;
+const args = action ? rawArgs.slice(1) : rawArgs;
 function readFlag(name) {
     return args.includes(name);
 }
@@ -70,24 +76,47 @@ function readForwardedEnvironment() {
         .map((key) => [key, process.env[key]])
         .filter((entry) => typeof entry[1] === 'string' && entry[1].length > 0));
 }
-const exitCode = await runTreeseedIntegratedDev({
-    surface: parseSurface(readOption('--surface')),
-    surfaces: readOption('--surfaces'),
-    watch: readFlag('--watch'),
-    webHost: readOption('--host'),
-    webPort: readNumberOption('--port'),
-    apiHost: readOption('--api-host'),
-    apiPort: readNumberOption('--api-port'),
-    webRuntime: parseLocalRuntimeMode(readOption('--web-runtime')),
-    setupMode: parseSetupMode(readOption('--setup')),
-    feedbackMode: parseFeedbackMode(readOption('--feedback')),
-    openMode: parseOpenMode(readOption('--open')),
-    plan: readFlag('--plan'),
-    reset: readFlag('--reset'),
-    force: readFlag('--force'),
-    json: readFlag('--json'),
-    projectId: readOption('--project-id'),
-    teamId: readOption('--team-id'),
-    env: readForwardedEnvironment(),
-});
-process.exit(exitCode);
+function resolveSupervisorArgs() {
+    const scriptPath = fileURLToPath(import.meta.url);
+    if (scriptPath.endsWith('.ts')) {
+        const runnerPath = resolve(dirname(scriptPath), 'run-ts.mjs');
+        return existsSync(runnerPath) ? [runnerPath, scriptPath] : [scriptPath];
+    }
+    return [scriptPath];
+}
+async function main() {
+    const common = {
+        surface: parseSurface(readOption('--surface')),
+        surfaces: readOption('--surfaces'),
+        watch: readFlag('--watch'),
+        webHost: readOption('--host'),
+        webPort: readNumberOption('--port'),
+        apiHost: readOption('--api-host'),
+        apiPort: readNumberOption('--api-port'),
+        webRuntime: parseLocalRuntimeMode(readOption('--web-runtime')),
+        setupMode: parseSetupMode(readOption('--setup')),
+        feedbackMode: parseFeedbackMode(readOption('--feedback')),
+        openMode: parseOpenMode(readOption('--open')),
+        plan: readFlag('--plan'),
+        reset: readFlag('--reset'),
+        force: readFlag('--force'),
+        forceConflicts: readFlag('--force-conflicts'),
+        json: readFlag('--json'),
+        projectId: readOption('--project-id'),
+        teamId: readOption('--team-id'),
+        env: readForwardedEnvironment(),
+    };
+    if (!action) {
+        return runTreeseedIntegratedDev(common);
+    }
+    return runTreeseedManagedDev({
+        ...common,
+        action,
+        all: readFlag('--all'),
+        follow: readFlag('--follow'),
+    }, {
+        supervisorCommand: process.execPath,
+        supervisorArgs: resolveSupervisorArgs(),
+    });
+}
+process.exit(await main());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/core",
-  "version": "0.10.20",
+  "version": "0.10.21",
   "description": "Treeseed web framework package for Astro/Starlight site runtimes.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -70,7 +70,7 @@
     "@astrojs/sitemap": "3.7.0",
     "@astrojs/starlight": "0.37.6",
     "@tailwindcss/vite": "^4.1.4",
-    "@treeseed/sdk": "github:treeseed-ai/sdk#0.10.26",
+    "@treeseed/sdk": "github:treeseed-ai/sdk#0.10.27",
     "astro": "^5.6.1",
     "esbuild": "^0.28.0",
     "katex": "^0.16.22",