@treeseed/sdk 0.6.6 → 0.6.8

package/dist/operations/services/workspace-dependency-mode.d.ts

@@ -0,0 +1,70 @@
+export type DependencyResolutionMode = 'local-workspace' | 'git-dev' | 'stable-registry';
+export type WorkspaceLinksMode = 'auto' | 'off';
+type WorkspaceLink = {
+    packageName: string;
+    linkPath: string;
+    targetPath: string;
+    scope: 'root' | 'package';
+    ownerPath: string;
+};
+export type WorkspaceDependencyModeReport = {
+    mode: DependencyResolutionMode;
+    enabled: boolean;
+    root: string;
+    links: Array<WorkspaceLink & {
+        exists: boolean;
+        linked: boolean;
+        targetMatches: boolean;
+        currentTarget: string | null;
+    }>;
+    created: string[];
+    removed: string[];
+    issues: string[];
+};
+export type DeploymentLockfileWorkspaceIssue = {
+    filePath: string;
+    packageName: string;
+    reason: string;
+};
+export declare function discoverWorkspaceLinks(root?: any): WorkspaceLink[];
+export declare function ensureLocalWorkspaceLinks(root?: any, options?: {
+    mode?: WorkspaceLinksMode;
+    env?: NodeJS.ProcessEnv;
+}): {
+    created: string[];
+    removed: never[];
+    mode: DependencyResolutionMode;
+    enabled: boolean;
+    root: string;
+    links: Array<WorkspaceLink & {
+        exists: boolean;
+        linked: boolean;
+        targetMatches: boolean;
+        currentTarget: string | null;
+    }>;
+    issues: string[];
+};
+export declare function unlinkLocalWorkspaceLinks(root?: any, options?: {
+    mode?: WorkspaceLinksMode;
+    env?: NodeJS.ProcessEnv;
+}): {
+    enabled: boolean;
+    removed: string[];
+    mode: DependencyResolutionMode;
+    root: string;
+    links: Array<WorkspaceLink & {
+        exists: boolean;
+        linked: boolean;
+        targetMatches: boolean;
+        currentTarget: string | null;
+    }>;
+    created: string[];
+    issues: string[];
+};
+export declare function collectDeploymentLockfileWorkspaceIssues(root?: any): DeploymentLockfileWorkspaceIssue[];
+export declare function assertNoWorkspaceLinksInDeploymentLockfiles(root?: any): void;
+export declare function inspectWorkspaceDependencyMode(root?: any, options?: {
+    mode?: WorkspaceLinksMode;
+    env?: NodeJS.ProcessEnv;
+}): WorkspaceDependencyModeReport;
+export {};

package/dist/operations/services/workspace-dependency-mode.js

@@ -0,0 +1,404 @@
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { workspacePackages, workspaceRoot } from "./workspace-tools.js";
+const METADATA_VERSION = 1;
+const INTERNAL_DEPENDENCY_FIELDS = ["dependencies", "optionalDependencies", "peerDependencies", "devDependencies"];
+function metadataPath(root) {
+  return resolve(root, ".treeseed", "workspace-links.json");
+}
+function workspaceLinksEnabled(mode = "auto", env = process.env) {
+  if (mode === "off") return false;
+  const envMode = String(env.TREESEED_WORKSPACE_LINKS ?? "auto").trim().toLowerCase();
+  return envMode !== "off" && envMode !== "false" && envMode !== "0";
+}
+function readJson(filePath) {
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function packageDirName(packageName) {
+  const parts = packageName.split("/");
+  return parts.at(-1) ?? packageName;
+}
+function linkPathFor(ownerPath, packageName) {
+  const scope = packageName.startsWith("@") ? packageName.split("/")[0] : null;
+  const name = packageDirName(packageName);
+  return scope ? resolve(ownerPath, "node_modules", scope, name) : resolve(ownerPath, "node_modules", name);
+}
+function safeLstat(path) {
+  try {
+    return lstatSync(path);
+  } catch {
+    return null;
+  }
+}
+function safeReadlink(path) {
+  try {
+    const link = readlinkSync(path);
+    return resolve(dirname(path), link);
+  } catch {
+    return null;
+  }
+}
+function pathKey(path) {
+  return resolve(path);
+}
+function readMetadata(root) {
+  const filePath = metadataPath(root);
+  if (!existsSync(filePath)) return /* @__PURE__ */ new Set();
+  try {
+    const value = readJson(filePath);
+    const links = Array.isArray(value.links) ? value.links : [];
+    return new Set(links.map((entry) => entry && typeof entry === "object" ? String(entry.linkPath ?? "") : "").filter(Boolean).map(pathKey));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function writeMetadata(root, links) {
+  const filePath = metadataPath(root);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify({
+    version: METADATA_VERSION,
+    root,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    links
+  }, null, 2)}
+`, "utf8");
+}
+function gitInfoExcludePath(repoPath) {
+  const gitPath = resolve(repoPath, ".git");
+  const stat = safeLstat(gitPath);
+  if (!stat) return null;
+  if (stat.isDirectory()) {
+    return resolve(gitPath, "info", "exclude");
+  }
+  if (stat.isFile()) {
+    try {
+      const content = readFileSync(gitPath, "utf8").trim();
+      const match = /^gitdir:\s*(.+)$/iu.exec(content);
+      if (!match) return null;
+      const gitDir = resolve(repoPath, match[1]);
+      return resolve(gitDir, "info", "exclude");
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function ensureGitInfoExcludes(root, links) {
+  const patternsByRepo = /* @__PURE__ */ new Map();
+  const addPattern = (repoPath, pattern) => {
+    const set = patternsByRepo.get(repoPath) ?? /* @__PURE__ */ new Set();
+    set.add(pattern.replaceAll("\\", "/"));
+    patternsByRepo.set(repoPath, set);
+  };
+  addPattern(root, ".treeseed/workspace-links.json");
+  for (const link of links) {
+    addPattern(link.ownerPath, relative(link.ownerPath, link.linkPath));
+  }
+  for (const [repoPath, patterns] of patternsByRepo) {
+    const excludePath = gitInfoExcludePath(repoPath);
+    if (!excludePath) continue;
+    mkdirSync(dirname(excludePath), { recursive: true });
+    const current = existsSync(excludePath) ? readFileSync(excludePath, "utf8") : "";
+    const currentLines = new Set(current.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean));
+    const missing = [...patterns].filter((pattern) => !currentLines.has(pattern));
+    if (missing.length === 0) continue;
+    const prefix = current.length > 0 && !current.endsWith("\n") ? "\n" : "";
+    writeFileSync(excludePath, `${current}${prefix}${missing.join("\n")}
+`, "utf8");
+  }
+}
+function internalDependencyNames(packageJson, packageNames) {
+  const names = /* @__PURE__ */ new Set();
+  for (const field of INTERNAL_DEPENDENCY_FIELDS) {
+    const deps = packageJson[field];
+    if (!deps || typeof deps !== "object" || Array.isArray(deps)) continue;
+    for (const name of Object.keys(deps)) {
+      if (packageNames.has(name)) names.add(name);
+    }
+  }
+  return [...names].sort();
+}
+function dependencyNames(packageJson, filter) {
+  const names = /* @__PURE__ */ new Set();
+  if (!packageJson) return names;
+  for (const field of INTERNAL_DEPENDENCY_FIELDS) {
+    const deps = packageJson[field];
+    if (!deps || typeof deps !== "object" || Array.isArray(deps)) continue;
+    for (const name of Object.keys(deps)) {
+      if (filter(name)) names.add(name);
+    }
+  }
+  return names;
+}
+function dependencySpec(packageJson, field, packageName) {
+  const deps = packageJson[field];
+  if (!deps || typeof deps !== "object" || Array.isArray(deps)) return null;
+  const value = deps[packageName];
+  return typeof value === "string" ? value : null;
+}
+function normalizedPathValue(value) {
+  return value.replaceAll("\\", "/").replace(/^\.\//u, "").replace(/\/$/u, "");
+}
+function rootLockfileAllowsWorkspaceLink(root, filePath, packageName, entry, workspacePackageByName) {
+  if (filePath !== resolve(root, "package-lock.json")) return false;
+  const workspacePackage = workspacePackageByName.get(packageName);
+  if (!workspacePackage) return false;
+  return normalizedPathValue(String(entry.resolved ?? "")) === normalizedPathValue(workspacePackage.relativeDir);
+}
+function collectPackageLockConsistencyIssues(filePath, packageJson, packages, workspacePackageByName) {
+  const issues = [];
+  const rootLockEntry = packages[""];
+  const declaredWorkspaces = Array.isArray(packageJson.workspaces) ? packageJson.workspaces.map(String) : [];
+  if (declaredWorkspaces.length > 0) {
+    const lockWorkspaces = Array.isArray(rootLockEntry?.workspaces) ? rootLockEntry.workspaces.map(String) : [];
+    if (JSON.stringify(lockWorkspaces) !== JSON.stringify(declaredWorkspaces)) {
+      issues.push({
+        filePath,
+        packageName: String(packageJson.name ?? "(root)"),
+        reason: `root-workspaces-mismatch:package.json=${JSON.stringify(declaredWorkspaces)} lockfile=${JSON.stringify(lockWorkspaces)}`
+      });
+    }
+  }
+  for (const [packageName, workspacePackage] of workspacePackageByName) {
+    const relativeDir = normalizedPathValue(workspacePackage.relativeDir);
+    const packageEntry = packages[relativeDir];
+    if (!packageEntry) {
+      issues.push({ filePath, packageName, reason: `missing-workspace-package-entry:${relativeDir}` });
+      continue;
+    }
+    if (packageEntry.name !== packageName) {
+      issues.push({ filePath, packageName, reason: `workspace-package-name-mismatch:${relativeDir}` });
+    }
+    const expectedVersion = workspacePackage.packageJson.version;
+    if (typeof expectedVersion === "string" && packageEntry.version !== expectedVersion) {
+      issues.push({ filePath, packageName, reason: `workspace-package-version-mismatch:${packageEntry.version ?? "(missing)"}!=${expectedVersion}` });
+    }
+    const linkEntry = packages[`node_modules/${packageName}`];
+    if (!linkEntry || linkEntry.link !== true || normalizedPathValue(String(linkEntry.resolved ?? "")) !== relativeDir) {
+      issues.push({ filePath, packageName, reason: `workspace-link-entry-mismatch:${relativeDir}` });
+    }
+  }
+  for (const field of INTERNAL_DEPENDENCY_FIELDS) {
+    for (const packageName of workspacePackageByName.keys()) {
+      const manifestSpec = dependencySpec(packageJson, field, packageName);
+      if (!manifestSpec) continue;
+      const lockSpec = dependencySpec(rootLockEntry ?? {}, field, packageName);
+      if (lockSpec !== manifestSpec) {
+        issues.push({
+          filePath,
+          packageName,
+          reason: `root-dependency-spec-mismatch:${field}:${lockSpec ?? "(missing)"}!=${manifestSpec}`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function discoverWorkspaceLinks(root = workspaceRoot()) {
+  if (!existsSync(resolve(root, "package.json"))) {
+    return [];
+  }
+  const packages = workspacePackages(root).filter((pkg) => typeof pkg.name === "string" && pkg.name.startsWith("@treeseed/"));
+  const packageByName = new Map(packages.map((pkg) => [String(pkg.name), pkg]));
+  const packageNames = new Set(packageByName.keys());
+  const links = [];
+  for (const pkg of packages) {
+    links.push({
+      packageName: String(pkg.name),
+      linkPath: linkPathFor(root, String(pkg.name)),
+      targetPath: pkg.dir,
+      scope: "root",
+      ownerPath: root
+    });
+  }
+  for (const owner of packages) {
+    for (const dependencyName of internalDependencyNames(owner.packageJson, packageNames)) {
+      const dependency = packageByName.get(dependencyName);
+      if (!dependency) continue;
+      links.push({
+        packageName: dependencyName,
+        linkPath: linkPathFor(owner.dir, dependencyName),
+        targetPath: dependency.dir,
+        scope: "package",
+        ownerPath: owner.dir
+      });
+    }
+  }
+  return links;
+}
+function isInstalledTreeseedPackage(path, packageName) {
+  try {
+    const packageJson = readJson(resolve(path, "package.json"));
+    return packageJson.name === packageName;
+  } catch {
+    return false;
+  }
+}
+function isEmptyDirectory(path) {
+  try {
+    return safeLstat(path)?.isDirectory() === true && readdirSync(path).length === 0;
+  } catch {
+    return false;
+  }
+}
+function removeLinkCandidate(link, managedLinks) {
+  const stat = safeLstat(link.linkPath);
+  if (!stat) return true;
+  const currentTarget = stat.isSymbolicLink() ? safeReadlink(link.linkPath) : null;
+  const managed = managedLinks.has(pathKey(link.linkPath)) || currentTarget === pathKey(link.targetPath);
+  if (stat.isSymbolicLink()) {
+    if (!managed && currentTarget !== pathKey(link.targetPath)) {
+      throw new Error(`Refusing to remove unmanaged workspace link ${link.linkPath}.`);
+    }
+    unlinkSync(link.linkPath);
+    return true;
+  }
+  if (isInstalledTreeseedPackage(link.linkPath, link.packageName)) {
+    rmSync(link.linkPath, { recursive: true, force: true });
+    return true;
+  }
+  if (isEmptyDirectory(link.linkPath)) {
+    rmSync(link.linkPath, { recursive: true, force: true });
+    return true;
+  }
+  throw new Error(`Refusing to replace unmanaged path ${link.linkPath}.`);
+}
+function createLink(link) {
+  mkdirSync(dirname(link.linkPath), { recursive: true });
+  const relativeTarget = relative(dirname(link.linkPath), link.targetPath) || ".";
+  symlinkSync(relativeTarget, link.linkPath, process.platform === "win32" ? "junction" : "dir");
+}
+function ensureLocalWorkspaceLinks(root = workspaceRoot(), options = {}) {
+  const enabled = workspaceLinksEnabled(options.mode, options.env);
+  const links = discoverWorkspaceLinks(root);
+  const report = inspectWorkspaceDependencyMode(root, { mode: options.mode, env: options.env });
+  if (!enabled) return { ...report, enabled: false, created: [], removed: [] };
+  ensureGitInfoExcludes(root, links);
+  const managedLinks = readMetadata(root);
+  const created = [];
+  for (const link of links) {
+    const stat = safeLstat(link.linkPath);
+    const currentTarget = stat?.isSymbolicLink() ? safeReadlink(link.linkPath) : null;
+    if (stat?.isSymbolicLink() && currentTarget === pathKey(link.targetPath)) continue;
+    removeLinkCandidate(link, managedLinks);
+    createLink(link);
+    created.push(link.linkPath);
+  }
+  writeMetadata(root, links);
+  return {
+    ...inspectWorkspaceDependencyMode(root, { mode: options.mode, env: options.env }),
+    created,
+    removed: []
+  };
+}
+function unlinkLocalWorkspaceLinks(root = workspaceRoot(), options = {}) {
+  const enabled = workspaceLinksEnabled(options.mode, options.env);
+  const links = discoverWorkspaceLinks(root);
+  const managedLinks = readMetadata(root);
+  const removed = [];
+  if (!enabled) return { ...inspectWorkspaceDependencyMode(root, { mode: options.mode, env: options.env }), enabled: false, removed };
+  for (const link of links) {
+    const stat = safeLstat(link.linkPath);
+    if (!stat) continue;
+    const currentTarget = stat.isSymbolicLink() ? safeReadlink(link.linkPath) : null;
+    const managed = managedLinks.has(pathKey(link.linkPath)) || currentTarget === pathKey(link.targetPath);
+    if (!stat.isSymbolicLink() || !managed) continue;
+    unlinkSync(link.linkPath);
+    removed.push(link.linkPath);
+  }
+  return {
+    ...inspectWorkspaceDependencyMode(root, { mode: options.mode, env: options.env }),
+    removed,
+    created: []
+  };
+}
+function collectDeploymentLockfileWorkspaceIssues(root = workspaceRoot()) {
+  if (!existsSync(resolve(root, "package.json"))) {
+    return [];
+  }
+  const rootPackageJson = readJson(resolve(root, "package.json"));
+  const workspacePkgs = workspacePackages(root).filter((pkg) => typeof pkg.name === "string" && pkg.name.startsWith("@treeseed/"));
+  const workspacePackageByName = new Map(workspacePkgs.map((pkg) => [String(pkg.name), {
+    relativeDir: pkg.relativeDir,
+    packageJson: pkg.packageJson
+  }]));
+  const packageNames = workspacePackageByName.size > 0 ? new Set(workspacePackageByName.keys()) : dependencyNames(rootPackageJson, (name) => name.startsWith("@treeseed/"));
+  const lockRoots = workspacePkgs.length > 0 ? [root, ...workspacePkgs.map((pkg) => pkg.dir)] : [root];
+  const issues = [];
+  for (const dir of lockRoots) {
+    const filePath = resolve(dir, "package-lock.json");
+    if (!existsSync(filePath)) continue;
+    let lock;
+    try {
+      lock = readJson(filePath);
+    } catch {
+      continue;
+    }
+    const packages = lock.packages && typeof lock.packages === "object" && !Array.isArray(lock.packages) ? lock.packages : {};
+    if (dir === root && workspacePackageByName.size > 0) {
+      issues.push(...collectPackageLockConsistencyIssues(filePath, rootPackageJson, packages, workspacePackageByName));
+    }
+    const checkedPackageNames = dir === root ? packageNames : dependencyNames(
+      existsSync(resolve(dir, "package.json")) ? readJson(resolve(dir, "package.json")) : null,
+      (name) => name.startsWith("@treeseed/")
+    );
+    const lockPackageNames = new Set(Object.keys(packages).map((key) => /^node_modules\/(@treeseed\/[^/]+)$/u.exec(key)?.[1] ?? null).filter((name) => Boolean(name)));
+    for (const packageName of /* @__PURE__ */ new Set([...packageNames, ...checkedPackageNames, ...lockPackageNames])) {
+      const entry = packages[`node_modules/${packageName}`];
+      if (!entry) continue;
+      const resolvedValue = String(entry.resolved ?? "");
+      if (entry.link === true) {
+        if (!rootLockfileAllowsWorkspaceLink(root, filePath, packageName, entry, workspacePackageByName)) {
+          issues.push({ filePath, packageName, reason: "workspace-link-lock-entry" });
+        }
+      } else if (/^(?:\.\.?\/|packages\/|file:)/u.test(resolvedValue)) {
+        issues.push({ filePath, packageName, reason: `local-lock-resolved:${resolvedValue}` });
+      }
+    }
+  }
+  return issues.filter((issue, index, all) => all.findIndex((candidate) => candidate.filePath === issue.filePath && candidate.packageName === issue.packageName && candidate.reason === issue.reason) === index);
+}
+function assertNoWorkspaceLinksInDeploymentLockfiles(root = workspaceRoot()) {
+  const issues = collectDeploymentLockfileWorkspaceIssues(root);
+  if (issues.length === 0) return;
+  throw new Error(`Deployment lockfile validation failed.
+${issues.map((issue) => `${issue.filePath}: ${issue.packageName} ${issue.reason}`).join("\n")}`);
+}
+function inspectWorkspaceDependencyMode(root = workspaceRoot(), options = {}) {
+  const enabled = workspaceLinksEnabled(options.mode, options.env);
+  const links = discoverWorkspaceLinks(root);
+  const inspected = links.map((link) => {
+    const stat = safeLstat(link.linkPath);
+    const currentTarget = stat?.isSymbolicLink() ? safeReadlink(link.linkPath) : null;
+    const targetMatches = currentTarget === pathKey(link.targetPath);
+    return {
+      ...link,
+      exists: Boolean(stat),
+      linked: stat?.isSymbolicLink() === true,
+      targetMatches,
+      currentTarget
+    };
+  });
+  const lockIssues = collectDeploymentLockfileWorkspaceIssues(root).map((issue) => `${issue.filePath}: ${issue.packageName} ${issue.reason}`);
+  const allLinked = inspected.length > 0 && inspected.every((link) => link.linked && link.targetMatches);
+  return {
+    mode: allLinked ? "local-workspace" : "git-dev",
+    enabled,
+    root,
+    links: inspected,
+    created: [],
+    removed: [],
+    issues: [
+      ...inspected.filter((link) => link.exists && (!link.linked || !link.targetMatches)).map((link) => `${link.linkPath} is not linked to ${link.targetPath}.`),
+      ...lockIssues
+    ]
+  };
+}
+export {
+  assertNoWorkspaceLinksInDeploymentLockfiles,
+  collectDeploymentLockfileWorkspaceIssues,
+  discoverWorkspaceLinks,
+  ensureLocalWorkspaceLinks,
+  inspectWorkspaceDependencyMode,
+  unlinkLocalWorkspaceLinks
+};

package/dist/operations/services/workspace-preflight.js

@@ -3,6 +3,7 @@ import { spawnSync } from "node:child_process";
 import { dirname, resolve } from "node:path";
 import { collectTreeseedConfigSeedValues } from "./config-runtime.js";
 import { createTempDir } from "./workspace-tools.js";
+import { resolveTreeseedToolBinary } from "../../managed-dependencies.js";
 function runCapture(command, args, options = {}) {
   const result = spawnSync(command, args, {
     cwd: options.cwd ?? process.cwd(),
@@ -20,6 +21,10 @@ function runCapture(command, args, options = {}) {
   };
 }
 function locateBinary(candidate) {
+  const managed = resolveTreeseedToolBinary(candidate);
+  if (managed) {
+    return managed;
+  }
   const result = runCapture("bash", ["-lc", `command -v ${candidate}`]);
   return result.status === 0 ? result.stdout.trim() : null;
 }

package/dist/operations/services/workspace-save.js

@@ -3,14 +3,15 @@ import { resolve } from "node:path";
 import { changedWorkspacePackages, publishableWorkspacePackages, run, sortWorkspacePackages, workspacePackages, workspaceRoot } from "./workspace-tools.js";
 const MERGE_CONFLICT_EXIT_CODE = 12;
 function parseSemver(version) {
-  const match = String(version).trim().match(/^(\d+)\.(\d+)\.(\d+)$/);
+  const match = String(version).trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-[0-9A-Za-z.-]+)?$/);
   if (!match) {
     throw new Error(`Unsupported version "${version}". Expected x.y.z.`);
   }
   return {
     major: Number(match[1]),
     minor: Number(match[2]),
-    patch: Number(match[3])
+    patch: Number(match[3]),
+    prerelease: String(version).includes("-")
   };
 }
 function incrementPatchVersion(version) {
@@ -26,6 +27,9 @@ function incrementVersion(version, level = "patch") {
     return `${parsed.major}.${parsed.minor + 1}.0`;
   }
   if (level === "patch") {
+    if (parsed.prerelease) {
+      return `${parsed.major}.${parsed.minor}.${parsed.patch}`;
+    }
     return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
   }
   throw new Error(`Unsupported release bump "${level}". Expected major, minor, or patch.`);
@@ -71,7 +75,7 @@ function planWorkspaceVersionChanges(root = workspaceRoot()) {
           if (!versions.has(depName)) {
             continue;
           }
-          const nextSpec = `^${versions.get(depName)}`;
+          const nextSpec = `${versions.get(depName)}`;
           if (pkg.packageJson[field][depName] === nextSpec) {
             continue;
           }
@@ -143,7 +147,7 @@ function planWorkspaceReleaseBump(level = "patch", root = workspaceRoot(), optio
         if (!versions.has(depName)) {
           continue;
         }
-        pkg.packageJson[field][depName] = `^${versions.get(depName)}`;
+        pkg.packageJson[field][depName] = `${versions.get(depName)}`;
         touched.add(pkg.name);
       }
     }
@@ -169,7 +173,7 @@ function collectWorkspaceVersionConsistencyIssues(root = workspaceRoot()) {
         if (!versions.has(depName)) {
           continue;
         }
-        const expectedSpec = `^${versions.get(depName)}`;
+        const expectedSpec = `${versions.get(depName)}`;
         if (currentSpec !== expectedSpec) {
           issues.push({
             packageName: pkg.name,
@@ -246,7 +250,7 @@ function collectMergeConflictReport(repoDir) {
 }
 function formatMergeConflictReport(report, repoDir, targetBranch = "main") {
   const lines = [
-    `Treeseed save failed due to merge conflicts during \`git pull --rebase origin ${targetBranch}\`.`,
+    `Treeseed save failed due to merge conflicts during \`git pull --rebase --recurse-submodules=no origin ${targetBranch}\`.`,
     `Repository root: ${repoDir}`,
     `Branch: ${report.branch}`,
     `Rebase in progress: ${report.rebaseInProgress ? "yes" : "no"}`,

package/dist/operations-registry.js

@@ -1,6 +1,7 @@
 function operation(spec) {
   return spec;
 }
+const workspaceCommand = (name) => `workspace${":"}${name}`;
 const TRESEED_OPERATION_SPECS = [
   operation({ id: "workspace.status", name: "status", aliases: [], group: "Workflow", summary: "Show Treeseed project health and the current task state.", description: "Report branch/task state, runtime readiness, preview/deploy state, auth readiness, and recommended next operations.", provider: "default", related: ["tasks", "switch", "config"] }),
   operation({ id: "branch.tasks", name: "tasks", aliases: [], group: "Workflow", summary: "List task branches plus package branch alignment.", description: "List task branches from market and checked-out package repos, including preview metadata and branch/pointer alignment state.", provider: "default", related: ["status", "switch", "close"] }),
@@ -10,8 +11,12 @@ const TRESEED_OPERATION_SPECS = [
   operation({ id: "branch.stage", name: "stage", aliases: [], group: "Workflow", summary: "Squash a task branch into staging across market and packages.", description: "Auto-save if needed, squash-merge package task branches into staging first, update market submodule pointers, then squash-merge market into staging and clean up the task branch.", provider: "default", related: ["save", "release", "close"] }),
   operation({ id: "workspace.resume", name: "resume", aliases: [], group: "Workflow", summary: "Resume an interrupted workflow run.", description: "Continue a failed journaled workflow run from its next incomplete step after validating current workspace preconditions.", provider: "default", related: ["recover", "status"] }),
   operation({ id: "workspace.recover", name: "recover", aliases: [], group: "Workflow", summary: "Inspect active workflow locks and interrupted runs.", description: "List active workflow locks, resumable interrupted runs, and the exact commands needed to continue or recover the workspace state.", provider: "default", related: ["resume", "status"] }),
+  operation({ id: "workspace.links.status", name: workspaceCommand("status"), aliases: [], group: "Utilities", summary: "Inspect local workspace dependency links.", description: "Inspect whether Treeseed package dependencies are linked to local package checkouts or resolved through deployment references.", provider: "default", related: ["dev", "save"] }),
+  operation({ id: "workspace.links.link", name: workspaceCommand("link"), aliases: [], group: "Utilities", summary: "Link local Treeseed workspace packages.", description: "Create local node_modules links from internal Treeseed dependencies to checked-out package repositories for integrated development.", provider: "default", related: ["dev", workspaceCommand("status")] }),
+  operation({ id: "workspace.links.unlink", name: workspaceCommand("unlink"), aliases: [], group: "Utilities", summary: "Remove managed local workspace package links.", description: "Remove Treeseed-managed local workspace links before deployment-style installs or lockfile repair.", provider: "default", related: ["save", workspaceCommand("status")] }),
   operation({ id: "deploy.rollback", name: "rollback", aliases: [], group: "Workflow", summary: "Roll back staging or production to a recorded deployment.", description: "Redeploy a previously recorded staging or production commit using a temporary checkout of that revision.", provider: "default", related: ["status", "release"] }),
   operation({ id: "workspace.doctor", name: "doctor", aliases: [], group: "Validation", summary: "Diagnose Treeseed tooling, auth, and workflow readiness.", description: "Collect doctor-style diagnostics for workspace readiness and optional safe repairs.", provider: "default", related: ["status", "config"] }),
+  operation({ id: "workspace.install", name: "install", aliases: [], group: "Utilities", summary: "Install Treeseed-managed local dependencies.", description: "Install or repair Treeseed-managed CLI dependencies including GitHub CLI, Wrangler, Railway, Copilot, and optional gh-act support.", provider: "default", related: ["config", "doctor"] }),
   operation({ id: "auth.login", name: "auth:login", aliases: [], group: "Validation", summary: "Authenticate against the configured Treeseed API.", description: "Start the device login flow against the active Treeseed API host and persist the returned session locally.", provider: "default", related: ["auth:check", "auth:whoami", "auth:logout"] }),
   operation({ id: "auth.logout", name: "auth:logout", aliases: [], group: "Validation", summary: "Clear locally stored Treeseed API credentials.", description: "Remove the persisted local device-flow session for the active Treeseed API host.", provider: "default", related: ["auth:login", "auth:whoami"] }),
   operation({ id: "auth.whoami", name: "auth:whoami", aliases: [], group: "Validation", summary: "Inspect the active Treeseed API identity.", description: "Use the persisted local remote session to query the active Treeseed API principal.", provider: "default", related: ["auth:login", "status"] }),

package/dist/operations-types.d.ts

@@ -28,6 +28,7 @@ export type TreeseedOperationResult<TPayload = Record<string, unknown>> = {
     exitCode?: number;
     stdout?: string[];
     stderr?: string[];
+    report?: Record<string, unknown> | null;
 };
 export type TreeseedOperationWriter = (output: string, stream?: 'stdout' | 'stderr') => void;
 export type TreeseedOperationPrompt = (message: string) => Promise<string> | string;

package/dist/platform/books-data.js

@@ -1,4 +1,4 @@
-import { readFileSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
 import { parse as parseYaml } from "yaml";
 import { getTenantContentRoot } from "./tenant-config.js";
@@ -26,6 +26,9 @@ function sortPaths(paths) {
   return [...paths].sort((left, right) => left.localeCompare(right, void 0, { numeric: true, sensitivity: "base" }));
 }
 function collectMarkdownFiles(rootPath) {
+  if (!existsSync(rootPath)) {
+    return [];
+  }
   const stats = statSync(rootPath);
   if (stats.isFile()) {
     return [rootPath];

package/dist/platform/env.yaml

@@ -90,13 +90,14 @@ entries:
   CLOUDFLARE_API_TOKEN:
     label: Cloudflare API token
     group: auth
-    description: Account-level Cloudflare API token used by Wrangler and CI to manage Pages, Workers, Workers KV, D1, Queues, DNS, secrets, and deploys.
-    howToGet: "Create a Cloudflare account-level API token scoped to the target domain and account. Required permissions: Account Cloudflare Pages edit, Account Workers Scripts edit, Account Workers KV Storage edit, Account D1 edit, Account Queues edit, Zone DNS edit. Then paste it here as CLOUDFLARE_API_TOKEN."
+    description: Account-level Cloudflare API token used by Wrangler, Workers AI, and CI to manage Pages, Workers, Workers KV, D1, Queues, DNS, secrets, and deploys.
+    howToGet: "Create a Cloudflare account-level API token scoped to the target domain and account. Required permissions: Account Cloudflare Pages edit, Account Workers Scripts edit, Account Workers KV Storage edit, Account D1 edit, Account Queues edit, Zone DNS edit, Workers AI Read, and Workers AI Edit for model execution. If TREESEED_COMMIT_AI_GATEWAY_ID is configured, also grant AI Gateway Read/Run access for the gateway. Then paste it here as CLOUDFLARE_API_TOKEN."
     sensitivity: secret
     targets:
       - local-runtime
       - github-secret
     scopes:
+      - local
       - staging
       - prod
     storage: shared
@@ -167,14 +168,16 @@ entries:
   CLOUDFLARE_ACCOUNT_ID:
     label: Cloudflare account ID
     group: cloudflare
-    description: Identifies the Cloudflare account Treeseed should provision and deploy into.
+    description: Identifies the Cloudflare account Treeseed should provision, deploy into, and use for Workers AI commit message generation.
     howToGet: In the Cloudflare dashboard, open Workers & Pages or Account Home and copy the account ID.
     startupProfile: core
     sensitivity: plain
     targets:
+      - local-runtime
       - github-variable
       - config-file
     scopes:
+      - local
       - staging
       - prod
     storage: shared