@treeseed/sdk 0.10.28 → 0.12.4

package/dist/operations/services/verification-cache.d.ts

@@ -0,0 +1,25 @@
+export interface TreeseedVerificationCacheEntry {
+    key: string;
+    repoName: string;
+    repoPath: string;
+    headSha: string;
+    command: string;
+    status: 'passed' | 'failed';
+    createdAt: string;
+    durationMs: number;
+    logsPath?: string | null;
+}
+export interface TreeseedVerificationCacheInput {
+    workspaceRoot: string;
+    repoName: string;
+    repoPath: string;
+    command: string;
+    verifyMode: string;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+}
+export declare function treeseedVerificationCacheKey(input: TreeseedVerificationCacheInput): {
+    key: string;
+    headSha: string;
+};
+export declare function readTreeseedVerificationCache(input: TreeseedVerificationCacheInput): TreeseedVerificationCacheEntry | null;
+export declare function writeTreeseedVerificationCache(input: TreeseedVerificationCacheInput, durationMs: number): TreeseedVerificationCacheEntry | null;

package/dist/operations/services/verification-cache.js

@@ -0,0 +1,71 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { headCommit } from "./git-workflow.js";
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function fileHash(path) {
+  if (!existsSync(path)) return null;
+  return sha256(readFileSync(path));
+}
+function cacheEnabled(env = process.env) {
+  const value = String(env.TREESEED_VERIFY_CACHE ?? "").trim().toLowerCase();
+  if (value === "0" || value === "false" || value === "off") return false;
+  if (env.GITHUB_ACTIONS === "true") return value === "1" || value === "true" || value === "on";
+  return true;
+}
+function treeseedVerificationCacheKey(input) {
+  const headSha = headCommit(input.repoPath);
+  const payload = {
+    repoPath: resolve(input.repoPath),
+    headSha,
+    packageJson: fileHash(resolve(input.repoPath, "package.json")),
+    packageLock: fileHash(resolve(input.repoPath, "package-lock.json")),
+    command: input.command,
+    nodeMajor: process.versions.node.split(".")[0],
+    verifyMode: input.verifyMode
+  };
+  return { key: sha256(JSON.stringify(payload)), headSha };
+}
+function cachePath(input, key) {
+  return resolve(input.workspaceRoot, ".treeseed", "cache", "verification", `${key}.json`);
+}
+function readTreeseedVerificationCache(input) {
+  if (!cacheEnabled(input.env)) return null;
+  const { key, headSha } = treeseedVerificationCacheKey(input);
+  const path = cachePath(input, key);
+  if (!existsSync(path)) return null;
+  try {
+    const entry = JSON.parse(readFileSync(path, "utf8"));
+    if (entry.key !== key || entry.headSha !== headSha || entry.status !== "passed") return null;
+    return entry;
+  } catch {
+    return null;
+  }
+}
+function writeTreeseedVerificationCache(input, durationMs) {
+  if (!cacheEnabled(input.env)) return null;
+  const { key, headSha } = treeseedVerificationCacheKey(input);
+  const path = cachePath(input, key);
+  const entry = {
+    key,
+    repoName: input.repoName,
+    repoPath: resolve(input.repoPath),
+    headSha,
+    command: input.command,
+    status: "passed",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    durationMs,
+    logsPath: null
+  };
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(entry, null, 2)}
+`, "utf8");
+  return entry;
+}
+export {
+  readTreeseedVerificationCache,
+  treeseedVerificationCacheKey,
+  writeTreeseedVerificationCache
+};

package/dist/operations/services/workflow-timing.d.ts

@@ -0,0 +1,25 @@
+export type TreeseedWorkflowPhaseStatus = 'passed' | 'failed' | 'skipped';
+export type TreeseedWorkflowTimingPhase = {
+    id: string;
+    label: string;
+    startedAt: string;
+    finishedAt: string;
+    durationMs: number;
+    status: TreeseedWorkflowPhaseStatus;
+};
+export type TreeseedWorkflowTiming = {
+    startedAt: string;
+    finishedAt: string;
+    durationMs: number;
+    phases: TreeseedWorkflowTimingPhase[];
+};
+export type TreeseedWorkflowTimer = {
+    readonly startedAt: string;
+    phase<T>(id: string, label: string, action: () => T): T;
+    phaseAsync<T>(id: string, label: string, action: () => Promise<T>): Promise<T>;
+    skip(id: string, label: string): void;
+    finish(): TreeseedWorkflowTiming;
+};
+export declare function createTreeseedWorkflowTimer(startedAt?: string): TreeseedWorkflowTimer;
+export declare function formatTreeseedDuration(durationMs: number): string;
+export declare function slowestTreeseedWorkflowPhases(timing: TreeseedWorkflowTiming, limit?: number): TreeseedWorkflowTimingPhase[];

package/dist/operations/services/workflow-timing.js

@@ -0,0 +1,79 @@
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function durationSince(startMs) {
+  return Math.max(0, Date.now() - startMs);
+}
+function createTreeseedWorkflowTimer(startedAt = nowIso()) {
+  const startMs = Date.parse(startedAt);
+  const phases = [];
+  function record(id, label, started, startedMs, status) {
+    const finishedAt = nowIso();
+    phases.push({
+      id,
+      label,
+      startedAt: started,
+      finishedAt,
+      durationMs: durationSince(startedMs),
+      status
+    });
+  }
+  return {
+    startedAt,
+    phase(id, label, action) {
+      const phaseStartedAt = nowIso();
+      const phaseStartedMs = Date.now();
+      try {
+        const result = action();
+        record(id, label, phaseStartedAt, phaseStartedMs, "passed");
+        return result;
+      } catch (error) {
+        record(id, label, phaseStartedAt, phaseStartedMs, "failed");
+        throw error;
+      }
+    },
+    async phaseAsync(id, label, action) {
+      const phaseStartedAt = nowIso();
+      const phaseStartedMs = Date.now();
+      try {
+        const result = await action();
+        record(id, label, phaseStartedAt, phaseStartedMs, "passed");
+        return result;
+      } catch (error) {
+        record(id, label, phaseStartedAt, phaseStartedMs, "failed");
+        throw error;
+      }
+    },
+    skip(id, label) {
+      const phaseStartedAt = nowIso();
+      record(id, label, phaseStartedAt, Date.now(), "skipped");
+    },
+    finish() {
+      const finishedAt = nowIso();
+      return {
+        startedAt,
+        finishedAt,
+        durationMs: Math.max(0, Date.parse(finishedAt) - startMs),
+        phases: [...phases]
+      };
+    }
+  };
+}
+function formatTreeseedDuration(durationMs) {
+  const totalSeconds = Math.max(0, Math.round(durationMs / 1e3));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes < 60) return seconds === 0 ? `${minutes}m` : `${minutes}m${seconds}s`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return remainingMinutes === 0 ? `${hours}h` : `${hours}h${remainingMinutes}m`;
+}
+function slowestTreeseedWorkflowPhases(timing, limit = 5) {
+  return [...timing.phases].sort((left, right) => right.durationMs - left.durationMs).slice(0, Math.max(0, limit));
+}
+export {
+  createTreeseedWorkflowTimer,
+  formatTreeseedDuration,
+  slowestTreeseedWorkflowPhases
+};

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

@@ -1,6 +1,6 @@
 import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, relative, resolve } from "node:path";
-import { spawnSync } from "node:child_process";
+import { runTreeseedGit } from "./git-runner.js";
 import { workspacePackages, workspaceRoot } from "./workspace-tools.js";
 const METADATA_VERSION = 1;
 const INTERNAL_DEPENDENCY_FIELDS = ["dependencies", "optionalDependencies", "peerDependencies", "devDependencies"];
@@ -65,10 +65,10 @@ function writeMetadata(root, links) {
 `, "utf8");
 }
 function gitInfoExcludePath(repoPath) {
-  const result = spawnSync("git", ["rev-parse", "--git-common-dir"], {
+  const result = runTreeseedGit(["rev-parse", "--git-common-dir"], {
     cwd: repoPath,
-    stdio: "pipe",
-    encoding: "utf8"
+    mode: "read",
+    allowFailure: true
   });
   if (result.status !== 0) return null;
   const gitDir = result.stdout.trim();
@@ -128,6 +128,14 @@ function dependencySpec(packageJson, field, packageName) {
   const value = deps[packageName];
   return typeof value === "string" ? value : null;
 }
+function dependencySpecsMatch(manifestSpec, lockSpec) {
+  if (lockSpec === manifestSpec) return true;
+  const manifestVersion = manifestSpec.replace(/^[~^]/u, "");
+  const lockRef = lockSpec.includes("#") ? lockSpec.slice(lockSpec.lastIndexOf("#") + 1) : null;
+  return Boolean(
+    lockRef && manifestVersion.includes("-dev.") && lockRef === manifestVersion && /^(?:github:|git\+https:\/\/github\.com\/|git\+ssh:\/\/git@github\.com[:/])/u.test(lockSpec)
+  );
+}
 function normalizedPathValue(value) {
   return value.replaceAll("\\", "/").replace(/^\.\//u, "").replace(/\/$/u, "");
 }
@@ -175,7 +183,7 @@ function collectPackageLockConsistencyIssues(filePath, packageJson, packages, wo
       const manifestSpec = dependencySpec(packageJson, field, packageName);
       if (!manifestSpec) continue;
       const lockSpec = dependencySpec(rootLockEntry ?? {}, field, packageName);
-      if (lockSpec !== manifestSpec) {
+      if (!lockSpec || !dependencySpecsMatch(manifestSpec, lockSpec)) {
         issues.push({
           filePath,
           packageName,
@@ -260,6 +268,40 @@ function createLink(link) {
   const relativeTarget = relative(dirname(link.linkPath), link.targetPath) || ".";
   symlinkSync(relativeTarget, link.linkPath, process.platform === "win32" ? "junction" : "dir");
 }
+function packageBinEntries(packageJson) {
+  const bin = packageJson.bin;
+  if (typeof bin === "string" && typeof packageJson.name === "string") {
+    return [[packageDirName(packageJson.name), bin]];
+  }
+  if (!bin || typeof bin !== "object" || Array.isArray(bin)) return [];
+  return Object.entries(bin).filter((entry) => typeof entry[1] === "string");
+}
+function syncPackageBinLinks(link) {
+  const packageJson = readJson(resolve(link.targetPath, "package.json"));
+  const binEntries = packageBinEntries(packageJson);
+  if (binEntries.length === 0) return [];
+  const binDir = resolve(link.ownerPath, "node_modules", ".bin");
+  mkdirSync(binDir, { recursive: true });
+  const created = [];
+  for (const [binName, binTarget] of binEntries) {
+    const linkPath = resolve(binDir, binName);
+    const targetPath = resolve(link.linkPath, binTarget);
+    const relativeTarget = relative(dirname(linkPath), targetPath) || targetPath;
+    const stat = safeLstat(linkPath);
+    if (stat?.isSymbolicLink()) {
+      const currentTarget = readlinkSync(linkPath);
+      if (currentTarget === relativeTarget || resolve(dirname(linkPath), currentTarget) === targetPath) {
+        continue;
+      }
+      unlinkSync(linkPath);
+    } else if (stat) {
+      continue;
+    }
+    symlinkSync(relativeTarget, linkPath);
+    created.push(linkPath);
+  }
+  return created;
+}
 function ensureLocalWorkspaceLinks(root = workspaceRoot(), options = {}) {
   const enabled = workspaceLinksEnabled(options.mode, options.env);
   const links = discoverWorkspaceLinks(root);
@@ -276,6 +318,9 @@ function ensureLocalWorkspaceLinks(root = workspaceRoot(), options = {}) {
     createLink(link);
     created.push(link.linkPath);
   }
+  for (const link of links) {
+    created.push(...syncPackageBinLinks(link));
+  }
   writeMetadata(root, links);
   return {
     ...inspectWorkspaceDependencyMode(root, { mode: options.mode, env: options.env }),

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

@@ -51,27 +51,27 @@ function envTokenStatus(keys, label, values = process.env) {
 }
 function parseGitHubAuthStatus(values = process.env) {
   return {
-    authenticated: envTokenStatus(["GH_TOKEN"], "GitHub", values).ready,
-    detail: envTokenStatus(["GH_TOKEN"], "GitHub", values).detail
+    authenticated: envTokenStatus(["TREESEED_GITHUB_TOKEN"], "GitHub", values).ready,
+    detail: envTokenStatus(["TREESEED_GITHUB_TOKEN"], "GitHub", values).detail
   };
 }
 function parseWranglerWhoAmI(values = process.env) {
   return {
-    authenticated: envTokenStatus(["CLOUDFLARE_API_TOKEN"], "Cloudflare", values).ready,
-    detail: envTokenStatus(["CLOUDFLARE_API_TOKEN"], "Cloudflare", values).detail
+    authenticated: envTokenStatus(["TREESEED_CLOUDFLARE_API_TOKEN"], "Cloudflare", values).ready,
+    detail: envTokenStatus(["TREESEED_CLOUDFLARE_API_TOKEN"], "Cloudflare", values).detail
   };
 }
 function parseRailwayWhoAmI(values = process.env) {
   return {
-    authenticated: envTokenStatus(["RAILWAY_API_TOKEN"], "Railway", values).ready,
-    detail: envTokenStatus(["RAILWAY_API_TOKEN"], "Railway", values).detail
+    authenticated: envTokenStatus(["TREESEED_RAILWAY_API_TOKEN"], "Railway", values).ready,
+    detail: envTokenStatus(["TREESEED_RAILWAY_API_TOKEN"], "Railway", values).detail
   };
 }
 function parseCopilotSessionStatus(values = process.env) {
-  const status = envTokenStatus(["GH_TOKEN"], "GitHub", values);
+  const status = envTokenStatus(["TREESEED_GITHUB_COPILOT_TOKEN", "TREESEED_GITHUB_TOKEN"], "GitHub Copilot", values);
   return {
     configured: status.ready,
-    detail: status.ready ? "GitHub token detected from configured Treeseed environment for Copilot-backed workflows." : "GitHub token is not configured. Set GH_TOKEN for Copilot-backed workflows."
+    detail: status.ready ? "GitHub Copilot token detected from configured Treeseed environment for Copilot-backed workflows." : "GitHub Copilot token is not configured. Set TREESEED_GITHUB_COPILOT_TOKEN for Copilot-backed workflows. TREESEED_GITHUB_TOKEN is accepted as a compatibility fallback."
   };
 }
 function collectCliPreflight({ cwd = process.cwd(), requireAuth = false } = {}) {

package/dist/operations/services/workspace-save-script.d.ts

@@ -1,4 +1,4 @@
-import type { TreeseedWorkflowResult } from '../../workflow.ts';
+import type { TreeseedWorkflowResult } from '../../workflow.js';
 export type SaveScriptArgs = {
     hotfix: boolean;
     message: string;
@@ -7,12 +7,12 @@ export declare function parseWorkspaceSaveScriptArgs(argv: string[]): SaveScript
 export declare function formatWorkspaceSaveSuccessReport(result: TreeseedWorkflowResult<Record<string, unknown>>): {
     ok: boolean;
     kind: string;
-    operation: import("../../workflow.ts").TreeseedWorkflowOperationId;
+    operation: import("../../workflow.js").TreeseedWorkflowOperationId;
 };
 export declare function formatWorkspaceSaveFailureReport(error: unknown): {
     ok: boolean;
-    kind: import("../../workflow.ts").TreeseedWorkflowErrorCode;
-    operation: import("../../workflow.ts").TreeseedWorkflowOperationId;
+    kind: import("../../workflow.js").TreeseedWorkflowErrorCode;
+    operation: import("../../workflow.js").TreeseedWorkflowOperationId;
     message: string;
     details: Record<string, unknown> | null;
     exitCode: number;

package/dist/operations/services/workspace-save.d.ts

@@ -59,6 +59,7 @@ export declare function countConflictMarkers(source: any): {
 };
 export declare function collectMergeConflictReport(repoDir: any): {
     branch: string;
+    mergeInProgress: boolean;
     rebaseInProgress: boolean;
     conflictedFiles: string[];
     status: string;

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

@@ -1,8 +1,17 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { changedWorkspacePackages, publishableWorkspacePackages, run, sortWorkspacePackages, workspacePackages, workspaceRoot } from "./workspace-tools.js";
+import { existsSync, lstatSync, readFileSync, writeFileSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { changedWorkspacePackages, publishableWorkspacePackages, sortWorkspacePackages, workspacePackages, workspaceRoot } from "./workspace-tools.js";
+import { classifyTreeseedGitMode, runTreeseedGitText } from "./git-runner.js";
+function runGit(args, options) {
+  return runTreeseedGitText(args, {
+    cwd: options.cwd,
+    mode: classifyTreeseedGitMode(args),
+    timeoutMs: options.timeoutMs,
+    maxBuffer: options.maxBuffer
+  });
+}
 const MERGE_CONFLICT_EXIT_CODE = 12;
-const TREESEED_PUBLIC_RELEASE_PACKAGE_NAMES = ["@treeseed/sdk", "@treeseed/core", "@treeseed/cli", "@treeseed/agent"];
+const TREESEED_PUBLIC_RELEASE_PACKAGE_NAMES = ["@treeseed/sdk", "@treeseed/ui", "@treeseed/core", "@treeseed/admin", "@treeseed/cli", "@treeseed/agent"];
 function parseSemver(version) {
   const match = String(version).trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-[0-9A-Za-z.-]+)?$/);
   if (!match) {
@@ -60,7 +69,7 @@ function versionForLine(line, patch = 0) {
 }
 function localGitTagExists(repoDir, tagName) {
   try {
-    return run("git", ["tag", "--list", tagName], { cwd: repoDir, capture: true }).trim() === tagName;
+    return runGit(["tag", "--list", tagName], { cwd: repoDir, capture: true }).trim() === tagName;
   } catch {
     return false;
   }
@@ -68,7 +77,7 @@ function localGitTagExists(repoDir, tagName) {
 function highestStableGitTagOnLine(repoDir, lineLabel) {
   const line = parseVersionLine(lineLabel);
   try {
-    const tags = run("git", ["tag", "--list", `${line.label}.*`], { cwd: repoDir, capture: true }).split(/\r?\n/u).map((tag) => tag.trim()).filter(Boolean).map((tag) => {
+    const tags = runGit(["tag", "--list", `${line.label}.*`], { cwd: repoDir, capture: true }).split(/\r?\n/u).map((tag) => tag.trim()).filter(Boolean).map((tag) => {
       try {
         const parsed = parseSemver(tag);
         if (parsed.prerelease || parsed.major !== line.major || parsed.minor !== line.minor) return null;
@@ -340,16 +349,16 @@ function assertWorkspaceVersionConsistency(root = workspaceRoot()) {
   );
 }
 function repoRoot(cwd = workspaceRoot()) {
-  return run("git", ["rev-parse", "--show-toplevel"], { cwd, capture: true }).trim();
+  return runGit(["rev-parse", "--show-toplevel"], { cwd, capture: true }).trim();
 }
 function currentBranch(repoDir) {
-  return run("git", ["branch", "--show-current"], { cwd: repoDir, capture: true }).trim();
+  return runGit(["branch", "--show-current"], { cwd: repoDir, capture: true }).trim();
 }
 function originRemoteUrl(repoDir) {
-  return run("git", ["remote", "get-url", "origin"], { cwd: repoDir, capture: true }).trim();
+  return runGit(["remote", "get-url", "origin"], { cwd: repoDir, capture: true }).trim();
 }
 function gitStatusPorcelain(repoDir) {
-  return run("git", ["status", "--porcelain"], { cwd: repoDir, capture: true }).trim();
+  return runGit(["status", "--porcelain"], { cwd: repoDir, capture: true }).trim();
 }
 function hasMeaningfulChanges(repoDir) {
   return gitStatusPorcelain(repoDir).length > 0;
@@ -361,25 +370,38 @@ function countConflictMarkers(source) {
     end: (source.match(/^>{7} /gm) ?? []).length
   };
 }
+function gitPathExists(repoDir, gitPath) {
+  try {
+    const resolved = runGit(["rev-parse", "--git-path", gitPath], {
+      cwd: repoDir,
+      capture: true
+    }).trim();
+    const fullPath = resolved && (isAbsolute(resolved) ? resolved : resolve(repoDir, resolved));
+    return Boolean(fullPath) && existsSync(fullPath);
+  } catch {
+    return false;
+  }
+}
 function collectMergeConflictReport(repoDir) {
   const branch = currentBranch(repoDir);
-  const conflictedFiles = run("git", ["diff", "--name-only", "--diff-filter=U"], {
+  const conflictedFiles = runGit(["diff", "--name-only", "--diff-filter=U"], {
     cwd: repoDir,
     capture: true
   }).split("\n").map((line) => line.trim()).filter(Boolean);
-  const status = run("git", ["status", "--short"], { cwd: repoDir, capture: true });
+  const status = runGit(["status", "--short"], { cwd: repoDir, capture: true });
   const perFile = conflictedFiles.map((filePath) => {
     const fullPath = resolve(repoDir, filePath);
-    const source = existsSync(fullPath) ? readFileSync(fullPath, "utf8") : "";
+    const source = existsSync(fullPath) && !lstatSync(fullPath).isDirectory() ? readFileSync(fullPath, "utf8") : "";
     return {
       filePath,
       markers: countConflictMarkers(source),
-      diff: run("git", ["diff", "--", filePath], { cwd: repoDir, capture: true })
+      diff: runGit(["diff", "--", filePath], { cwd: repoDir, capture: true })
     };
   });
   return {
     branch,
-    rebaseInProgress: true,
+    mergeInProgress: gitPathExists(repoDir, "MERGE_HEAD"),
+    rebaseInProgress: gitPathExists(repoDir, "rebase-merge") || gitPathExists(repoDir, "rebase-apply"),
     conflictedFiles,
     status,
     perFile
@@ -387,9 +409,10 @@ function collectMergeConflictReport(repoDir) {
 }
 function formatMergeConflictReport(report, repoDir, targetBranch = "main") {
   const lines = [
-    `Treeseed save failed due to merge conflicts during \`git pull --rebase --recurse-submodules=no origin ${targetBranch}\`.`,
+    `Treeseed workflow failed due to Git integration conflicts while updating ${targetBranch}.`,
     `Repository root: ${repoDir}`,
     `Branch: ${report.branch}`,
+    `Merge in progress: ${report.mergeInProgress ? "yes" : "no"}`,
     `Rebase in progress: ${report.rebaseInProgress ? "yes" : "no"}`,
     "Git status:",
     report.status || "(no git status output)",
@@ -402,9 +425,9 @@ function formatMergeConflictReport(report, repoDir, targetBranch = "main") {
     lines.push(file.diff || "  (no diff output)");
   }
   lines.push("Next steps:");
-  lines.push("- Inspect conflicted files and reconcile local vs remote changes.");
-  lines.push("- After resolving files, run `git add <files>` and `git rebase --continue`.");
-  lines.push("- Or abort with `git rebase --abort` if you need to restart the save flow.");
+  lines.push("- Inspect conflicted files and reconcile local vs target-branch changes on your task branch.");
+  lines.push("- Save the resolved task branch, then retry the interrupted Treeseed workflow.");
+  lines.push("- If a Git merge or rebase is still active, abort it before retrying.");
   return lines.join("\n");
 }
 export {

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

@@ -1,7 +1,8 @@
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
 import { spawnSync } from "node:child_process";
+import { classifyTreeseedGitMode, runTreeseedGit, runTreeseedGitText } from "./git-runner.js";
 import { join, relative, resolve } from "node:path";
-const TREESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "core", "cli", "agent"];
+const TREESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "ui", "core", "admin", "cli", "agent", "api", "treedx"];
 function packageSortWeight(pkg) {
   const relativeDir = String(pkg.relativeDir ?? "");
   const dirName = relativeDir.split("/").pop() ?? "";
@@ -19,6 +20,14 @@ function compareWorkspacePackages(left, right) {
 function escapeRegex(source) {
   return source.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
 }
+function runGit(args, options) {
+  return runTreeseedGitText(args, {
+    cwd: options.cwd,
+    mode: classifyTreeseedGitMode(args),
+    timeoutMs: options.timeoutMs,
+    maxBuffer: options.maxBuffer
+  });
+}
 function segmentPatternToRegex(pattern) {
   return new RegExp(`^${escapeRegex(pattern).replaceAll("*", ".*")}$`);
 }
@@ -76,7 +85,10 @@ function isWorkspaceRoot(root = process.cwd()) {
   }
 }
 function hasCompleteTreeseedPackageCheckout(root = process.cwd()) {
-  return TREESEED_WORKSPACE_PACKAGE_DIRS.every((dirName) => existsSync(resolve(root, "packages", dirName, "package.json")));
+  return TREESEED_WORKSPACE_PACKAGE_DIRS.every((dirName) => {
+    const packageDir = resolve(root, "packages", dirName);
+    return existsSync(resolve(packageDir, "package.json")) || existsSync(resolve(packageDir, "treeseed.package.yaml"));
+  });
 }
 function findNearestTreeseedWorkspaceRoot(startCwd = process.cwd()) {
   const tenantRoot = findNearestTreeseedRoot(startCwd);
@@ -89,9 +101,15 @@ function readJson(filePath) {
   return JSON.parse(readFileSync(filePath, "utf8"));
 }
 function workspacePackageJson(root = workspaceRoot()) {
+  if (!existsSync(resolve(root, "package.json"))) {
+    return {};
+  }
   return readJson(resolve(root, "package.json"));
 }
 function workspacePatterns(root = workspaceRoot()) {
+  if (!existsSync(resolve(root, "package.json"))) {
+    return hasCompleteTreeseedPackageCheckout(root) ? ["packages/*"] : [];
+  }
   const packageJson = workspacePackageJson(root);
   const workspaces = Array.isArray(packageJson.workspaces) ? packageJson.workspaces : Array.isArray(packageJson.workspaces?.packages) ? packageJson.workspaces.packages : [];
   const patterns = workspaces.filter((value) => typeof value === "string" && value.trim().length > 0);
@@ -172,12 +190,29 @@ function packagesWithScript(scriptName, root = workspaceRoot()) {
   );
 }
 function run(command, args, options = {}) {
+  if (command === "git") {
+    const result2 = runTreeseedGit(args, {
+      cwd: options.cwd ?? workspaceRoot(),
+      mode: classifyTreeseedGitMode(args),
+      allowFailure: false,
+      timeoutMs: options.timeoutMs,
+      maxBuffer: options.maxBuffer
+    });
+    if (!options.capture && result2.stdout) {
+      process.stdout.write(result2.stdout);
+    }
+    if (!options.capture && result2.stderr) {
+      process.stderr.write(result2.stderr);
+    }
+    return (result2.stdout ?? "").trim();
+  }
   const result = spawnSync(command, args, {
     cwd: options.cwd ?? workspaceRoot(),
     env: { ...process.env, ...options.env ?? {} },
     stdio: options.capture ? "pipe" : "inherit",
     encoding: "utf8",
-    timeout: options.timeoutMs
+    timeout: options.timeoutMs,
+    maxBuffer: options.maxBuffer ?? 1024 * 1024 * 32
   });
   if (result.status !== 0) {
     const message = (result.error?.message ? `${result.error.message}
@@ -187,10 +222,10 @@ function run(command, args, options = {}) {
   return (result.stdout ?? "").trim();
 }
 function canResolveGitRef(baseRef, cwd = workspaceRoot()) {
-  const result = spawnSync("git", ["rev-parse", "--verify", baseRef], {
+  const result = runTreeseedGit(["rev-parse", "--verify", baseRef], {
     cwd,
-    stdio: "pipe",
-    encoding: "utf8"
+    mode: "read",
+    allowFailure: true
   });
   return result.status === 0;
 }
@@ -212,7 +247,7 @@ function changedWorkspaceFiles(baseRef, cwd = workspaceRoot()) {
     diffCommands.unshift(["diff", "--name-only", resolvedBaseRef, "HEAD"]);
   }
   for (const args of diffCommands) {
-    const output = run("git", args, { cwd, capture: true });
+    const output = runGit(args, { cwd, capture: true });
     for (const line of output.split("\n").map((entry) => entry.trim()).filter(Boolean)) {
       changedFiles.add(line);
     }

package/dist/operations-registry.d.ts

@@ -1,4 +1,4 @@
-import type { TreeseedOperationMetadata } from './operations-types.ts';
+import type { TreeseedOperationMetadata } from './operations-types.js';
 export declare const TRESEED_OPERATION_SPECS: TreeseedOperationMetadata[];
 export declare const TRESEED_OPERATION_INDEX: Map<string, TreeseedOperationMetadata>;
 export declare function findTreeseedOperation(name: string | null | undefined): TreeseedOperationMetadata | null;

package/dist/operations-registry.js

@@ -8,9 +8,11 @@ const TRESEED_OPERATION_SPECS = [
   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"] }),
   operation({ id: "branch.switch", name: "switch", aliases: [], group: "Workflow", summary: "Create or resume a recursive task branch.", description: "Create or resume the task branch in market and any checked-out package repos, with optional preview provisioning.", provider: "default", related: ["tasks", "dev", "save"] }),
   operation({ id: "branch.save", name: "save", aliases: [], group: "Workflow", summary: "Recursively verify, commit, and push the current task checkpoint.", description: "Save dirty package repos in dependency order, then verify, commit, push, and optionally refresh preview for market.", provider: "default", related: ["switch", "stage", "status"] }),
-  operation({ id: "branch.close", name: "close", aliases: [], group: "Workflow", summary: "Recursively archive and delete a task branch.", description: "Auto-save if needed, clean preview resources, create deprecated tags, and remove the task branch across market and checked-out package repos.", provider: "default", related: ["tasks", "switch", "stage"] }),
-  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.tags.cleanup", name: "tags:cleanup", aliases: [], group: "Utilities", summary: "Clean stale Treeseed-managed package dev tags.", description: "Plan or delete stale staging and preview package dev tags that are older than each package current version line while preserving active references and non-Treeseed tags.", provider: "default", related: ["release", "status"] }),
+  operation({ id: "branch.update", name: "update", aliases: [], group: "Workflow", summary: "Merge staging into the current task branch.", description: "Merge the selected upstream branch, staging by default, into the current task branch across market and checked-out package repos.", provider: "default", related: ["status", "save", "stage", "switch"] }),
+  operation({ id: "branch.close", name: "close", aliases: [], group: "Workflow", summary: "Recursively archive and delete a task branch.", description: "Auto-save if needed, clean preview resources, and remove the task branch across market and checked-out package repos.", provider: "default", related: ["tasks", "switch", "stage"] }),
+  operation({ id: "branch.stage", name: "stage", aliases: [], group: "Workflow", summary: "Promote a locally verified task branch to staging across market and packages.", description: "Merge staging down into the task branch first, run local proof, promote exact verified root and package refs to staging, verify remote staging refs, and clean up only after promotion succeeds.", provider: "default", related: ["save", "release", "close"] }),
+  operation({ id: "release.candidate", name: "release-candidate", aliases: [], group: "Validation", summary: "Plan and run reusable release proof records for staging promotion.", description: "Build the exact-SHA proof graph for package, hosted workflow, and provider verification. GitHub-hosted workflow proof is authoritative; local and action-simulation proof is reusable but not a hosted CI substitute.", provider: "default", related: ["stage", "release", "save"] }),
+  operation({ id: "release.proof", name: "proof", aliases: [], group: "Validation", summary: "Plan, run, and inspect reusable release proof records.", description: "Manage exact-SHA release proof records for packages, hosted workflows, and provider verification. GitHub-hosted workflow proof is authoritative; local action simulation is advisory.", provider: "default", related: ["save", "release-candidate", "ci"] }),
   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"] }),
@@ -68,9 +70,6 @@ const TRESEED_OPERATION_SPECS = [
   operation({ id: "release.verify", name: "test:release:full", aliases: ["release:verify"], group: "Release Utilities", summary: "Run the full release verification path.", description: "Run the full release verification path.", provider: "default" }),
   operation({ id: "release.publishChanged", name: "release:publish:changed", aliases: [], group: "Release Utilities", summary: "Publish changed Treeseed workspace packages.", description: "Publish changed Treeseed workspace packages.", provider: "default" }),
   operation({ id: "tools.astro", name: "astro", aliases: [], group: "Passthrough", summary: "Pass through to the packaged Astro CLI wrapper.", description: "Pass through to the packaged Astro CLI wrapper.", provider: "default" }),
-  operation({ id: "services.mailpitUp", name: "mailpit:up", aliases: [], group: "Utilities", summary: "Start the package-managed Mailpit service.", description: "Start the package-managed Mailpit service.", provider: "default" }),
-  operation({ id: "services.mailpitDown", name: "mailpit:down", aliases: [], group: "Utilities", summary: "Stop the package-managed Mailpit service.", description: "Stop the package-managed Mailpit service.", provider: "default" }),
-  operation({ id: "services.mailpitLogs", name: "mailpit:logs", aliases: [], group: "Utilities", summary: "Show Mailpit logs.", description: "Show Mailpit logs.", provider: "default" }),
   operation({ id: "data.d1MigrateLocal", name: "d1:migrate:local", aliases: [], group: "Utilities", summary: "Apply local D1 migrations.", description: "Apply local D1 migrations.", provider: "default" }),
   operation({ id: "content.cleanupMarkdown", name: "cleanup:markdown", aliases: [], group: "Utilities", summary: "Normalize Markdown and MDX files.", description: "Normalize Markdown and MDX files.", provider: "default" }),
   operation({ id: "content.cleanupMarkdownCheck", name: "cleanup:markdown:check", aliases: [], group: "Utilities", summary: "Check Markdown and MDX formatting without rewriting files.", description: "Check Markdown and MDX formatting without rewriting files.", provider: "default" }),