@treeseed/sdk 0.6.33 → 0.6.35

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/deploy.d.ts

@@ -998,6 +998,7 @@ export declare function runRemoteD1Migrations(tenantRoot: any, options?: {}): {
 };
 export declare function markDeploymentInitialized(tenantRoot: any, options?: {}): any;
 export declare function markManagedServicesInitialized(tenantRoot: any, options?: {}): any;
+export declare function recordHostedDeploymentState(tenantRoot: any, options?: {}): any;
 export declare function assertDeploymentInitialized(tenantRoot: any, options?: {}): any;
 export declare function finalizeDeploymentState(tenantRoot: any, options?: {}): any;
 export declare function printDeploySummary(summary: any): void;

package/dist/operations/services/deploy.js

@@ -2096,6 +2096,42 @@ function markManagedServicesInitialized(tenantRoot, options = {}) {
   writeDeployState(tenantRoot, state, { target });
   return state;
 }
+function recordHostedDeploymentState(tenantRoot, options = {}) {
+  const target = normalizeTarget(options.scope ?? options.target ?? "prod");
+  const deployConfig = loadTenantDeployConfig(tenantRoot);
+  const state = loadDeployState(tenantRoot, deployConfig, { target });
+  const timestamp = typeof options.timestamp === "string" && options.timestamp.trim() ? options.timestamp.trim() : (/* @__PURE__ */ new Date()).toISOString();
+  const deployedUrl = typeof options.url === "string" && options.url.trim() ? options.url.trim() : state.lastDeployedUrl ?? resolveConfiguredSurfaceBaseUrl(deployConfig, target, "web");
+  const commit = typeof options.commit === "string" && options.commit.trim() ? options.commit.trim() : null;
+  state.lastDeployedUrl = deployedUrl;
+  state.lastDeploymentTimestamp = timestamp;
+  state.lastDeployedCommit = commit;
+  state.readiness = {
+    ...state.readiness ?? {},
+    initialized: true,
+    configured: true,
+    provisioned: true,
+    deployable: true,
+    phase: "provisioned",
+    initializedAt: state.readiness?.initializedAt ?? timestamp,
+    lastValidatedAt: timestamp,
+    blockers: [],
+    warnings: state.readiness?.warnings ?? []
+  };
+  const nextHistoryEntry = {
+    commit,
+    timestamp,
+    url: deployedUrl,
+    target: deployTargetLabel(target),
+    source: options.source ?? "hosted-github-workflow",
+    workflow: options.workflow ?? null,
+    runId: options.runId ?? null
+  };
+  const history = Array.isArray(state.deploymentHistory) ? state.deploymentHistory : [];
+  state.deploymentHistory = [...history, nextHistoryEntry].slice(-20);
+  writeDeployState(tenantRoot, state, { target });
+  return state;
+}
 function assertDeploymentInitialized(tenantRoot, options = {}) {
   const target = normalizeTarget(options.scope ?? options.target ?? "prod");
   const deployConfig = loadTenantDeployConfig(tenantRoot);
@@ -2225,6 +2261,7 @@ export {
   queueId,
   queueName,
   reconcileCloudflareWebCacheRules,
+  recordHostedDeploymentState,
   resolveCloudflareZoneIdForHost,
   resolveConfiguredCloudflareAccountId,
   resolveConfiguredSurfaceBaseUrl,

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

@@ -119,15 +119,32 @@ export declare function mergeCurrentBranchIntoStaging(cwd: any, featureBranch: a
     committed: boolean;
     commitSha: string;
     pushed: boolean;
+    generatedMetadataReconciliation: {
+        commitSha: null;
+        resolved: boolean;
+        repoDir: any;
+        targetBranch: string;
+        reconciledFiles: string[];
+        allConflictsWereGeneratedMetadata: boolean;
+    } | null;
 };
-export declare function squashMergeBranchIntoStaging(cwd: any, featureBranch: any, message: any, { pushTarget }?: {
+export declare function squashMergeBranchIntoStaging(cwd: any, featureBranch: any, message: any, { pushTarget, reportGeneratedMetadataReconciliation }?: {
     pushTarget?: boolean | undefined;
+    reportGeneratedMetadataReconciliation?: boolean | undefined;
 }): {
     repoDir: string;
     targetBranch: string;
     committed: boolean;
     commitSha: string;
     pushed: boolean;
+    generatedMetadataReconciliation: {
+        commitSha: null;
+        resolved: boolean;
+        repoDir: any;
+        targetBranch: string;
+        reconciledFiles: string[];
+        allConflictsWereGeneratedMetadata: boolean;
+    } | null;
 };
 export declare function currentManagedBranch(cwd?: any): string;
 export declare function isTaskBranch(branchName: any): boolean;

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

@@ -28,14 +28,34 @@ function conflictedFiles(repoDir) {
 }
 function resolveGeneratedPackageMetadataConflicts(repoDir) {
   const files = conflictedFiles(repoDir);
-  if (files.length === 0) return false;
+  if (files.length === 0) {
+    return {
+      resolved: false,
+      repoDir,
+      targetBranch: STAGING_BRANCH,
+      reconciledFiles: [],
+      allConflictsWereGeneratedMetadata: false
+    };
+  }
   const generatedMetadataFiles = /* @__PURE__ */ new Set(["package.json", "package-lock.json"]);
   if (files.some((file) => !generatedMetadataFiles.has(file))) {
-    return false;
+    return {
+      resolved: false,
+      repoDir,
+      targetBranch: STAGING_BRANCH,
+      reconciledFiles: files,
+      allConflictsWereGeneratedMetadata: false
+    };
   }
   runGit(["checkout", "--theirs", "--", ...files], { cwd: repoDir });
   runGit(["add", "--", ...files], { cwd: repoDir });
-  return true;
+  return {
+    resolved: true,
+    repoDir,
+    targetBranch: STAGING_BRANCH,
+    reconciledFiles: files,
+    allConflictsWereGeneratedMetadata: true
+  };
 }
 function headCommit(repoDir, ref = "HEAD") {
   return runGit(["rev-parse", ref], { cwd: repoDir, capture: true }).trim();
@@ -301,22 +321,35 @@ function deleteRemoteBranch(repoDir, branchName) {
 function mergeCurrentBranchIntoStaging(cwd, featureBranch) {
   return squashMergeBranchIntoStaging(cwd, featureBranch, `stage: ${featureBranch}`);
 }
-function squashMergeBranchIntoStaging(cwd, featureBranch, message, { pushTarget = true } = {}) {
+function squashMergeBranchIntoStaging(cwd, featureBranch, message, { pushTarget = true, reportGeneratedMetadataReconciliation = true } = {}) {
   const repoDir = assertCleanWorktree(cwd);
   fetchOrigin(repoDir);
   syncBranchWithOrigin(repoDir, STAGING_BRANCH);
+  let generatedMetadataReconciliation = null;
   try {
-    runGit(["merge", "--squash", featureBranch], { cwd: repoDir });
+    runGit(["merge", "--squash", featureBranch], { cwd: repoDir, capture: true });
   } catch (error) {
-    if (!resolveGeneratedPackageMetadataConflicts(repoDir)) {
+    const reconciliation = resolveGeneratedPackageMetadataConflicts(repoDir);
+    if (!reconciliation.resolved) {
       throw error;
     }
+    if (reportGeneratedMetadataReconciliation) {
+      console.log(`Resolving generated package metadata reconciliation for ${reconciliation.reconciledFiles.join(", ")}.`);
+    }
+    generatedMetadataReconciliation = {
+      ...reconciliation,
+      commitSha: null
+    };
   }
   let committed = false;
   if (repoHasStagedChanges(repoDir)) {
     runGit(["commit", "-m", message], { cwd: repoDir });
     committed = true;
   }
+  const commitSha = headCommit(repoDir);
+  if (generatedMetadataReconciliation) {
+    generatedMetadataReconciliation.commitSha = commitSha;
+  }
   if (pushTarget) {
     pushBranch(repoDir, STAGING_BRANCH);
   }
@@ -324,8 +357,9 @@ function squashMergeBranchIntoStaging(cwd, featureBranch, message, { pushTarget
     repoDir,
     targetBranch: STAGING_BRANCH,
     committed,
-    commitSha: headCommit(repoDir),
-    pushed: pushTarget
+    commitSha,
+    pushed: pushTarget,
+    generatedMetadataReconciliation
   };
 }
 function currentManagedBranch(cwd = workspaceRoot()) {

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;
@@ -114,8 +114,16 @@ export declare function skippedGitHubActionsGate(gate: GitHubActionsWorkflowGate
     conclusion: null;
     runId: null;
     url: null;
+    createdAt: null;
+    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

@@ -406,7 +406,9 @@ function skippedGitHubActionsGate(gate, reason) {
     reason,
     conclusion: null,
     runId: null,
-    url: null
+    url: null,
+    createdAt: null,
+    updatedAt: null
   };
 }
 function formatGitHubActionsGateFailure(gate, result) {
@@ -431,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) {
@@ -461,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,
@@ -470,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/github-api.d.ts

@@ -26,6 +26,8 @@ export interface GitHubWorkflowRunSummary {
     url: string | null;
     headSha: string | null;
     headBranch: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
 }
 export interface GitHubWorkflowJobSummary {
     id: number;
@@ -162,6 +164,8 @@ export declare function waitForGitHubWorkflowRunCompletion(repository: string |
     runId: number;
     headSha: string | null;
     branch: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
     conclusion: string | null;
     url: string | null;
     jobs: GitHubWorkflowJobSummary[];

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

@@ -520,7 +520,9 @@ function normalizeWorkflowRun(run) {
     conclusion: typeof run.conclusion === "string" ? run.conclusion : null,
     url: typeof run.html_url === "string" ? run.html_url : null,
     headSha: typeof run.head_sha === "string" ? run.head_sha : null,
-    headBranch: typeof run.head_branch === "string" ? run.head_branch : null
+    headBranch: typeof run.head_branch === "string" ? run.head_branch : null,
+    createdAt: typeof run.created_at === "string" ? run.created_at : null,
+    updatedAt: typeof run.updated_at === "string" ? run.updated_at : null
   };
 }
 function normalizeWorkflowJob(job) {
@@ -623,6 +625,8 @@ async function waitForGitHubWorkflowRunCompletion(repository, {
             runId: normalized.id,
             headSha: normalized.headSha,
             branch: normalized.headBranch,
+            createdAt: normalized.createdAt,
+            updatedAt: normalized.updatedAt,
             conclusion: normalized.conclusion,
             url: normalized.url,
             jobs: normalizedJobs,

package/dist/operations/services/github-automation.d.ts

@@ -284,6 +284,8 @@ export declare function waitForGitHubWorkflowCompletion(tenantRoot: any, { repos
     runId: number;
     headSha: string | null;
     branch: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
     conclusion: string | null;
     url: string | null;
     jobs: import("./github-api.ts").GitHubWorkflowJobSummary[];

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,11 +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 = [
-	/Module "url" has been externalized for browser compatibility, imported by ".*libsodium-sumo.*"/u,
-];
 const allowlisted = [];
 const files = [];
 let useDefaultPolicy = true;
@@ -22,7 +23,7 @@ for (let index = 0; index < args.length; index += 1) {
 		if (!pattern) {
 			throw new Error('Missing value for --allow.');
 		}
-		allowlisted.push(new RegExp(pattern));
+		allowlisted.push(pattern);
 		index += 1;
 		continue;
 	}
@@ -34,21 +35,17 @@ if (files.length === 0) {
 }
 
 const warningLines = [];
-const effectiveAllowlisted = [
-	...(useDefaultPolicy ? defaultAllowlisted : []),
-	...allowlisted,
-];
+const allowedWarnings = new Map();
 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;
-		}
-		if (effectiveAllowlisted.some((pattern) => pattern.test(line))) {
-			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) {
@@ -59,4 +56,7 @@ if (warningLines.length > 0) {
 	process.exit(1);
 }
 
+for (const line of formatAllowedBuildWarnings(allowedWarnings)) {
+	console.log(line);
+}
 console.log('No unexpected build warnings detected.');

package/dist/workflow/operations.d.ts

@@ -415,6 +415,8 @@ export declare function workflowSave(helpers: WorkflowOperationHelpers, input: T
         conclusion: null;
         runId: null;
         url: null;
+        createdAt: null;
+        updatedAt: null;
     }[];
     releaseCandidate: ReleaseCandidateReport | null;
 } & {
@@ -553,6 +555,8 @@ export declare function workflowClose(helpers: WorkflowOperationHelpers, input:
             conclusion: null;
             runId: null;
             url: null;
+            createdAt: null;
+            updatedAt: null;
         }[];
         releaseCandidate: ReleaseCandidateReport | null;
     } & {
@@ -732,6 +736,8 @@ export declare function workflowStage(helpers: WorkflowOperationHelpers, input:
             conclusion: null;
             runId: null;
             url: null;
+            createdAt: null;
+            updatedAt: null;
         }[];
         releaseCandidate: ReleaseCandidateReport | null;
     } & {
@@ -886,6 +892,7 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
         targetBranch: string;
         commitSha: string;
     };
+    hostedDeploymentState: Record<string, unknown>[];
     finalBranch: string;
     pushStatus: {
         stagingPushed: boolean;
@@ -905,6 +912,8 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
         conclusion: null;
         runId: null;
         url: null;
+        createdAt: null;
+        updatedAt: null;
     }[];
 } & {
     finalState?: WorkflowStatePayload;
@@ -968,6 +977,7 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
         targetBranch: string;
         commitSha: string;
     };
+    hostedDeploymentState: Record<string, unknown>[];
     finalBranch: string;
     pushStatus: {
         stagingPushed: boolean;
@@ -987,6 +997,8 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
         conclusion: null;
         runId: null;
         url: null;
+        createdAt: null;
+        updatedAt: null;
     })[];
 } & {
     finalState?: WorkflowStatePayload;

package/dist/workflow/operations.js

@@ -36,6 +36,7 @@ import {
   ensureGeneratedWranglerConfig,
   finalizeDeploymentState,
   loadDeployState,
+  recordHostedDeploymentState,
   runRemoteD1Migrations,
   validateDeployPrerequisites,
   validateDestroyPrerequisites
@@ -418,6 +419,38 @@ async function waitForWorkflowGates(operation, gates, ciMode, options = {}) {
   }
   return results;
 }
+function recordHostedDeploymentStatesFromRootGates(root, rootRelease, workflowGates) {
+  const gates = Array.isArray(workflowGates) ? workflowGates.map((gate) => stringRecord(gate)).filter((gate) => Boolean(gate)) : [];
+  const releaseRecord = stringRecord(rootRelease) ?? {};
+  const reports = [];
+  for (const target of [
+    { scope: "staging", branch: STAGING_BRANCH, commit: releaseRecord.stagingCommit },
+    { scope: "prod", branch: PRODUCTION_BRANCH, commit: releaseRecord.releasedCommit }
+  ]) {
+    const gate = gates.find((candidate) => candidate.workflow === "deploy.yml" && candidate.branch === target.branch && candidate.status === "completed" && candidate.conclusion === "success");
+    const timestamp = typeof gate?.updatedAt === "string" && gate.updatedAt.trim() ? gate.updatedAt : null;
+    if (!gate || !timestamp) {
+      continue;
+    }
+    const state = recordHostedDeploymentState(root, {
+      scope: target.scope,
+      commit: typeof target.commit === "string" ? target.commit : null,
+      timestamp,
+      workflow: gate.workflow,
+      runId: gate.runId ?? null
+    });
+    reports.push({
+      scope: target.scope,
+      branch: target.branch,
+      commit: typeof target.commit === "string" ? target.commit : null,
+      timestamp: state.lastDeploymentTimestamp ?? timestamp,
+      url: state.lastDeployedUrl ?? null,
+      workflow: gate.workflow,
+      runId: gate.runId ?? null
+    });
+  }
+  return reports;
+}
 function ensureTreeseedCommandReadiness(root) {
   if (getGitHubAutomationMode() === "stub") {
     return {
@@ -3625,6 +3658,7 @@ async function workflowRelease(helpers, input) {
             runId: workflowRun.runId,
             onProgress: (line, stream) => helpers.write(line, stream)
           }).then((workflowGates) => ({ workflowGates })));
+          const hostedDeploymentState2 = recordHostedDeploymentStatesFromRootGates(root, rootRelease2, rootWorkflowGateResult2?.workflowGates);
           const releaseBackMerge2 = await executeJournalStep(root, workflowRun.runId, "release-back-merge", () => backMergeRootProductionIntoStaging(root, false));
           const workspaceLinks2 = ensureWorkflowWorkspaceLinks(root, helpers, effectiveInput.workspaceLinks ?? "auto");
           const payload2 = {
@@ -3648,6 +3682,7 @@ async function workflowRelease(helpers, input) {
             rootRepo,
             releaseCandidate,
             releaseBackMerge: releaseBackMerge2,
+            hostedDeploymentState: hostedDeploymentState2,
             finalBranch: currentBranch(gitRoot) || STAGING_BRANCH,
             pushStatus: { stagingPushed: true, productionPushed: true, tagPushed: true },
             workspaceLinks: workspaceLinks2,
@@ -3870,6 +3905,7 @@ async function workflowRelease(helpers, input) {
           runId: workflowRun.runId,
           onProgress: (line, stream) => helpers.write(line, stream)
         }).then((workflowGates) => ({ workflowGates })));
+        const hostedDeploymentState = recordHostedDeploymentStatesFromRootGates(root, rootRelease, rootWorkflowGateResult?.workflowGates);
         const releaseBackMerge = await executeJournalStep(root, workflowRun.runId, "release-back-merge", () => backMergeRootProductionIntoStaging(root, true));
         const devTagCleanupMode = effectiveInput.devTagCleanup ?? "safe-after-release";
         const devTagCleanup = devTagCleanupMode === "off" ? (skipJournalStep(root, workflowRun.runId, "cleanup-dev-tags", { status: "skipped", reason: "disabled" }), { status: "skipped", reason: "disabled" }) : await executeJournalStep(root, workflowRun.runId, "cleanup-dev-tags", () => {
@@ -3921,6 +3957,7 @@ async function workflowRelease(helpers, input) {
           rootRepo,
           releaseCandidate,
           releaseBackMerge,
+          hostedDeploymentState,
           finalBranch: currentBranch(gitRoot) || STAGING_BRANCH,
           pushStatus: {
             stagingPushed: true,

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: {
@@ -189,6 +193,7 @@ export type TreeseedWorkflowState = {
     releaseHistory: {
         stagingAheadMain: number | null;
         stagingBehindMain: number | null;
+        unreleasedStagingCommits: number | null;
         backMerged: boolean | null;
         detail: string;
     };
@@ -217,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

@@ -261,6 +261,7 @@ function safeReleaseHistory(repoDir) {
     return {
       stagingAheadMain: null,
       stagingBehindMain: null,
+      unreleasedStagingCommits: null,
       backMerged: null,
       detail: "Repository root is unavailable."
     };
@@ -273,21 +274,46 @@ function safeReleaseHistory(repoDir) {
     if (!Number.isFinite(stagingAheadMain) || !Number.isFinite(stagingBehindMain)) {
       throw new Error("invalid rev-list output");
     }
+    const stagingOnlySubjects = run("git", ["log", "--format=%s", "main..staging"], { cwd: repoDir, capture: true }).split("\n").map((line) => line.trim()).filter(Boolean);
+    const unreleasedStagingCommits = stagingOnlySubjects.filter((subject) => subject !== "release: sync package staging heads" && subject !== "release: back-merge main into staging" && !subject.startsWith("release: back-merge main into staging ")).length;
     return {
       stagingAheadMain,
       stagingBehindMain,
+      unreleasedStagingCommits,
       backMerged: stagingBehindMain === 0,
-      detail: stagingBehindMain === 0 ? "Staging contains current main release history." : `Staging is missing ${stagingBehindMain} main commit${stagingBehindMain === 1 ? "" : "s"}.`
+      detail: stagingBehindMain === 0 && unreleasedStagingCommits === 0 ? stagingAheadMain > 0 ? "Staging contains current main release history and is only ahead by release sync commits." : "Staging contains current main release history." : stagingBehindMain === 0 ? `Staging has ${unreleasedStagingCommits} unreleased commit${unreleasedStagingCommits === 1 ? "" : "s"} and contains current main release history.` : `Staging is missing ${stagingBehindMain} main commit${stagingBehindMain === 1 ? "" : "s"}.`
     };
   } catch {
     return {
       stagingAheadMain: null,
       stagingBehindMain: null,
+      unreleasedStagingCommits: null,
       backMerged: null,
       detail: "Could not compare staging and main release history."
     };
   }
 }
+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;
 }
@@ -404,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}).`);
@@ -414,6 +441,8 @@ function resolveTreeseedWorkflowState(cwd, options = {}) {
   if (interruptedRuns.length > 0) {
     workflowBlockers.push(`Interrupted workflow runs detected: ${interruptedRuns.map((run2) => run2.runId).join(", ")}.`);
   }
+  const releaseHistory = safeReleaseHistory(root);
+  const releaseReady = branchRole === "staging" && !dirtyWorktree && (releaseHistory.unreleasedStagingCommits ?? 0) > 0;
   const state = {
     cwd: effectiveCwd,
     workspaceRoot,
@@ -435,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: {
@@ -527,8 +559,8 @@ function resolveTreeseedWorkflowState(cwd, options = {}) {
       idleRemainingMs: keyStatus.idleRemainingMs,
       startupPassphraseConfigured: Boolean(process.env.TREESEED_KEY_PASSPHRASE?.trim())
     },
-    releaseReady: branchRole === "staging" && !dirtyWorktree,
-    releaseHistory: safeReleaseHistory(root),
+    releaseReady,
+    releaseHistory,
     readiness: {
       local: { ready: false, blockers: [], warnings: [] },
       staging: { ready: false, blockers: [], warnings: [] },
@@ -747,8 +779,13 @@ function recommendTreeseedNextSteps(state) {
     }
     if (!state.persistentEnvironments.staging.initialized) {
       recommendations.push({ operation: "config", reason: "Initialize the staging environment before releasing.", input: { environment: ["staging"] } });
+    } else if ((state.releaseHistory.unreleasedStagingCommits ?? 0) > 0) {
+      recommendations.push({ operation: "release", reason: "Promote unreleased staging commits into production.", input: { bump: "patch" } });
+      if (state.managedServices.api.enabled) {
+        recommendations.push({ operation: "auth:login", reason: "Keep the local runtime authenticated to the remote API used by managed services." });
+      }
     } else {
-      recommendations.push({ operation: "release", reason: "Promote staging into main when the integration branch is ready for production.", input: { bump: "patch" } });
+      recommendations.push({ operation: "status", reason: "Inspect staging and production state; no unreleased staging commits are pending." });
       if (state.managedServices.api.enabled) {
         recommendations.push({ operation: "auth:login", reason: "Keep the local runtime authenticated to the remote API used by managed services." });
       }
@@ -771,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.33",
+  "version": "0.6.35",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "AGPL-3.0-only",
   "repository": {