@treeseed/sdk 0.6.34 → 0.6.36

package/dist/operations/services/build-warning-policy.js

@@ -0,0 +1,85 @@
+export const DEFAULT_BUILD_WARNING_RULES = [
+	{
+		label: 'vite-browser-external-libsodium-url',
+		pattern: /Module "url" has been externalized for browser compatibility, imported by ".*libsodium-sumo.*"/u,
+	},
+];
+
+export function createBuildWarningRules(options = {}) {
+	const useDefaultPolicy = options.useDefaultPolicy !== false;
+	const customAllow = Array.isArray(options.allow) ? options.allow : [];
+	return [
+		...(useDefaultPolicy ? DEFAULT_BUILD_WARNING_RULES : []),
+		...customAllow.map((pattern) => ({
+			label: `custom:${pattern}`,
+			pattern: pattern instanceof RegExp ? pattern : new RegExp(String(pattern)),
+		})),
+	];
+}
+
+export function classifyBuildWarningLine(line, options = {}) {
+	const value = String(line ?? '');
+	if (!value.includes('[WARN]')) {
+		return { kind: 'not-warning' };
+	}
+	const allowed = createBuildWarningRules(options).find((rule) => rule.pattern.test(value));
+	if (allowed) {
+		return { kind: 'allowed', label: allowed.label };
+	}
+	return { kind: 'unexpected', line: value };
+}
+
+export function createBuildWarningSummary() {
+	const allowedWarnings = new Map();
+	const unexpectedWarnings = [];
+	return {
+		allowedWarnings,
+		unexpectedWarnings,
+		record(line, options = {}) {
+			const classified = classifyBuildWarningLine(line, options);
+			if (classified.kind === 'allowed') {
+				allowedWarnings.set(classified.label, (allowedWarnings.get(classified.label) ?? 0) + 1);
+				return classified;
+			}
+			if (classified.kind === 'unexpected') {
+				unexpectedWarnings.push(classified.line);
+			}
+			return classified;
+		},
+	};
+}
+
+export function mergeAllowedBuildWarnings(target, source) {
+	for (const [label, count] of source.entries()) {
+		target.set(label, (target.get(label) ?? 0) + count);
+	}
+	return target;
+}
+
+export function countAllowedBuildWarnings(allowedWarnings) {
+	return [...allowedWarnings.values()].reduce((sum, count) => sum + count, 0);
+}
+
+export function formatAllowedBuildWarnings(allowedWarnings) {
+	const total = countAllowedBuildWarnings(allowedWarnings);
+	if (total === 0) {
+		return [];
+	}
+	return [
+		`Allowed build warnings: ${total}`,
+		...[...allowedWarnings.entries()]
+			.sort(([left], [right]) => left.localeCompare(right))
+			.map(([label, count]) => `- ${label}: ${count}`),
+	];
+}
+
+export function scanBuildWarningText(text, options = {}) {
+	const summary = createBuildWarningSummary();
+	for (const line of String(text ?? '').split(/\r?\n/u)) {
+		summary.record(line, options);
+	}
+	return {
+		allowedWarnings: summary.allowedWarnings,
+		unexpectedWarnings: summary.unexpectedWarnings,
+	};
+}

package/dist/operations/services/github-actions-verification.d.ts

@@ -1,4 +1,4 @@
-import { type GitHubApiClient } from './github-api.ts';
+import { type GitHubApiClient, type GitHubWorkflowProgressEvent } from './github-api.ts';
 export type GitHubActionsWorkflowState = 'success' | 'failure' | 'pending' | 'missing' | 'not_pushed' | 'error';
 export type GitHubActionsVerificationTarget = {
     name: string;
@@ -118,6 +118,12 @@ export declare function skippedGitHubActionsGate(gate: GitHubActionsWorkflowGate
     updatedAt: null;
 };
 export declare function formatGitHubActionsGateFailure(gate: GitHubActionsWorkflowGate, result: Record<string, unknown>): string;
+export declare function createGitHubActionsGateProgressReporter(gate: GitHubActionsWorkflowGate, options?: {
+    operation?: string;
+    now?: () => number;
+    minRepeatMs?: number;
+    onProgress?: (message: string, stream?: 'stdout' | 'stderr') => void;
+}): (event: GitHubWorkflowProgressEvent) => void;
 export declare function waitForGitHubActionsGate(gate: GitHubActionsWorkflowGate, options?: {
     timeoutSeconds?: number;
     pollSeconds?: number;

package/dist/operations/services/github-actions-verification.js

@@ -433,13 +433,15 @@ function formatElapsed(seconds) {
 function shortSha(value) {
   return value ? value.slice(0, 12) : "(unknown)";
 }
-function activeJobSummary(event) {
+function activeJobSummaries(event) {
   const activeJobs = event.activeJobs ?? [];
-  if (activeJobs.length === 0) return "";
-  const summaries = activeJobs.slice(0, 2).map((job) => {
+  return activeJobs.slice(0, 2).map((job) => {
     const activeStep = (job.steps ?? []).find((step) => step.status && step.status !== "completed");
     return activeStep?.name ? `${job.name} > ${activeStep.name}` : job.name;
   }).filter(Boolean);
+}
+function activeJobSummary(event) {
+  const summaries = activeJobSummaries(event);
   return summaries.length > 0 ? `; active: ${summaries.join(", ")}` : "";
 }
 function failedJobSummary(event) {
@@ -463,8 +465,73 @@ function formatGitHubActionsGateProgress(gate, event, operation) {
   const run = event.runId ? ` run ${event.runId}` : "";
   return `${prefix}${run} ${status}${activeJobSummary(event)}${url} (${formatElapsed(event.elapsedSeconds)} elapsed)`;
 }
+function progressCompactKey(gate, event) {
+  const active = activeJobSummaries(event).join(",");
+  return [
+    gate.name,
+    event.workflow,
+    event.runId ?? "none",
+    event.type,
+    event.status ?? "none",
+    event.conclusion ?? "none",
+    active
+  ].join("|");
+}
+function formatCompactedGitHubActionsGateProgress(gate, event, operation, repeatedPolls, lastChangeSeconds) {
+  const prefix = `[${operation}][gate][${gate.name}] ${event.workflow}`;
+  const run = event.runId ? ` run ${event.runId}` : "";
+  const active = activeJobSummaries(event);
+  const activeText = active.length > 0 ? active.join(", ") : event.status ?? "waiting";
+  const url = event.url ? `: ${event.url}` : "";
+  return `${prefix}${run} still active: ${activeText} (${repeatedPolls} polls, ${formatElapsed(lastChangeSeconds)} since last change)${url}`;
+}
+function createGitHubActionsGateProgressReporter(gate, options = {}) {
+  const operation = options.operation ?? "workflow";
+  const now = options.now ?? (() => Date.now());
+  const minRepeatMs = options.minRepeatMs ?? 6e4;
+  let lastKey = null;
+  let lastChangeAt = now();
+  let lastEmitAt = 0;
+  let repeatedPolls = 0;
+  return (event) => {
+    if (event.type === "completed") {
+      options.onProgress?.(formatGitHubActionsGateProgress(gate, event, operation));
+      lastKey = null;
+      repeatedPolls = 0;
+      lastEmitAt = now();
+      lastChangeAt = lastEmitAt;
+      return;
+    }
+    const currentKey = progressCompactKey(gate, event);
+    const currentTime = now();
+    if (currentKey !== lastKey) {
+      lastKey = currentKey;
+      lastChangeAt = currentTime;
+      lastEmitAt = currentTime;
+      repeatedPolls = 0;
+      options.onProgress?.(formatGitHubActionsGateProgress(gate, event, operation));
+      return;
+    }
+    repeatedPolls += 1;
+    if (currentTime - lastEmitAt >= minRepeatMs) {
+      options.onProgress?.(formatCompactedGitHubActionsGateProgress(
+        gate,
+        event,
+        operation,
+        repeatedPolls,
+        Math.max(0, Math.round((currentTime - lastChangeAt) / 1e3))
+      ));
+      lastEmitAt = currentTime;
+      repeatedPolls = 0;
+    }
+  };
+}
 async function waitForGitHubActionsGate(gate, options = {}) {
   const { waitForGitHubWorkflowCompletion } = await import("./github-automation.js");
+  const reportProgress = createGitHubActionsGateProgressReporter(gate, {
+    operation: options.operation ?? "workflow",
+    onProgress: options.onProgress
+  });
   return await waitForGitHubWorkflowCompletion(gate.repoPath, {
     repository: gate.repository,
     workflow: gate.workflow,
@@ -472,12 +539,11 @@ async function waitForGitHubActionsGate(gate, options = {}) {
     branch: gate.branch,
     timeoutSeconds: options.timeoutSeconds,
     pollSeconds: options.pollSeconds,
-    onProgress: (event) => {
-      options.onProgress?.(formatGitHubActionsGateProgress(gate, event, options.operation ?? "workflow"));
-    }
+    onProgress: reportProgress
   });
 }
 export {
+  createGitHubActionsGateProgressReporter,
   formatGitHubActionsGateFailure,
   inspectGitHubActionsVerification,
   skippedGitHubActionsGate,

package/dist/operations/services/release-candidate.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
 import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, relative, resolve } from "node:path";
@@ -10,6 +11,7 @@ import { collectTreeseedEnvironmentContext, resolveTreeseedMachineEnvironmentVal
 import { loadDeployState } from "./deploy.js";
 import { loadCliDeployConfig } from "./runtime-tools.js";
 import { packagesWithScript, run, workspacePackages } from "./workspace-tools.js";
+import { createBuildWarningSummary, formatAllowedBuildWarnings } from "./build-warning-policy.js";
 const RELEASE_CANDIDATE_CACHE_DIR = ".treeseed/workflow/release-candidates";
 const STABLE_SEMVER = /^\d+\.\d+\.\d+$/u;
 const REHEARSAL_IGNORED_SEGMENTS = /* @__PURE__ */ new Set([
@@ -224,9 +226,43 @@ function rehearsalVerifyScript(root) {
   }
   return null;
 }
+function runNpmRehearsalCommand(args, options) {
+  const result = spawnSync("npm", args, {
+    cwd: options.cwd,
+    env: process.env,
+    stdio: "pipe",
+    encoding: "utf8",
+    timeout: options.timeoutMs
+  });
+  const stdout = result.stdout ?? "";
+  const stderr = result.stderr ?? "";
+  if (result.status !== 0) {
+    if (stdout) process.stdout.write(stdout);
+    if (stderr) process.stderr.write(stderr);
+    const message = (result.error?.message ? `${result.error.message}
+` : "") + (stderr.trim() || stdout.trim() || `npm ${args.join(" ")} failed`);
+    throw new Error(message);
+  }
+  const warningSummary = createBuildWarningSummary();
+  const emitFiltered = (text, stream) => {
+    for (const line of text.split(/\r?\n/u)) {
+      if (!line) continue;
+      const classified = warningSummary.record(line);
+      if (classified.kind === "allowed") continue;
+      stream.write(`${line}
+`);
+    }
+  };
+  emitFiltered(stdout, process.stdout);
+  emitFiltered(stderr, process.stderr);
+  for (const line of formatAllowedBuildWarnings(warningSummary.allowedWarnings)) {
+    process.stdout.write(`${line}
+`);
+  }
+}
 function buildRehearsalWorkspacePackageArtifacts(root) {
   for (const pkg of packagesWithScript("build:dist", root)) {
-    run("npm", ["--prefix", pkg.dir, "run", "build:dist"], { cwd: root, timeoutMs: 3e5 });
+    runNpmRehearsalCommand(["--prefix", pkg.dir, "run", "build:dist"], { cwd: root, timeoutMs: 3e5 });
   }
 }
 function runProductionDependencyRehearsal(root, plannedVersions, selectedPackageNames, failures) {
@@ -239,12 +275,12 @@ function runProductionDependencyRehearsal(root, plannedVersions, selectedPackage
     const copied = copyWorkspaceForProductionRehearsal(root);
     tempParent = copied.tempParent;
     applyPlannedStableMetadata(copied.tempRoot, plannedVersions);
-    run("npm", ["install", "--package-lock-only", "--ignore-scripts"], { cwd: copied.tempRoot, timeoutMs: 3e5 });
-    run("npm", ["ci", "--ignore-scripts"], { cwd: copied.tempRoot, timeoutMs: 6e5 });
+    runNpmRehearsalCommand(["install", "--package-lock-only", "--ignore-scripts"], { cwd: copied.tempRoot, timeoutMs: 3e5 });
+    runNpmRehearsalCommand(["ci", "--ignore-scripts"], { cwd: copied.tempRoot, timeoutMs: 6e5 });
     buildRehearsalWorkspacePackageArtifacts(copied.tempRoot);
     const scriptName = rehearsalVerifyScript(copied.tempRoot);
     if (scriptName) {
-      run("npm", ["run", scriptName], { cwd: copied.tempRoot, timeoutMs: 9e5 });
+      runNpmRehearsalCommand(["run", scriptName], { cwd: copied.tempRoot, timeoutMs: 9e5 });
     }
     const postInstallIssues = collectInternalDevReferenceIssues(copied.tempRoot, selectedPackageSet);
     if (postInstallIssues.length > 0) {

package/dist/operations/services/repository-save-orchestrator.d.ts

@@ -1,6 +1,7 @@
 import { type GitRemoteWriteMode } from './git-remote-policy.ts';
 import { type CommitMessageContext, type CommitMessageProvider, type CommitMessageProviderMode } from './commit-message-provider.ts';
 import { type DevDependencyReferenceMode, type GitDependencyProtocol } from './package-reference-policy.ts';
+import { type BuildWarningPolicyOptions } from './build-warning-policy.js';
 export type RepoKind = 'package' | 'project';
 export type RepoBranchMode = 'package-release-main' | 'package-dev-save' | 'project-save';
 export type SaveVerifyMode = 'action-first' | 'local-only' | 'skip';
@@ -150,6 +151,15 @@ export type RepositorySaveOptions = {
     stablePackageRelease?: boolean;
     onProgress?: (message: string, stream?: 'stdout' | 'stderr') => void;
 };
+export declare function runStreamingCommand(node: Pick<RepositorySaveNode, 'name' | 'path'>, options: Pick<RepositorySaveOptions, 'onProgress'>, phase: string, command: string, args: string[], commandOptions?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+    buildWarningPolicy?: BuildWarningPolicyOptions | false;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
 export declare function nextDevVersion(version: string, branch: string, date?: Date): string;
 export declare function discoverRepositorySaveNodes(root: string, gitRoot?: string, branch?: string, options?: {
     stablePackageRelease?: boolean;

package/dist/operations/services/repository-save-orchestrator.js

@@ -39,6 +39,10 @@ import {
   workspacePackages
 } from "./workspace-tools.js";
 import { collectDeploymentLockfileWorkspaceIssues } from "./workspace-dependency-mode.js";
+import {
+  createBuildWarningSummary,
+  formatAllowedBuildWarnings
+} from "./build-warning-policy.js";
 class RepositorySaveError extends Error {
   exitCode;
   details;
@@ -79,8 +83,10 @@ function runCapturedCommand(node, options, phase, command, args, commandOptions
   });
   const stdout = result.stdout?.trim() ?? "";
   const stderr = result.stderr?.trim() ?? "";
-  if (stdout) emitProgress(options, node, phase, stdout);
-  if (stderr) emitProgress(options, node, phase, stderr, "stderr");
+  if (commandOptions.emitOutputOnSuccess !== false) {
+    if (stdout) emitProgress(options, node, phase, stdout);
+    if (stderr) emitProgress(options, node, phase, stderr, "stderr");
+  }
   if (result.status !== 0) {
     const message = (result.error?.message ? `${result.error.message}
 ` : "") + (prefixedOutput(node, phase, stderr) || prefixedOutput(node, phase, stdout) || `${progressPrefix(node, phase)} ${command} ${args.join(" ")} failed`);
@@ -94,6 +100,21 @@ function runCapturedCommand(node, options, phase, command, args, commandOptions
   }
   return stdout;
 }
+function npmLockfilePackageCount(repoDir) {
+  try {
+    const lockfile = readJson(resolve(repoDir, "package-lock.json"));
+    const packages = lockfile.packages;
+    if (packages && typeof packages === "object" && !Array.isArray(packages)) {
+      return Math.max(0, Object.keys(packages).filter((entry) => entry !== "").length);
+    }
+    const dependencies = lockfile.dependencies;
+    if (dependencies && typeof dependencies === "object" && !Array.isArray(dependencies)) {
+      return Object.keys(dependencies).length;
+    }
+  } catch {
+  }
+  return null;
+}
 function isNoOpGitCommitError(error) {
   if (!(error instanceof RepositorySaveError)) return false;
   const command = typeof error.details?.command === "string" ? error.details.command : "";
@@ -140,6 +161,7 @@ async function runStreamingCommand(node, options, phase, command, args, commandO
     let stdoutRemainder = "";
     let stderrRemainder = "";
     let settled = false;
+    const warningSummary = commandOptions.buildWarningPolicy === false ? null : createBuildWarningSummary();
     const flush = (chunk, stream) => {
       const combined = stream === "stdout" ? stdoutRemainder + chunk : stderrRemainder + chunk;
       const parts = combined.split(/\r?\n/u);
@@ -147,6 +169,10 @@ async function runStreamingCommand(node, options, phase, command, args, commandO
       if (stream === "stdout") stdoutRemainder = parts.at(-1) ?? "";
       else stderrRemainder = parts.at(-1) ?? "";
       for (const line of complete) {
+        const classified = warningSummary?.record(line, commandOptions.buildWarningPolicy || void 0);
+        if (classified?.kind === "allowed") {
+          continue;
+        }
         emitProgress(options, node, phase, line, stream);
       }
     };
@@ -176,9 +202,20 @@ async function runStreamingCommand(node, options, phase, command, args, commandO
       if (settled) return;
       settled = true;
       if (timeout) clearTimeout(timeout);
-      if (stdoutRemainder) emitProgress(options, node, phase, stdoutRemainder);
-      if (stderrRemainder) emitProgress(options, node, phase, stderrRemainder, "stderr");
+      if (stdoutRemainder) {
+        const classified = warningSummary?.record(stdoutRemainder, commandOptions.buildWarningPolicy || void 0);
+        if (classified?.kind !== "allowed") emitProgress(options, node, phase, stdoutRemainder);
+      }
+      if (stderrRemainder) {
+        const classified = warningSummary?.record(stderrRemainder, commandOptions.buildWarningPolicy || void 0);
+        if (classified?.kind !== "allowed") emitProgress(options, node, phase, stderrRemainder, "stderr");
+      }
       if (code === 0) {
+        if (warningSummary) {
+          for (const line of formatAllowedBuildWarnings(warningSummary.allowedWarnings)) {
+            emitProgress(options, node, phase, line);
+          }
+        }
         resolvePromise({ stdout, stderr });
         return;
       }
@@ -644,7 +681,10 @@ async function validateRepositoryLockfile(node, options) {
     return { status: "skipped", command: commandText, issues: [], error: "stubbed" };
   }
   try {
-    runCapturedCommand(node, options, "lockfile", command, args, { timeoutMs: 12e4 });
+    runCapturedCommand(node, options, "lockfile", command, args, { timeoutMs: 12e4, emitOutputOnSuccess: false });
+    const packageCount = npmLockfilePackageCount(node.path);
+    const countText = packageCount === null ? "package-lock entries" : `${packageCount} package${packageCount === 1 ? "" : "s"}`;
+    emitProgress(options, node, "lockfile", `Lockfile validation passed: ${countText} checked, 0 issues.`);
     return { status: "passed", command: commandText, issues: [], error: null };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -1520,5 +1560,6 @@ export {
   refreshAndValidateRootWorkspaceLockfileForSave,
   repositorySaveErrorDetails,
   repositorySaveWaves,
-  runRepositorySaveOrchestrator
+  runRepositorySaveOrchestrator,
+  runStreamingCommand
 };

package/dist/scripts/check-build-warnings.js

@@ -2,14 +2,12 @@
 
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
+import {
+	formatAllowedBuildWarnings,
+	scanBuildWarningText,
+} from '../operations/services/build-warning-policy.js';
 
 const args = process.argv.slice(2);
-const defaultAllowlisted = [
-	{
-		label: 'vite-browser-external-libsodium-url',
-		pattern: /Module "url" has been externalized for browser compatibility, imported by ".*libsodium-sumo.*"/u,
-	},
-];
 const allowlisted = [];
 const files = [];
 let useDefaultPolicy = true;
@@ -25,10 +23,7 @@ for (let index = 0; index < args.length; index += 1) {
 		if (!pattern) {
 			throw new Error('Missing value for --allow.');
 		}
-		allowlisted.push({
-			label: `custom:${pattern}`,
-			pattern: new RegExp(pattern),
-		});
+		allowlisted.push(pattern);
 		index += 1;
 		continue;
 	}
@@ -41,24 +36,16 @@ if (files.length === 0) {
 
 const warningLines = [];
 const allowedWarnings = new Map();
-const effectiveAllowlisted = [
-	...(useDefaultPolicy ? defaultAllowlisted : []),
-	...allowlisted,
-];
 for (const file of files) {
 	const contents = readFileSync(resolve(process.cwd(), file), 'utf8');
-	for (const line of contents.split(/\r?\n/u)) {
-		if (!line.includes('[WARN]')) {
-			continue;
-		}
-		const allowed = effectiveAllowlisted.find((rule) => rule.pattern.test(line));
-		if (allowed) {
-			const current = allowedWarnings.get(allowed.label) ?? 0;
-			allowedWarnings.set(allowed.label, current + 1);
-			continue;
-		}
-		warningLines.push(line);
+	const scan = scanBuildWarningText(contents, {
+		useDefaultPolicy,
+		allow: allowlisted,
+	});
+	for (const [label, count] of scan.allowedWarnings.entries()) {
+		allowedWarnings.set(label, (allowedWarnings.get(label) ?? 0) + count);
 	}
+	warningLines.push(...scan.unexpectedWarnings);
 }
 
 if (warningLines.length > 0) {
@@ -69,11 +56,7 @@ if (warningLines.length > 0) {
 	process.exit(1);
 }
 
-const allowedTotal = [...allowedWarnings.values()].reduce((sum, count) => sum + count, 0);
-if (allowedTotal > 0) {
-	console.log(`Allowed build warnings: ${allowedTotal}`);
-	for (const [label, count] of [...allowedWarnings.entries()].sort(([left], [right]) => left.localeCompare(right))) {
-		console.log(`- ${label}: ${count}`);
-	}
+for (const line of formatAllowedBuildWarnings(allowedWarnings)) {
+	console.log(line);
 }
 console.log('No unexpected build warnings detected.');

package/dist/workflow-state.d.ts

@@ -35,6 +35,7 @@ export type TreeseedWorkflowProviderStatus = Record<'local' | 'staging' | 'prod'
 }>;
 export type TreeseedWorkflowStatusOptions = {
     live?: boolean;
+    history?: 'recent' | 'all';
     env?: NodeJS.ProcessEnv;
 };
 export type TreeseedWorkflowState = {
@@ -75,6 +76,9 @@ export type TreeseedWorkflowState = {
             updatedAt: string;
             reasons: string[];
         }>;
+        historyMode: 'recent' | 'all';
+        obsoleteRunsTotal: number;
+        obsoleteRunsOmitted: number;
         blockers: string[];
     };
     packageSync: {
@@ -218,5 +222,14 @@ export type TreeseedWorkflowState = {
     }>;
     recommendations: TreeseedWorkflowRecommendation[];
 };
+export declare function capObsoleteWorkflowRuns<T>(obsoleteRuns: T[], options?: {
+    history?: 'recent' | 'all';
+    limit?: number;
+}): {
+    historyMode: string;
+    obsoleteRuns: T[];
+    obsoleteRunsTotal: number;
+    obsoleteRunsOmitted: number;
+};
 export declare function resolveTreeseedWorkflowState(cwd: string, options?: TreeseedWorkflowStatusOptions): TreeseedWorkflowState;
 export declare function recommendTreeseedNextSteps(state: TreeseedWorkflowState): TreeseedWorkflowRecommendation[];

package/dist/workflow-state.js

@@ -293,6 +293,27 @@ function safeReleaseHistory(repoDir) {
     };
   }
 }
+const DEFAULT_OBSOLETE_RUN_HISTORY_LIMIT = 20;
+function capObsoleteWorkflowRuns(obsoleteRuns, options = {}) {
+  const historyMode = options.history === "all" ? "all" : "recent";
+  const limit = options.limit ?? DEFAULT_OBSOLETE_RUN_HISTORY_LIMIT;
+  const obsoleteRunsTotal = obsoleteRuns.length;
+  if (historyMode === "all") {
+    return {
+      historyMode,
+      obsoleteRuns,
+      obsoleteRunsTotal,
+      obsoleteRunsOmitted: 0
+    };
+  }
+  const cappedRuns = obsoleteRuns.slice(0, limit);
+  return {
+    historyMode,
+    obsoleteRuns: cappedRuns,
+    obsoleteRunsTotal,
+    obsoleteRunsOmitted: Math.max(0, obsoleteRunsTotal - cappedRuns.length)
+  };
+}
 function resolveLocalStatusUrl(deployConfig) {
   return deployConfig.surfaces?.web?.localBaseUrl ?? deployConfig.surfaces?.api?.localBaseUrl ?? Object.values(deployConfig.services ?? {}).find((service) => service?.enabled !== false && service.environments?.local?.baseUrl)?.environments?.local?.baseUrl ?? null;
 }
@@ -409,6 +430,7 @@ function resolveTreeseedWorkflowState(cwd, options = {}) {
     updatedAt: journal.updatedAt,
     reasons: classification.reasons
   }));
+  const obsoleteHistory = capObsoleteWorkflowRuns(obsoleteRuns, { history: options.history });
   const workflowBlockers = [];
   if (workflowLock.active && workflowLock.lock) {
     workflowBlockers.push(`Workflow lock active for ${workflowLock.lock.command} (${workflowLock.lock.runId}).`);
@@ -442,7 +464,10 @@ function resolveTreeseedWorkflowState(cwd, options = {}) {
       },
       interruptedRuns,
       staleRuns,
-      obsoleteRuns,
+      obsoleteRuns: obsoleteHistory.obsoleteRuns,
+      historyMode: obsoleteHistory.historyMode,
+      obsoleteRunsTotal: obsoleteHistory.obsoleteRunsTotal,
+      obsoleteRunsOmitted: obsoleteHistory.obsoleteRunsOmitted,
       blockers: workflowBlockers
     },
     packageSync: {
@@ -783,6 +808,7 @@ function recommendTreeseedNextSteps(state) {
   return recommendations.slice(0, 3);
 }
 export {
+  capObsoleteWorkflowRuns,
   recommendTreeseedNextSteps,
   resolveTreeseedWorkflowState
 };

package/package.json

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