@treeseed/sdk 0.12.61 → 0.12.62

package/dist/workflow/operations.js

@@ -478,6 +478,14 @@ async function waitForWorkflowGates(operation, gates, ciMode, options = {}) {
         env: gateEnv,
         onProgress: options.onProgress
       });
+    } else if (result.status === "completed" && result.conclusion !== "success" && options.retryFailedOnce) {
+      const retry = await rerunGitHubActionsFailedJobs(result, gateEnv);
+      options.onProgress?.(`[${operation}][gate][${gateWithTimeout.name}] Retrying failed jobs once for adopted immutable release run ${retry.runId}.`);
+      result = await waitForGitHubActionsGate(gateWithTimeout, {
+        operation,
+        env: gateEnv,
+        onProgress: options.onProgress
+      });
     }
     const normalized = {
       name: gateWithTimeout.name,
@@ -1319,6 +1327,62 @@ function ensureReleaseTag(repoDir, tagName, commitSha, message) {
     remote: remoteCommit ? "existing" : "pushed"
   };
 }
+async function adoptPublishedPackageRelease(pkg, version) {
+  const commitSha = tagCommitSha(pkg.dir, version);
+  if (!commitSha) return null;
+  const remoteCommit = remoteTagCommit(pkg.dir, version);
+  if (remoteCommit !== commitSha) {
+    throw new Error(`Release tag ${version} for ${pkg.name} is inconsistent: local=${commitSha}, origin=${remoteCommit ?? "(missing)"}.`);
+  }
+  let taggedManifest;
+  try {
+    taggedManifest = JSON.parse(runGit(["show", `${commitSha}:package.json`], { cwd: pkg.dir, capture: true }));
+  } catch (error) {
+    throw new Error(`Release tag ${version} for ${pkg.name} does not contain a valid package.json: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (taggedManifest.name !== pkg.name || taggedManifest.version !== version) {
+    throw new Error(`Release tag ${version} does not identify ${pkg.name}@${version}.`);
+  }
+  if (hasMeaningfulChanges(pkg.dir)) {
+    throw new Error(`Cannot adopt published ${pkg.name}@${version} while ${pkg.dir} has uncommitted changes.`);
+  }
+  const publishedArtifacts = await verifyPublishedReleaseArtifacts(/* @__PURE__ */ new Map([[pkg.name, version]]));
+  const previousStagingHead = remoteHeadCommit(pkg.dir, STAGING_BRANCH);
+  if (previousStagingHead !== commitSha) {
+    runGit([
+      "push",
+      `--force-with-lease=refs/heads/${STAGING_BRANCH}:${previousStagingHead}`,
+      "origin",
+      `${commitSha}:refs/heads/${STAGING_BRANCH}`
+    ], { cwd: pkg.dir });
+  }
+  const previousProductionHead = remoteHeadCommit(pkg.dir, PRODUCTION_BRANCH);
+  if (previousProductionHead !== commitSha) {
+    promoteCommitToProductionBranch(pkg.dir, commitSha);
+  }
+  if (currentBranch(pkg.dir) !== STAGING_BRANCH) {
+    checkoutBranch(pkg.dir, STAGING_BRANCH);
+  }
+  if (headCommit(pkg.dir) !== commitSha) {
+    runGit(["reset", "--hard", commitSha], { cwd: pkg.dir });
+  }
+  const observedStagingHead = remoteHeadCommit(pkg.dir, STAGING_BRANCH);
+  const observedProductionHead = remoteHeadCommit(pkg.dir, PRODUCTION_BRANCH);
+  if (headCommit(pkg.dir) !== commitSha || observedStagingHead !== commitSha || observedProductionHead !== commitSha) {
+    throw new Error(`Published release adoption failed for ${pkg.name}@${version}; local=${headCommit(pkg.dir)}, staging=${observedStagingHead}, main=${observedProductionHead}, expected=${commitSha}.`);
+  }
+  return {
+    name: pkg.name,
+    version,
+    commit: { commitSha, status: "adopted-published-tag" },
+    tag: { tagName: version, local: "existing", remote: "existing" },
+    branches: {
+      staging: previousStagingHead === commitSha ? "existing" : "restored",
+      production: previousProductionHead === commitSha ? "existing" : "restored"
+    },
+    publishedArtifacts
+  };
+}
 function promoteCommitToProductionBranch(repoDir, commitSha) {
   const expectedBefore = remoteBranchExists(repoDir, PRODUCTION_BRANCH) ? remoteHeadCommit(repoDir, PRODUCTION_BRANCH) : null;
   const lease = expectedBefore ? `--force-with-lease=refs/heads/${PRODUCTION_BRANCH}:${expectedBefore}` : "--force-with-lease";
@@ -2039,7 +2103,8 @@ function findAutoResumableReleaseRun(root, branch, rootRepo, packageReports, opt
     }
     const classification = classifyWorkflowRunJournal(journal, {
       currentBranch: branch,
-      currentHeads
+      currentHeads,
+      acceptedReleaseHeads: acceptedPublishedReleaseHeads(root, journal, currentHeads)
     });
     if (classification.state !== "resumable") {
       if (options.archiveStale && classification.state === "stale") {
@@ -2061,6 +2126,45 @@ function findAutoResumableReleaseRun(root, branch, rootRepo, packageReports, opt
     return releasePlan ? releasePlanMatchesCurrentHeads(releasePlan, rootRepo, packageReports) : true;
   }) ?? null;
 }
+function acceptedPublishedReleaseHeads(root, journal, currentHeads) {
+  if (journal.command !== "release") return {};
+  const plan = stringRecord(journal.steps.find((step) => step.id === "release-plan")?.data);
+  const plannedVersions = stringRecord(plan?.plannedVersions);
+  if (!plannedVersions) return {};
+  const repos = new Map(checkedOutWorkspacePackageRepos(root).map((repo) => [repo.name, repo.dir]));
+  const accepted = {};
+  for (const [name, versionValue] of Object.entries(plannedVersions)) {
+    if (name === "@treeseed/market" || typeof versionValue !== "string") continue;
+    const repoDir = repos.get(name);
+    const currentHead = currentHeads[name];
+    if (!repoDir || !currentHead) continue;
+    let manifestVersion = null;
+    try {
+      manifestVersion = JSON.parse(readFileSync(resolve(repoDir, "package.json"), "utf8")).version ?? null;
+    } catch {
+      continue;
+    }
+    const tagHead = tagCommitSha(repoDir, versionValue);
+    const remoteTagHead = remoteTagCommit(repoDir, versionValue);
+    const productionHead = remoteHeadCommit(repoDir, PRODUCTION_BRANCH);
+    const stagingHead = remoteHeadCommit(repoDir, STAGING_BRANCH);
+    const exactPublishedHead = tagHead === currentHead && productionHead === currentHead && stagingHead === currentHead;
+    const boundedInterruptedRetry = tagHead.length > 0 && remoteTagHead === tagHead && !hasMeaningfulChanges(repoDir) && [productionHead, stagingHead].every((head) => head === currentHead || head === tagHead);
+    if (manifestVersion !== versionValue || !exactPublishedHead && !boundedInterruptedRetry) {
+      if (process.env.TREESEED_RECONCILE_TRACE === "1") {
+        process.stderr.write(`[release][resume-adoption] package=${name} accepted=false manifest=${manifestVersion === versionValue} tag=${tagHead === currentHead} remoteTag=${remoteTagHead === tagHead} main=${productionHead === currentHead} staging=${stagingHead === currentHead} bounded=${boundedInterruptedRetry}
+`);
+      }
+      continue;
+    }
+    accepted[name] = currentHead;
+    if (process.env.TREESEED_RECONCILE_TRACE === "1") {
+      process.stderr.write(`[release][resume-adoption] package=${name} accepted=true
+`);
+    }
+  }
+  return accepted;
+}
 async function executeJournalStep(root, runId, stepId, action, options = {}) {
   const current = readWorkflowRunJournal(root, runId);
   const step = current?.steps.find((entry) => entry.id === stepId) ?? null;
@@ -2391,21 +2495,32 @@ async function runReleaseNpmInstall(repoDir, options = {}) {
   if (repoDir === options.workspaceRoot && lockfileRootMatchesManifest(repoDir)) {
     return { status: "skipped", reason: "root-lockfile-already-matches", attempts: 0 };
   }
-  const args = ["install", "--package-lock-only", "--ignore-scripts", "--prefer-offline", "--workspaces=false", "--no-audit", "--no-fund"];
-  const spawnCommand = npmCommandForWorkflowSpawn(args);
+  const baseArgs = ["install", "--package-lock-only", "--ignore-scripts", "--workspaces=false", "--no-audit", "--no-fund"];
+  const propagationDelaysMs = [15e3, 3e4, 6e4, 12e4, 18e4];
+  const startedAt = Date.now();
   let lastDetail = "";
-  for (let attempt = 1; attempt <= 3; attempt += 1) {
-    process.stderr.write(`[release][restore] repository=${repoDir} phase=package-lock attempt=${attempt} elapsed=0s
+  for (let attempt = 1; attempt <= propagationDelaysMs.length + 1; attempt += 1) {
+    const args = [...baseArgs, attempt === 1 ? "--prefer-offline" : "--prefer-online"];
+    const spawnCommand = npmCommandForWorkflowSpawn(args);
+    process.stderr.write(`[release][restore] repository=${repoDir} phase=package-lock attempt=${attempt} elapsed=${Math.ceil((Date.now() - startedAt) / 1e3)}s
 `);
     const result = await waitForReleaseInstall(spawnCommand.command, spawnCommand.args, repoDir, attempt);
     if (result.status === 0) {
       return { status: "completed", reason: null, attempts: attempt };
     }
     lastDetail = result.detail;
-    if (!/No matching version found|notarget|ETARGET|E404/u.test(lastDetail) || attempt === 3) break;
-    await new Promise((resolvePromise) => setTimeout(resolvePromise, 15e3));
+    const propagationDelayMs = propagationDelaysMs[attempt - 1];
+    if (!/No matching version found|notarget|ETARGET|E404/u.test(lastDetail) || propagationDelayMs == null) break;
+    let remainingMs = propagationDelayMs;
+    while (remainingMs > 0) {
+      process.stderr.write(`[release][restore] repository=${repoDir} phase=registry-propagation nextAttempt=${attempt + 1} remaining=${Math.ceil(remainingMs / 1e3)}s elapsed=${Math.ceil((Date.now() - startedAt) / 1e3)}s
+`);
+      const sliceMs = Math.min(15e3, remainingMs);
+      await new Promise((resolvePromise) => setTimeout(resolvePromise, sliceMs));
+      remainingMs -= sliceMs;
+    }
   }
-  throw new Error(lastDetail || `npm ${args.join(" ")} failed`);
+  throw new Error(lastDetail || `npm ${baseArgs.join(" ")} failed`);
 }
 function pathIsWithin(parent, candidate) {
   const path = relative(parent, candidate);
@@ -4676,7 +4791,7 @@ async function workflowSave(helpers, input) {
       const recursiveWorkspace = session.mode === "recursive-workspace";
       const mode = session.mode;
       const executionMode = normalizeExecutionMode(input);
-      const explicitResumeRunId = helpers.context.workflow?.resumeRunId ?? null;
+      const explicitResumeRunId = helpers.context.workflow?.resumeRunId ?? input.resumeRunId ?? null;
       const autoResumeRun = executionMode === "execute" && !explicitResumeRunId ? findAutoResumableSaveRun(root, branch) : null;
       rejectImplicitWorkflowResume("save", autoResumeRun);
       const planAutoResumeRun = null;
@@ -4841,7 +4956,10 @@ async function workflowSave(helpers, input) {
             resumable: true
           }] : []
         ],
-        autoResumeRun ? {
+        explicitResumeRunId ? {
+          ...helpers.context,
+          workflow: { ...helpers.context.workflow ?? {}, resumeRunId: explicitResumeRunId }
+        } : autoResumeRun ? {
           ...helpers.context,
           workflow: {
             ...helpers.context.workflow ?? {},
@@ -5127,7 +5245,7 @@ async function workflowClose(helpers, input) {
       const root = workspaceRoot(tenantRoot);
       const executionMode = normalizeExecutionMode(input);
       const session = resolveTreeseedWorkflowSession(root);
-      const explicitResumeRunId = helpers.context.workflow?.resumeRunId ?? null;
+      const explicitResumeRunId = helpers.context.workflow?.resumeRunId ?? input.resumeRunId ?? null;
       const autoResumeRun = executionMode === "execute" && !explicitResumeRunId ? findAutoResumableTaskRun(root, "close", session.branchName) : null;
       rejectImplicitWorkflowResume("close", autoResumeRun);
       const planAutoResumeRun = null;
@@ -5214,7 +5332,13 @@ async function workflowClose(helpers, input) {
           { id: "workspace-link", description: "Restore local workspace links", repoName: rootRepo.name, repoPath: rootRepo.path, branch: STAGING_BRANCH, resumable: true },
           ...isManagedWorkflowWorktree(root) ? [{ id: "worktree-cleanup", description: "Remove managed workflow worktree", repoName: rootRepo.name, repoPath: rootRepo.path, branch: STAGING_BRANCH, resumable: false }] : []
         ],
-        autoResumeRun ? {
+        explicitResumeRunId ? {
+          ...helpers.context,
+          workflow: {
+            ...helpers.context.workflow ?? {},
+            resumeRunId: explicitResumeRunId
+          }
+        } : autoResumeRun ? {
           ...helpers.context,
           workflow: {
             ...helpers.context.workflow ?? {},
@@ -5611,7 +5735,7 @@ async function workflowStage(helpers, input) {
       const root = workspaceRoot(tenantRoot);
       const executionMode = normalizeExecutionMode(input);
       const session = resolveTreeseedWorkflowSession(root);
-      const explicitResumeRunId = helpers.context.workflow?.resumeRunId ?? null;
+      const explicitResumeRunId = helpers.context.workflow?.resumeRunId ?? input.resumeRunId ?? null;
       const rawAutoResumeRun = executionMode === "execute" && !explicitResumeRunId ? findAutoResumableTaskRun(root, "stage", session.branchName) : null;
       rejectImplicitWorkflowResume("stage", rawAutoResumeRun);
       const autoResumeRun = rawAutoResumeRun?.steps.some((step) => step.id === "preflight") ? rawAutoResumeRun : null;
@@ -6026,7 +6150,9 @@ async function workflowRelease(helpers, input) {
       const rootRepo = createWorkspaceRootRepoReport(root);
       const packageReports = createWorkspacePackageReports(root);
       const releaseHelperRepos = checkedOutReleaseHelperRepos(root);
-      const explicitResumeRunId = helpers.context.workflow?.resumeRunId ?? null;
+      const explicitResumeRunId = helpers.context.workflow?.resumeRunId ?? input.resumeRunId ?? null;
+      const explicitResumeJournal = explicitResumeRunId ? readWorkflowRunJournal(root, explicitResumeRunId) : null;
+      const recordedReleasePlan = explicitResumeJournal?.command === "release" ? stringRecord(explicitResumeJournal.steps.find((step) => step.id === "release-plan")?.data) : null;
       const autoResumeRun = executionMode === "execute" && !explicitResumeRunId && input.fresh !== true ? findAutoResumableReleaseRun(root, session.branchName, rootRepo, packageReports, { archiveStale: false }) : null;
       const planAutoResumeRun = executionMode === "plan" && input.fresh !== true ? findAutoResumableReleaseRun(root, session.branchName, rootRepo, packageReports) : null;
       const effectiveInput = autoResumeRun ? {
@@ -6037,7 +6163,7 @@ async function workflowRelease(helpers, input) {
       const level = effectiveInput.bump ?? "patch";
       const ciMode = normalizeCiMode(effectiveInput.ciMode, "release");
       const packageSelection = session.packageSelection;
-      const plannedRelease = buildReleasePlanSnapshot({
+      const plannedRelease = recordedReleasePlan ?? buildReleasePlanSnapshot({
         root,
         mode: session.mode,
         level,
@@ -6049,12 +6175,14 @@ async function workflowRelease(helpers, input) {
         blockers: []
       });
       const selectedPackageNames = releasePlanPackageSelection(plannedRelease.packageSelection).selected;
-      const blockers = collectReleasePlanBlockers(session, session.mode, selectedPackageNames, {
+      const blockers = explicitResumeJournal ? [] : collectReleasePlanBlockers(session, session.mode, selectedPackageNames, {
         level,
         repairVersionLine: effectiveInput.repairVersionLine === true
       });
-      blockers.push(...collectReleaseHelperRepoBlockers(root));
-      blockers.push(...stageCandidateAttestationBlockers(root));
+      if (!explicitResumeJournal) {
+        blockers.push(...collectReleaseHelperRepoBlockers(root));
+        blockers.push(...stageCandidateAttestationBlockers(root));
+      }
       const selectedVersions = releasePlanVersionMap(plannedRelease.plannedVersions);
       const releaseImageVersions = productionReleaseImageRefVersions(root, selectedVersions);
       const releaseImageRefs = productionReleaseImageRefEnv(releaseImageVersions);
@@ -6160,7 +6288,13 @@ ${blockers.join("\n")}`, {
           { id: "release-back-merge", description: "Back-merge production release history into staging", repoName: rootRepo.name, repoPath: rootRepo.path, branch: STAGING_BRANCH, resumable: true },
           { id: "workspace-link", description: "Restore local workspace links after release", repoName: rootRepo.name, repoPath: rootRepo.path, branch: STAGING_BRANCH, resumable: true }
         ],
-        autoResumeRun ? {
+        explicitResumeRunId ? {
+          ...helpers.context,
+          workflow: {
+            ...helpers.context.workflow ?? {},
+            resumeRunId: explicitResumeRunId
+          }
+        } : autoResumeRun ? {
           ...helpers.context,
           workflow: {
             ...helpers.context.workflow ?? {},
@@ -6238,6 +6372,9 @@ ${rendered}`);
           if (packageName !== "@treeseed/sdk" && pendingPackageReleases.has("@treeseed/sdk") && !dependencies.includes("@treeseed/sdk")) {
             dependencies.push("@treeseed/sdk");
           }
+          if (packageName === "@treeseed/api" && pendingPackageReleases.has("@treeseed/cli") && !dependencies.includes("@treeseed/cli")) {
+            dependencies.push("@treeseed/cli");
+          }
           return [packageName, dependencies];
         }));
         while (pendingPackageReleases.size > 0) {
@@ -6251,6 +6388,26 @@ ${rendered}`);
             const pkg = packageRepoByName.get(packageName);
             const version = selectedVersions.get(pkg.name);
             const packageRelease = await executeJournalStep(root, workflowRun.runId, `release-${pkg.name}`, async () => {
+              const adopted = await adoptPublishedPackageRelease(pkg, version);
+              if (adopted) {
+                helpers.write(`[release][packages] adopted verified published release ${pkg.name}@${version}.`, "stderr");
+                if (pkg.name === "@treeseed/api") {
+                  const publishWait3 = await waitForWorkflowGates("release", [{
+                    name: pkg.name,
+                    repoPath: pkg.dir,
+                    workflow: releaseWorkflowForPackage(root, pkg.name),
+                    branch: version,
+                    headSha: String(stringRecord(adopted.commit)?.commitSha ?? tagCommitSha(pkg.dir, version))
+                  }], ciMode, {
+                    root,
+                    runId: workflowRun.runId,
+                    onProgress: (line, stream) => helpers.write(line, stream),
+                    retryFailedOnce: true
+                  });
+                  return { ...adopted, publishWait: publishWait3 };
+                }
+                return adopted;
+              }
               const metadata = await prepareAdapterReleaseMetadata(root, pkg, version);
               const changelog = updateReleaseChangelog(pkg.dir, {
                 version,
@@ -6483,7 +6640,8 @@ async function workflowResume(helpers, input) {
       );
       const classification = classifyWorkflowRunJournal(journal, {
         currentBranch: session.branchName,
-        currentHeads
+        currentHeads,
+        acceptedReleaseHeads: acceptedPublishedReleaseHeads(root, journal, currentHeads)
       });
       if (classification.state !== "resumable") {
         workflowError("resume", "resume_unavailable", `Run ${runId} is ${classification.state} and is not safe to resume.`, {
@@ -6513,7 +6671,10 @@ async function workflowResume(helpers, input) {
         case "stage":
           return workflowStage(resumedHelpers, journal.input);
         case "release":
-          return workflowRelease(resumedHelpers, journal.input);
+          return workflowRelease(resumedHelpers, {
+            ...journal.input,
+            resumeRunId: runId
+          });
         case "destroy":
           return workflowDestroy(resumedHelpers, journal.input);
         default:

package/dist/workflow/runs.d.ts

@@ -113,6 +113,7 @@ export declare function updateWorkflowRunJournal(root: string, runId: string, up
 export declare function classifyWorkflowRunJournal(journal: TreeseedWorkflowRunJournal, options?: {
     currentBranch?: string | null;
     currentHeads?: Record<string, string | null | undefined>;
+    acceptedReleaseHeads?: Record<string, string | null | undefined>;
     now?: string;
 }): TreeseedWorkflowRunClassification;
 export declare function classifyWorkflowRunJournals(root: string, options?: Parameters<typeof classifyWorkflowRunJournal>[1]): {

package/dist/workflow/runs.js

@@ -406,6 +406,8 @@ function expectedPackageHeadAfterReleaseGate(journal, packageName) {
   const data = releaseStepData(journal, `release-${packageName}`);
   const backMerge = stringRecord(data?.backMerge);
   if (typeof backMerge?.commitSha === "string") return backMerge.commitSha;
+  const commit = stringRecord(data?.commit);
+  if (typeof commit?.commitSha === "string") return commit.commitSha;
   if (typeof data?.commitSha === "string") return data.commitSha;
   return null;
 }
@@ -512,9 +514,9 @@ function classifyWorkflowRunJournal(journal, options = {}) {
       }
       for (const name of selectedReleasePackageNames(releasePlan)) {
         const currentHead = options.currentHeads[name];
-        const plannedHead = journalReleasePlanHead(releasePlan, name);
-        if (currentHead && plannedHead && currentHead !== plannedHead) {
-          reasons.push(`${name} head changed from ${plannedHead} to ${currentHead}`);
+        const expectedHead = expectedPackageHeadAfterReleaseGate(journal, name) ?? options.acceptedReleaseHeads?.[name] ?? journalReleasePlanHead(releasePlan, name);
+        if (currentHead && expectedHead && currentHead !== expectedHead) {
+          reasons.push(`${name} head changed from ${expectedHead} to ${currentHead}`);
         }
       }
     }

package/package.json

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