@treeseed/sdk 0.12.46 → 0.12.47

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

@@ -440,7 +440,12 @@ function checkoutTaskBranchFromStaging(cwd, branchName, { createIfMissing = true
 function checkoutNewTaskBranchWithChanges(cwd, branchName, { pushIfCreated = false } = {}) {
   const repoDir = repoRoot(cwd);
   if (currentBranch(repoDir) !== STAGING_BRANCH) {
-    throw new Error(`Dirty change adoption requires ${repoDir} to be on ${STAGING_BRANCH}.`);
+    const stagingHead = remoteBranchExists(repoDir, STAGING_BRANCH) ? remoteHeadCommit(repoDir, STAGING_BRANCH) : null;
+    const canNormalizeStagingCheckout = gitStatusPorcelain(repoDir).length === 0 && stagingHead !== null && headCommit(repoDir) === stagingHead;
+    if (!canNormalizeStagingCheckout) {
+      throw new Error(`Dirty change adoption requires ${repoDir} to be on ${STAGING_BRANCH}.`);
+    }
+    syncBranchWithOrigin(repoDir, STAGING_BRANCH);
   }
   if (branchExists(repoDir, branchName) || remoteBranchExists(repoDir, branchName)) {
     throw new Error(`Dirty change adoption requires a new branch; ${branchName} already exists.`);

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

@@ -743,7 +743,7 @@ function syncDirectGitDependencyLockfileEntries(node, options, references) {
         if (!dependencies || typeof dependencies !== "object" || Array.isArray(dependencies)) continue;
         const dependencyMap = dependencies;
         const current = dependencyMap[reference.packageName];
-        if (typeof current === "string" && /(?:git|github:|#[0-9a-f]{7,40}$)/iu.test(current) && current !== manifestSpec) {
+        if (typeof current === "string" && current !== manifestSpec) {
           dependencyMap[reference.packageName] = manifestSpec;
           changed = true;
         }

package/dist/reconcile/providers/release-private.d.ts

@@ -8,30 +8,17 @@ export declare function runReleaseVerifyCommand(input: {
     ok: boolean;
     skipped: boolean;
     reason: string;
-    status?: undefined;
-    signal?: undefined;
-    command?: undefined;
     dependencies?: undefined;
-    stdout?: undefined;
-    stderr?: undefined;
 } | {
     ok: boolean;
-    status: number | null;
-    signal: NodeJS.Signals | null;
-    command: import("../../index.js").TreeseedPackageCommand;
+    skipped: boolean;
+    reason: string;
     dependencies: {
-        status: "not-applicable";
-    } | {
-        status: "ready";
-    } | {
-        status: "restored";
-    } | {
-        status: "workspace-linked";
+        status: "staging-proof-reused";
+        candidatePath: string;
+        packageCommit: string;
+        rootCommit: string;
     };
-    stdout: string;
-    stderr: string;
-    skipped?: undefined;
-    reason?: undefined;
 }>;
 export declare function runTemplateReleaseVerifyCommand(input: {
     tenantRoot: string;

package/dist/reconcile/providers/release-private.js

@@ -1,42 +1,27 @@
-import { spawn, spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { findTreeseedPackageAdapter } from "../../operations/services/package-adapters.js";
 import { checkedOutTemplateRepositories } from "../../operations/services/managed-repositories.js";
 import { runTreeseedGitText } from "../../operations/services/git-runner.js";
-import { ensureLocalWorkspaceLinks } from "../../operations/services/workspace-dependency-mode.js";
-function ensureReleaseVerifyDependencies(input) {
-  if (!existsSync(resolve(input.packageDir, "package.json")) || !existsSync(resolve(input.packageDir, "package-lock.json"))) {
-    return { status: "not-applicable" };
+function requireMatchingStageCandidate(tenantRoot, packageId, packageDir) {
+  const candidatePath = resolve(tenantRoot, ".treeseed/workflow/stage-candidates/latest.json");
+  if (!existsSync(candidatePath)) {
+    throw new Error(`Release verification requires a successful staged candidate; ${candidatePath} is missing.`);
   }
-  const env = { ...process.env, ...input.env ?? {} };
-  const inspection = spawnSync("npm", ["ls", "--depth=0", "--workspaces=false"], {
-    cwd: input.packageDir,
-    env,
-    encoding: "utf8"
-  });
-  if (inspection.status === 0) return { status: "ready" };
-  input.onProgress?.("Package dependencies are incomplete; restoring the standalone lockfile installation.");
-  const install = spawnSync("npm", [
-    "ci",
-    "--ignore-scripts",
-    "--workspaces=false",
-    "--no-audit",
-    "--no-fund"
-  ], {
-    cwd: input.packageDir,
-    env,
-    encoding: "utf8"
-  });
-  if (install.status !== 0) {
-    throw new Error([
-      "Standalone package dependency hydration failed before release verification.",
-      install.stderr,
-      install.stdout
-    ].filter(Boolean).join("\n").trim());
+  const candidate = JSON.parse(readFileSync(candidatePath, "utf8"));
+  const packageProof = candidate.packages?.find((entry) => entry.name === packageId);
+  const packageHead = runTreeseedGitText(["rev-parse", "HEAD"], { cwd: packageDir, mode: "read" }).trim();
+  const rootHead = runTreeseedGitText(["rev-parse", "HEAD"], { cwd: tenantRoot, mode: "read" }).trim();
+  if (candidate.targetBranch !== "staging" || candidate.root?.verified !== true || candidate.root.commit !== rootHead || packageProof?.verified !== true || packageProof.commit !== packageHead) {
+    throw new Error(`Release verification requires ${packageId} and the Market root to match the latest verified staging candidate.`);
   }
-  ensureLocalWorkspaceLinks(input.tenantRoot, { env: input.env });
-  return { status: "restored" };
+  return {
+    status: "staging-proof-reused",
+    candidatePath,
+    packageCommit: packageHead,
+    rootCommit: rootHead
+  };
 }
 async function runReleaseVerifyCommand(input) {
   const adapter = findTreeseedPackageAdapter(input.tenantRoot, input.packageId);
@@ -51,54 +36,13 @@ async function runReleaseVerifyCommand(input) {
       reason: `${input.packageId} has no release verify command.`
     };
   }
-  const dependencies = adapter.capabilities.localOnly ? (() => {
-    ensureLocalWorkspaceLinks(input.tenantRoot, { env: input.env });
-    return { status: "workspace-linked" };
-  })() : ensureReleaseVerifyDependencies({
-    tenantRoot: input.tenantRoot,
-    packageDir: adapter.dir,
-    env: input.env,
-    onProgress: input.onProgress
-  });
-  const renderedCommand = [command.command, ...command.args].join(" ");
-  input.onProgress?.(`Running ${input.packageId} release verification: ${renderedCommand}`);
-  const started = Date.now();
-  let stdout = "";
-  let stderr = "";
-  const result = await new Promise((resolve2, reject) => {
-    const child = spawn(command.command, command.args, {
-      cwd: command.cwd,
-      env: { ...process.env, ...input.env ?? {} },
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const heartbeat = setInterval(() => {
-      input.onProgress?.(`Still running ${input.packageId} release verification after ${Math.round((Date.now() - started) / 1e3)}s.`);
-    }, 3e4);
-    child.stdout?.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-    child.on("error", (error) => {
-      clearInterval(heartbeat);
-      reject(error);
-    });
-    child.on("close", (status, signal) => {
-      clearInterval(heartbeat);
-      resolve2({ status, signal });
-    });
-  });
-  const elapsedSeconds = Math.round((Date.now() - started) / 1e3);
-  input.onProgress?.(`${input.packageId} release verification ${result.status === 0 ? "passed" : "failed"} in ${elapsedSeconds}s.`);
+  const stagingProof = requireMatchingStageCandidate(input.tenantRoot, input.packageId, adapter.dir);
+  input.onProgress?.(`Reusing exact-SHA staging verification for ${input.packageId} at ${stagingProof.packageCommit.slice(0, 12)}.`);
   return {
-    ok: (result.status ?? 1) === 0,
-    status: result.status,
-    signal: result.signal,
-    command,
-    dependencies,
-    stdout,
-    stderr
+    ok: true,
+    skipped: true,
+    reason: `${input.packageId} matches the latest verified staging candidate; tag workflows perform independent release verification before publication or deployment.`,
+    dependencies: stagingProof
   };
 }
 function runTemplateCommand(command, cwd, env) {

package/dist/workflow/operations.js

@@ -2133,8 +2133,12 @@ function productionPackageDeployGates(root, versions) {
 function prepareAdapterReleaseMetadata(root, pkg, version) {
   const adapter = discoverTreeseedPackageAdapters(root).find((entry) => entry.id === pkg.name || entry.name === pkg.name);
   if (adapter?.kind === "beam-elixir-rust" && existsSync(resolve(pkg.dir, "scripts", "bump-release-version.ts"))) {
-    run("tsx", ["scripts/bump-release-version.ts", version], { cwd: pkg.dir });
-    return { status: "updated", adapter: adapter.id, command: "tsx scripts/bump-release-version.ts" };
+    const tsx = resolve(root, "node_modules/.bin/tsx");
+    if (!existsSync(tsx)) {
+      throw new Error(`TreeSeed release requires the workspace tsx executable at ${tsx}. Run trsd install and restore workspace dependencies before retrying.`);
+    }
+    run(tsx, ["scripts/bump-release-version.ts", version], { cwd: pkg.dir });
+    return { status: "updated", adapter: adapter.id, command: `${tsx} scripts/bump-release-version.ts` };
   }
   if (existsSync(resolve(pkg.dir, "package.json"))) {
     return {

package/package.json

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