@treeseed/sdk 0.6.32 → 0.6.34

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;
@@ -162,8 +179,9 @@ export declare function mergeStagingIntoMain(cwd?: any): {
     commitSha: string;
     pushed: boolean;
 };
-export declare function mergeBranchIntoTarget(cwd?: any, { sourceBranch, targetBranch, message, pushTarget }?: {
+export declare function mergeBranchIntoTarget(cwd?: any, { sourceBranch, targetBranch, message, pushTarget, quietMerge }?: {
     pushTarget?: boolean | undefined;
+    quietMerge?: boolean | undefined;
 }): {
     repoDir: string;
     targetBranch: any;

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()) {
@@ -425,13 +459,13 @@ function mergeStagingIntoMain(cwd = workspaceRoot()) {
     pushTarget: true
   });
 }
-function mergeBranchIntoTarget(cwd = workspaceRoot(), { sourceBranch, targetBranch, message, pushTarget = true } = {}) {
+function mergeBranchIntoTarget(cwd = workspaceRoot(), { sourceBranch, targetBranch, message, pushTarget = true, quietMerge = false } = {}) {
   const repoDir = prepareReleaseBranches(cwd);
   checkoutBranch(repoDir, targetBranch);
   if (remoteBranchExists(repoDir, targetBranch)) {
     runGit(["merge", "--ff-only", `origin/${targetBranch}`], { cwd: repoDir });
   }
-  runGit(["merge", "--no-ff", sourceBranch, "-m", message], { cwd: repoDir });
+  runGit(["merge", "--no-ff", sourceBranch, "-m", message], { cwd: repoDir, capture: quietMerge });
   pushBranch(repoDir, STAGING_BRANCH);
   if (pushTarget) {
     pushBranch(repoDir, targetBranch);

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

@@ -114,6 +114,8 @@ 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 waitForGitHubActionsGate(gate: GitHubActionsWorkflowGate, options?: {

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,6 +433,21 @@ function formatElapsed(seconds) {
 function shortSha(value) {
   return value ? value.slice(0, 12) : "(unknown)";
 }
+function activeJobSummary(event) {
+  const activeJobs = event.activeJobs ?? [];
+  if (activeJobs.length === 0) return "";
+  const summaries = 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);
+  return summaries.length > 0 ? `; active: ${summaries.join(", ")}` : "";
+}
+function failedJobSummary(event) {
+  const failedJobs = event.failedJobs ?? [];
+  if (failedJobs.length === 0) return "";
+  const names = failedJobs.slice(0, 3).map((job) => job.name).filter(Boolean);
+  return names.length > 0 ? `; failed: ${names.join(", ")}` : "";
+}
 function formatGitHubActionsGateProgress(gate, event, operation) {
   const prefix = `[${operation}][gate][${gate.name}] ${event.workflow}`;
   if (event.type === "waiting") {
@@ -439,12 +456,12 @@ function formatGitHubActionsGateProgress(gate, event, operation) {
   if (event.type === "completed") {
     const conclusion = event.conclusion === "success" ? "successfully" : `with conclusion ${event.conclusion ?? "unknown"}`;
     const url2 = event.url ? `: ${event.url}` : "";
-    return `${prefix} completed ${conclusion} in ${formatElapsed(event.elapsedSeconds)}${url2}`;
+    return `${prefix} completed ${conclusion}${failedJobSummary(event)} in ${formatElapsed(event.elapsedSeconds)}${url2}`;
   }
   const status = event.status ?? "waiting";
   const url = event.url ? `: ${event.url}` : "";
   const run = event.runId ? ` run ${event.runId}` : "";
-  return `${prefix}${run} ${status}${url} (${formatElapsed(event.elapsedSeconds)} elapsed)`;
+  return `${prefix}${run} ${status}${activeJobSummary(event)}${url} (${formatElapsed(event.elapsedSeconds)} elapsed)`;
 }
 async function waitForGitHubActionsGate(gate, options = {}) {
   const { waitForGitHubWorkflowCompletion } = await import("./github-automation.js");

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;
@@ -33,6 +35,12 @@ export interface GitHubWorkflowJobSummary {
     status: string | null;
     conclusion: string | null;
     url: string | null;
+    steps?: GitHubWorkflowJobStepSummary[];
+}
+export interface GitHubWorkflowJobStepSummary {
+    name: string;
+    status: string | null;
+    conclusion: string | null;
 }
 export type GitHubWorkflowProgressEvent = {
     type: 'waiting' | 'running' | 'completed';
@@ -45,6 +53,10 @@ export type GitHubWorkflowProgressEvent = {
     url: string | null;
     status: string | null;
     conclusion: string | null;
+    jobs?: GitHubWorkflowJobSummary[];
+    activeJobs?: GitHubWorkflowJobSummary[];
+    completedJobs?: GitHubWorkflowJobSummary[];
+    failedJobs?: GitHubWorkflowJobSummary[];
 };
 export declare function resolveGitHubApiToken(env?: NodeJS.ProcessEnv | Record<string, string | undefined>): string;
 export declare function parseGitHubRepositorySlug(value: string): {
@@ -152,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) {
@@ -529,9 +531,27 @@ function normalizeWorkflowJob(job) {
     name: String(job.name ?? ""),
     status: typeof job.status === "string" ? job.status : null,
     conclusion: typeof job.conclusion === "string" ? job.conclusion : null,
-    url: typeof job.html_url === "string" ? job.html_url : null
+    url: typeof job.html_url === "string" ? job.html_url : null,
+    steps: Array.isArray(job.steps) ? job.steps.map((step) => ({
+      name: String(step.name ?? ""),
+      status: typeof step.status === "string" ? step.status : null,
+      conclusion: typeof step.conclusion === "string" ? step.conclusion : null
+    })) : []
   };
 }
+async function listWorkflowJobsForProgress(client, owner, repo, runId) {
+  try {
+    const jobs = await client.rest.actions.listJobsForWorkflowRun({
+      owner,
+      repo,
+      run_id: runId,
+      per_page: 100
+    });
+    return jobs.data.jobs.map((job) => normalizeWorkflowJob(job));
+  } catch {
+    return [];
+  }
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -547,7 +567,10 @@ async function waitForGitHubWorkflowRunCompletion(repository, {
   const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
   const startedAt = Date.now();
   let lastProgress = null;
-  const emitProgress = (type, run = null) => {
+  const emitProgress = (type, run = null, jobs = []) => {
+    const completedJobs = jobs.filter((job) => job.status === "completed");
+    const failedJobs = jobs.filter((job) => job.conclusion && job.conclusion !== "success" && job.conclusion !== "skipped");
+    const activeJobs = jobs.filter((job) => job.status && job.status !== "completed");
     const event = {
       type,
       repository: `${owner}/${name}`,
@@ -558,7 +581,11 @@ async function waitForGitHubWorkflowRunCompletion(repository, {
       runId: run?.id ?? null,
       url: run?.url ?? null,
       status: run?.status ?? null,
-      conclusion: run?.conclusion ?? null
+      conclusion: run?.conclusion ?? null,
+      jobs,
+      activeJobs,
+      completedJobs,
+      failedJobs
     };
     lastProgress = event;
     onProgress?.(event);
@@ -587,15 +614,10 @@ async function waitForGitHubWorkflowRunCompletion(repository, {
           run_id: match.id
         });
         const normalized = normalizeWorkflowRun(current.data);
+        const progressJobs = await listWorkflowJobsForProgress(client, owner, name, match.id);
         if (normalized.status === "completed") {
-          emitProgress("completed", normalized);
-          const jobs = await client.rest.actions.listJobsForWorkflowRun({
-            owner,
-            repo: name,
-            run_id: match.id,
-            per_page: 100
-          });
-          const normalizedJobs = jobs.data.jobs.map((job) => normalizeWorkflowJob(job));
+          const normalizedJobs = progressJobs;
+          emitProgress("completed", normalized, normalizedJobs);
           return {
             status: "completed",
             repository: `${owner}/${name}`,
@@ -603,13 +625,15 @@ 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,
             failedJobs: normalizedJobs.filter((job) => job.conclusion && job.conclusion !== "success" && job.conclusion !== "skipped")
           };
         }
-        emitProgress("running", normalized);
+        emitProgress("running", normalized, progressJobs);
         await sleep(pollSeconds * 1e3);
       }
     } catch (error) {

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/scripts/check-build-warnings.js

@@ -4,17 +4,31 @@ import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 
 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;
 
 for (let index = 0; index < args.length; index += 1) {
 	const arg = args[index];
+	if (arg === '--no-default-policy') {
+		useDefaultPolicy = false;
+		continue;
+	}
 	if (arg === '--allow') {
 		const pattern = args[index + 1];
 		if (!pattern) {
 			throw new Error('Missing value for --allow.');
 		}
-		allowlisted.push(new RegExp(pattern));
+		allowlisted.push({
+			label: `custom:${pattern}`,
+			pattern: new RegExp(pattern),
+		});
 		index += 1;
 		continue;
 	}
@@ -22,17 +36,25 @@ for (let index = 0; index < args.length; index += 1) {
 }
 
 if (files.length === 0) {
-	throw new Error('Usage: node check-build-warnings.mjs <log-file> [<log-file> ...] [--allow <regex>]');
+	throw new Error('Usage: node check-build-warnings.mjs <log-file> [<log-file> ...] [--allow <regex>] [--no-default-policy]');
 }
 
 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;
 		}
-		if (allowlisted.some((pattern) => pattern.test(line))) {
+		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);
@@ -47,4 +69,11 @@ 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}`);
+	}
+}
 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;
     } & {
@@ -798,6 +804,8 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
     worktreePath: string | null;
     primaryRoot: string | null;
     ciMode: "hosted" | "off";
+    fresh: boolean;
+    freshArchivedRuns: never[];
     mode: TreeseedWorkflowMode;
     mergeStrategy: string;
     level: string;
@@ -844,6 +852,11 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
     mode: "root-only";
     mergeStrategy: string;
     level: "patch" | "major" | "minor";
+    fresh: boolean;
+    freshArchivedRuns: {
+        runId: string;
+        reasons: string[];
+    }[];
     resumed: boolean;
     resumedRunId: string | null;
     autoResumed: boolean;
@@ -879,6 +892,7 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
         targetBranch: string;
         commitSha: string;
     };
+    hostedDeploymentState: Record<string, unknown>[];
     finalBranch: string;
     pushStatus: {
         stagingPushed: boolean;
@@ -898,6 +912,8 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
         conclusion: null;
         runId: null;
         url: null;
+        createdAt: null;
+        updatedAt: null;
     }[];
 } & {
     finalState?: WorkflowStatePayload;
@@ -909,6 +925,11 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
     mode: "recursive-workspace";
     mergeStrategy: string;
     level: "patch" | "major" | "minor";
+    fresh: boolean;
+    freshArchivedRuns: {
+        runId: string;
+        reasons: string[];
+    }[];
     resumed: boolean;
     resumedRunId: string | null;
     autoResumed: boolean;
@@ -956,6 +977,7 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
         targetBranch: string;
         commitSha: string;
     };
+    hostedDeploymentState: Record<string, unknown>[];
     finalBranch: string;
     pushStatus: {
         stagingPushed: boolean;
@@ -975,6 +997,8 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
         conclusion: null;
         runId: null;
         url: null;
+        createdAt: null;
+        updatedAt: null;
     })[];
 } & {
     finalState?: WorkflowStatePayload;
@@ -1041,6 +1065,11 @@ export declare function workflowRecover(helpers: WorkflowOperationHelpers, input
         } | null;
         classification: import("./runs.ts").TreeseedWorkflowRunClassification;
     }[];
+    markedObsoleteRun: {
+        runId: string;
+        command: TreeseedWorkflowRunCommand;
+        reason: string;
+    } | null;
     selectedRun: TreeseedWorkflowRunJournal | null;
     runCount: number;
 } & {

package/dist/workflow/operations.js

@@ -36,6 +36,7 @@ import {
   ensureGeneratedWranglerConfig,
   finalizeDeploymentState,
   loadDeployState,
+  recordHostedDeploymentState,
   runRemoteD1Migrations,
   validateDeployPrerequisites,
   validateDestroyPrerequisites
@@ -254,13 +255,30 @@ function resolveRootReleaseSubmoduleConflicts(root, selectedPackageNames) {
   const packagePaths = new Set(packages.map((pkg) => pkg.repoPath));
   const unresolved = unresolvedMergePaths(gitRoot);
   if (unresolved.length === 0 || unresolved.some((filePath) => !packagePaths.has(filePath))) {
-    return false;
+    return {
+      resolved: false,
+      allUnresolvedPathsWerePackagePointers: unresolved.length > 0 && unresolved.every((filePath) => packagePaths.has(filePath)),
+      unresolvedPaths: unresolved,
+      entries: []
+    };
   }
+  const entries = [];
   for (const pkg of packages) {
     syncBranchWithOrigin(pkg.dir, PRODUCTION_BRANCH);
     run("git", ["add", pkg.repoPath], { cwd: gitRoot });
+    entries.push({
+      packageName: pkg.name,
+      path: pkg.repoPath,
+      targetBranch: PRODUCTION_BRANCH,
+      resolvedCommit: headCommit(pkg.dir)
+    });
   }
-  return true;
+  return {
+    resolved: true,
+    allUnresolvedPathsWerePackagePointers: true,
+    unresolvedPaths: unresolved,
+    entries
+  };
 }
 function unlinkWorkflowWorkspaceLinks(root, helpers, mode = "auto") {
   if (!shouldManageWorkspaceLinks(mode, helpers.context.env)) {
@@ -401,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 {
@@ -1060,6 +1110,123 @@ function releasePlanMatchesCurrentHeads(plan, rootRepo, packageReports) {
 function releaseRunHasCompletedMutation(journal) {
   return journal.steps.some((step) => step.status === "completed" && step.id !== "release-plan" && step.id !== "workspace-unlink");
 }
+function generatedReleaseMetadataFiles(repoDir) {
+  return ["package.json", "package-lock.json", "npm-shrinkwrap.json"].filter((filePath) => {
+    if (existsSync(resolve(repoDir, filePath))) return true;
+    try {
+      run("git", ["ls-files", "--error-unmatch", filePath], { cwd: repoDir, capture: true });
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+function collectReleaseCleanupSnapshot(root, selectedPackageNames) {
+  return {
+    repos: [
+      {
+        name: "@treeseed/market",
+        path: repoRoot(root),
+        branch: currentBranch(repoRoot(root)) || null,
+        files: generatedReleaseMetadataFiles(repoRoot(root))
+      },
+      ...checkedOutWorkspacePackageRepos(root).filter((pkg) => selectedPackageNames.has(pkg.name)).map((pkg) => ({
+        name: pkg.name,
+        path: pkg.dir,
+        branch: currentBranch(pkg.dir) || null,
+        files: generatedReleaseMetadataFiles(pkg.dir)
+      }))
+    ]
+  };
+}
+function restoreReleaseGeneratedMetadata(repo) {
+  const restored = [];
+  const skipped = [];
+  for (const filePath of repo.files) {
+    const status = run("git", ["status", "--porcelain", "--", filePath], { cwd: repo.path, capture: true });
+    if (!status.trim()) {
+      skipped.push(filePath);
+      continue;
+    }
+    run("git", ["restore", "--staged", "--worktree", "--", filePath], { cwd: repo.path, capture: true });
+    restored.push(filePath);
+  }
+  return { restored, skipped };
+}
+function cleanupFailedReleaseLocalState(root, helpers, snapshot, workspaceLinksMode) {
+  const report = { restored: [], skipped: [], manualReview: [] };
+  try {
+    ensureWorkflowWorkspaceLinks(root, helpers, workspaceLinksMode ?? "auto");
+  } catch (error) {
+    report.manualReview.push({
+      scope: "workspace-links",
+      reason: error instanceof Error ? error.message : String(error)
+    });
+  }
+  if (!snapshot) {
+    report.skipped.push({ scope: "release-metadata", reason: "cleanup snapshot was not recorded before failure" });
+    return report;
+  }
+  for (const repo of snapshot.repos) {
+    try {
+      const restored = restoreReleaseGeneratedMetadata(repo);
+      if (repo.branch && currentBranch(repo.path) !== repo.branch) {
+        checkoutBranch(repo.path, repo.branch);
+      }
+      if (restored.restored.length > 0) {
+        report.restored.push({ repo: repo.name, path: repo.path, files: restored.restored });
+      }
+      if (restored.skipped.length > 0) {
+        report.skipped.push({ repo: repo.name, path: repo.path, files: restored.skipped, reason: "unchanged" });
+      }
+    } catch (error) {
+      report.manualReview.push({
+        repo: repo.name,
+        path: repo.path,
+        branch: repo.branch,
+        files: repo.files,
+        reason: error instanceof Error ? error.message : String(error),
+        nextCommand: repo.branch ? `git -C ${repo.path} restore --staged --worktree -- ${repo.files.join(" ")} && git -C ${repo.path} checkout ${repo.branch}` : null
+      });
+    }
+  }
+  return report;
+}
+function prepareFreshReleaseRun(root, branch, rootRepo, packageReports) {
+  if (branch !== STAGING_BRANCH) return { archived: [], blockers: [] };
+  const currentHeads = Object.fromEntries([
+    [rootRepo.name, rootRepo.commitSha ?? null],
+    ...packageReports.map((report) => [report.name, report.commitSha ?? null])
+  ]);
+  const archived = [];
+  const blockers = [];
+  for (const journal of listInterruptedWorkflowRuns(root).filter((entry) => entry.command === "release")) {
+    const classification = classifyWorkflowRunJournal(journal, {
+      currentBranch: branch,
+      currentHeads
+    });
+    if (classification.state === "stale") {
+      archiveWorkflowRun(root, journal.runId, {
+        ...classification,
+        reasons: ["fresh release superseded stale failed release", ...classification.reasons]
+      });
+      archived.push({ runId: journal.runId, reasons: classification.reasons });
+      continue;
+    }
+    if (classification.state === "resumable" && releaseRunHasCompletedMutation(journal)) {
+      blockers.push(`${journal.runId}: completed release mutations and is still safe to resume. Mark it obsolete with \`npx trsd recover --obsolete ${journal.runId} --reason "superseded by fresh release"\` before using --fresh.`);
+    }
+  }
+  if (blockers.length > 0) {
+    workflowError("release", "validation_failed", [
+      "Treeseed release --fresh will not bypass a resumable partial release that already completed release mutations.",
+      ...blockers
+    ].join("\n"), {
+      details: { archived, blockers }
+    });
+  }
+  return { archived, blockers };
+}
 function findAutoResumableReleaseRun(root, branch, rootRepo, packageReports) {
   if (branch !== STAGING_BRANCH) return null;
   return listInterruptedWorkflowRuns(root).find((journal) => {
@@ -3323,8 +3490,10 @@ async function workflowRelease(helpers, input) {
       const rootRepo = createWorkspaceRootRepoReport(root);
       const packageReports = createWorkspacePackageReports(root);
       const explicitResumeRunId = helpers.context.workflow?.resumeRunId ?? null;
-      const autoResumeRun = executionMode === "execute" && !explicitResumeRunId ? findAutoResumableReleaseRun(root, session.branchName, rootRepo, packageReports) : null;
-      const planAutoResumeRun = executionMode === "plan" ? findAutoResumableReleaseRun(root, session.branchName, rootRepo, packageReports) : null;
+      const freshRelease = input.fresh === true && !explicitResumeRunId;
+      const freshPreparation = freshRelease && executionMode === "execute" ? prepareFreshReleaseRun(root, session.branchName, rootRepo, packageReports) : { archived: [], blockers: [] };
+      const autoResumeRun = executionMode === "execute" && !explicitResumeRunId && !freshRelease ? findAutoResumableReleaseRun(root, session.branchName, rootRepo, packageReports) : null;
+      const planAutoResumeRun = executionMode === "plan" && input.fresh !== true ? findAutoResumableReleaseRun(root, session.branchName, rootRepo, packageReports) : null;
       const effectiveInput = autoResumeRun ? autoResumeRun.input : input;
       const level = effectiveInput.bump ?? "patch";
       const ciMode = normalizeCiMode(effectiveInput.ciMode, "release");
@@ -3345,6 +3514,8 @@ async function workflowRelease(helpers, input) {
         return buildWorkflowResult("release", root, {
           ...plannedRelease,
           ciMode,
+          fresh: input.fresh === true,
+          freshArchivedRuns: [],
           ...worktreePayload(root, effectiveInput.worktreeMode),
           autoResumeCandidate: planAutoResumeRun ? {
             runId: planAutoResumeRun.runId,
@@ -3372,6 +3543,7 @@ async function workflowRelease(helpers, input) {
           gitDependencyProtocol: effectiveInput.gitDependencyProtocol ?? "preserve-origin",
           gitRemoteWriteMode: effectiveInput.gitRemoteWriteMode ?? "ssh-pushurl",
           ciMode,
+          fresh: input.fresh === true,
           worktreeMode: effectiveInput.worktreeMode ?? "auto",
           workspaceLinks: effectiveInput.workspaceLinks ?? "auto"
         },
@@ -3404,6 +3576,7 @@ async function workflowRelease(helpers, input) {
       if (autoResumeRun) {
         helpers.write(`[workflow][resume] Resuming interrupted release ${autoResumeRun.runId} on ${STAGING_BRANCH}.`);
       }
+      let releaseCleanupSnapshot = null;
       try {
         const releasePlan = await executeJournalStep(root, workflowRun.runId, "release-plan", () => plannedRelease);
         const effectivePackageSelection = releasePlanPackageSelection(releasePlan.packageSelection);
@@ -3485,12 +3658,15 @@ 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 = {
             mode,
             mergeStrategy: "merge-commit",
             level,
+            fresh: input.fresh === true,
+            freshArchivedRuns: freshPreparation.archived,
             resumed: workflowRun.resumed,
             resumedRunId: workflowRun.resumed ? workflowRun.runId : null,
             autoResumed: autoResumeRun != null,
@@ -3506,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,
@@ -3527,6 +3704,7 @@ async function workflowRelease(helpers, input) {
             prepareReleaseBranches(pkg.dir);
           }
         }
+        releaseCleanupSnapshot = collectReleaseCleanupSnapshot(root, effectiveSelectedPackageNames);
         const metadata = await executeJournalStep(root, workflowRun.runId, "prepare-release-metadata", () => {
           const releasedPackageDevTags2 = Object.fromEntries(
             checkedOutWorkspacePackageRepos(root).filter((pkg) => effectiveSelectedPackageNames.has(pkg.name)).map((pkg) => {
@@ -3641,17 +3819,22 @@ async function workflowRelease(helpers, input) {
           pushBranch(gitRoot, STAGING_BRANCH);
           const stagingCommit = headCommit(gitRoot);
           let released;
+          let submoduleReconciliation = null;
           try {
             released = mergeBranchIntoTarget(root, {
               sourceBranch: STAGING_BRANCH,
               targetBranch: PRODUCTION_BRANCH,
               message: `release: ${STAGING_BRANCH} -> ${PRODUCTION_BRANCH}`,
-              pushTarget: false
+              pushTarget: false,
+              quietMerge: true
             });
           } catch (error) {
-            if (!resolveRootReleaseSubmoduleConflicts(root, effectiveSelectedPackageNames)) {
+            const reconciliation = resolveRootReleaseSubmoduleConflicts(root, effectiveSelectedPackageNames);
+            if (!reconciliation.resolved) {
               throw error;
             }
+            helpers.write(`[release][reconcile] Resolving generated package pointer reconciliation for ${reconciliation.entries.map((entry) => String(entry.path)).join(", ")}.`);
+            submoduleReconciliation = reconciliation;
             commitAllIfChanged(gitRoot, `release: ${STAGING_BRANCH} -> ${PRODUCTION_BRANCH}`);
             released = { commitSha: headCommit(gitRoot) };
           }
@@ -3671,7 +3854,8 @@ async function workflowRelease(helpers, input) {
             stagingCommit,
             releasedCommit,
             mergeCommit: released.commitSha,
-            tag
+            tag,
+            submoduleReconciliation
           };
         });
         rootRepo.committed = true;
@@ -3721,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", () => {
@@ -3752,6 +3937,8 @@ async function workflowRelease(helpers, input) {
           mode,
           mergeStrategy: "merge-commit",
           level,
+          fresh: input.fresh === true,
+          freshArchivedRuns: freshPreparation.archived,
           resumed: workflowRun.resumed,
           resumedRunId: workflowRun.resumed ? workflowRun.runId : null,
           autoResumed: autoResumeRun != null,
@@ -3770,6 +3957,7 @@ async function workflowRelease(helpers, input) {
           rootRepo,
           releaseCandidate,
           releaseBackMerge,
+          hostedDeploymentState,
           finalBranch: currentBranch(gitRoot) || STAGING_BRANCH,
           pushStatus: {
             stagingPushed: true,
@@ -3792,7 +3980,7 @@ async function workflowRelease(helpers, input) {
           ])
         });
       } catch (error) {
-        ensureWorkflowWorkspaceLinks(root, helpers, effectiveInput.workspaceLinks ?? "auto");
+        const localCleanup = cleanupFailedReleaseLocalState(root, helpers, releaseCleanupSnapshot, effectiveInput.workspaceLinks ?? "auto");
         const latestJournal = readWorkflowRunJournal(root, workflowRun.runId);
         const lastCompleted = [...latestJournal?.steps ?? []].reverse().find((step) => step.status === "completed") ?? null;
         const nextPending = latestJournal?.steps.find((step) => step.status === "pending") ?? null;
@@ -3808,14 +3996,22 @@ ${repair.blockers.join("\n")}`, "stderr");
         } catch (repairError) {
           helpers.write(`[release][recovery] Package repo repair failed: ${repairError instanceof Error ? repairError.message : String(repairError)}`, "stderr");
         }
-        helpers.write(`Safe recovery: npx trsd release --${level} --json, or inspect with npx trsd recover --json.`, "stderr");
+        if (localCleanup.restored.length > 0) {
+          helpers.write(`[release][recovery] Restored generated release metadata in ${localCleanup.restored.length} repo(s).`, "stderr");
+        }
+        if (localCleanup.manualReview.length > 0) {
+          helpers.write(`[release][recovery] Local cleanup needs manual review:
+${localCleanup.manualReview.map((entry) => `- ${String(entry.repo ?? entry.scope ?? "repo")}: ${String(entry.reason ?? "unknown")}`).join("\n")}`, "stderr");
+        }
+        helpers.write(`Safe recovery: npx trsd release --${level} --json, npx trsd release --${level} --fresh --json, or inspect with npx trsd recover --json.`, "stderr");
         failWorkflowRun(root, workflowRun.runId, error, {
           resumable: true,
           runId: workflowRun.runId,
           command: "release",
           message: `Resume the interrupted release on ${STAGING_BRANCH}. Last phase: ${lastCompleted?.id ?? "not-started"}; next phase: ${nextPending?.id ?? "none"}.`,
           recoverCommand: "npx trsd recover --json",
-          resumeCommand: `npx trsd release --${level} --json`
+          resumeCommand: `npx trsd release --${level} --json`,
+          localCleanup
         });
         throw error;
       }
@@ -3909,7 +4105,29 @@ async function workflowRecover(helpers, input = {}) {
         currentBranch: session.branchName,
         currentHeads
       });
-      const interruptedRuns = classifiedRuns.filter((entry) => entry.classification.state === "resumable").map(({ journal }) => ({
+      const markedObsoleteRun = input.obsoleteRunId ? (() => {
+        const entry = classifiedRuns.find((candidate) => candidate.journal.runId === input.obsoleteRunId);
+        if (!entry) {
+          workflowError("recover", "validation_failed", `Treeseed recover could not find workflow run ${input.obsoleteRunId}.`);
+        }
+        const reason = input.obsoleteReason?.trim() || "marked obsolete by operator";
+        const classification = {
+          state: "obsolete",
+          reasons: [reason],
+          classifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        archiveWorkflowRun(root, entry.journal.runId, classification);
+        return {
+          runId: entry.journal.runId,
+          command: entry.journal.command,
+          reason
+        };
+      })() : null;
+      const effectiveClassifiedRuns = markedObsoleteRun ? classifyWorkflowRunJournals(root, {
+        currentBranch: session.branchName,
+        currentHeads
+      }) : classifiedRuns;
+      const interruptedRuns = effectiveClassifiedRuns.filter((entry) => entry.classification.state === "resumable").map(({ journal }) => ({
         runId: journal.runId,
         command: journal.command,
         status: journal.status,
@@ -3919,7 +4137,7 @@ async function workflowRecover(helpers, input = {}) {
         failure: journal.failure,
         resumeCommand: `treeseed resume ${journal.runId}`
       }));
-      const staleRuns = classifiedRuns.filter((entry) => entry.classification.state === "stale").map(({ journal, classification }) => ({
+      const staleRuns = effectiveClassifiedRuns.filter((entry) => entry.classification.state === "stale").map(({ journal, classification }) => ({
         runId: journal.runId,
         command: journal.command,
         status: journal.status,
@@ -3929,7 +4147,7 @@ async function workflowRecover(helpers, input = {}) {
         failure: journal.failure,
         classification
       }));
-      const obsoleteRuns = classifiedRuns.filter((entry) => entry.classification.state === "obsolete").map(({ journal, classification }) => ({
+      const obsoleteRuns = effectiveClassifiedRuns.filter((entry) => entry.classification.state === "obsolete").map(({ journal, classification }) => ({
         runId: journal.runId,
         command: journal.command,
         status: journal.status,
@@ -3952,6 +4170,7 @@ async function workflowRecover(helpers, input = {}) {
           staleRuns,
           obsoleteRuns,
           prunedRuns,
+          markedObsoleteRun,
           selectedRun,
           runCount: journals.length
         },

package/dist/workflow/runs.js

@@ -247,6 +247,16 @@ function isReleaseGateOnlyCompletion(journal) {
   const pendingStep = journal.steps.find((step) => step.status === "pending");
   return pendingStep?.id === "release-root-gates" || pendingStep?.id === "release-back-merge" || pendingStep?.id === "cleanup-dev-tags";
 }
+function releaseStepData(journal, stepId) {
+  return stringRecord(journal.steps.find((step) => step.id === stepId)?.data);
+}
+function expectedPackageHeadAfterReleaseGate(journal, packageName) {
+  const data = releaseStepData(journal, `release-${packageName}`);
+  const backMerge = stringRecord(data?.backMerge);
+  if (typeof backMerge?.commitSha === "string") return backMerge.commitSha;
+  if (typeof data?.commitSha === "string") return data.commitSha;
+  return null;
+}
 function classifyWorkflowRunJournal(journal, options = {}) {
   const reasons = [];
   const now = options.now ?? nowIso();
@@ -283,6 +293,22 @@ function classifyWorkflowRunJournal(journal, options = {}) {
     reasons.push(`current branch ${options.currentBranch} does not match journal branch ${journal.session.branchName}`);
   }
   const releaseGateOnlyCompletion = isReleaseGateOnlyCompletion(journal);
+  if (journal.command === "release" && options.currentHeads && releaseGateOnlyCompletion) {
+    const rootRelease = releaseStepData(journal, "release-root");
+    const expectedRootHead = typeof rootRelease?.stagingCommit === "string" ? rootRelease.stagingCommit : null;
+    const rootHead = options.currentHeads["@treeseed/market"];
+    if (rootHead && expectedRootHead && rootHead !== expectedRootHead) {
+      reasons.push(`market staging head changed from ${expectedRootHead} to ${rootHead}`);
+    }
+    const releasePlan = releaseStepData(journal, "release-plan");
+    for (const name of selectedReleasePackageNames(releasePlan)) {
+      const currentHead = options.currentHeads[name];
+      const expectedHead = expectedPackageHeadAfterReleaseGate(journal, name);
+      if (currentHead && expectedHead && currentHead !== expectedHead) {
+        reasons.push(`${name} staging head changed from ${expectedHead} to ${currentHead}`);
+      }
+    }
+  }
   if (journal.command === "release" && options.currentHeads && !releaseGateOnlyCompletion) {
     const releasePlan = stringRecord(journal.steps.find((step) => step.id === "release-plan")?.data);
     if (releasePlan) {

package/dist/workflow-state.d.ts

@@ -189,6 +189,7 @@ export type TreeseedWorkflowState = {
     releaseHistory: {
         stagingAheadMain: number | null;
         stagingBehindMain: number | null;
+        unreleasedStagingCommits: number | null;
         backMerged: boolean | null;
         detail: string;
     };

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,16 +274,20 @@ 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."
     };
@@ -414,6 +419,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,
@@ -527,8 +534,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 +754,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." });
       }

package/dist/workflow.d.ts

@@ -25,6 +25,7 @@ export type TreeseedWorkflowRecovery = {
     recoverCommand?: string | null;
     resumeCommand?: string | null;
     lock?: Record<string, unknown> | null;
+    localCleanup?: Record<string, unknown> | null;
 };
 export type TreeseedWorkflowExecutionMode = 'execute' | 'plan';
 export type TreeseedWorkflowWorktreeMode = 'auto' | 'on' | 'off';
@@ -214,6 +215,7 @@ export type TreeseedReleaseInput = {
     ciMode?: TreeseedWorkflowCiMode;
     worktreeMode?: TreeseedWorkflowWorktreeMode;
     workspaceLinks?: 'auto' | 'off';
+    fresh?: boolean;
     plan?: boolean;
     dryRun?: boolean;
 };
@@ -223,6 +225,8 @@ export type TreeseedResumeInput = {
 export type TreeseedRecoverInput = {
     runId?: string;
     pruneStale?: boolean;
+    obsoleteRunId?: string;
+    obsoleteReason?: string;
 };
 export type TreeseedDestroyInput = {
     target?: 'local' | 'staging' | 'prod';

package/package.json

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

package/templates/github/deploy.workflow.yml

@@ -184,11 +184,9 @@ jobs:
           set -euo pipefail
           npm run verify:local 2>&1 | tee verify.log
           if test -f ./packages/sdk/scripts/check-build-warnings.mjs; then
-            node ./packages/sdk/scripts/check-build-warnings.mjs verify.log \
-              --allow 'Module "url" has been externalized for browser compatibility, imported by ".*libsodium-sumo.*"'
+            node ./packages/sdk/scripts/check-build-warnings.mjs verify.log
           elif test -f ./node_modules/@treeseed/sdk/dist/scripts/check-build-warnings.js; then
-            node ./node_modules/@treeseed/sdk/dist/scripts/check-build-warnings.js verify.log \
-              --allow 'Module "url" has been externalized for browser compatibility, imported by ".*libsodium-sumo.*"'
+            node ./node_modules/@treeseed/sdk/dist/scripts/check-build-warnings.js verify.log
           else
             echo "Unable to resolve @treeseed/sdk warning scanner entrypoint."
             exit 1