@treeseed/sdk 0.11.0 → 0.12.4

package/dist/workflow/policy.js

@@ -1,6 +1,8 @@
-import { findNearestTreeseedRoot, run } from "../operations/services/workspace-tools.js";
+import { relative } from "node:path";
+import { findNearestTreeseedRoot } from "../operations/services/workspace-tools.js";
 import { currentBranch, repoRoot } from "../operations/services/workspace-save.js";
 import { PRODUCTION_BRANCH, STAGING_BRANCH } from "../operations/services/git-workflow.js";
+import { runTreeseedGitOk } from "../operations/services/git-runner.js";
 function safeRepoRoot(cwd) {
   try {
     return repoRoot(cwd);
@@ -9,12 +11,12 @@ function safeRepoRoot(cwd) {
   }
 }
 function repoHasHead(repoDir) {
-  try {
-    run("git", ["rev-parse", "--verify", "HEAD"], { cwd: repoDir, capture: true });
-    return true;
-  } catch {
-    return false;
-  }
+  return runTreeseedGitOk(["rev-parse", "--verify", "HEAD"], { cwd: repoDir, mode: "read" });
+}
+function isInsideUnresolvedManagedWorktree(startCwd, tenantRoot) {
+  if (!tenantRoot) return false;
+  const relativePath = relative(tenantRoot, startCwd).replaceAll("\\", "/");
+  return relativePath === ".treeseed/worktrees" || relativePath.startsWith(".treeseed/worktrees/");
 }
 function classifyTreeseedBranchRole(branchName, repoDir) {
   if (!repoDir) {
@@ -33,6 +35,16 @@ function classifyTreeseedBranchRole(branchName, repoDir) {
 }
 function resolveTreeseedWorkflowPaths(startCwd) {
   const tenantRoot = findNearestTreeseedRoot(startCwd);
+  if (isInsideUnresolvedManagedWorktree(startCwd, tenantRoot)) {
+    return {
+      requestedCwd: startCwd,
+      tenantRoot: null,
+      cwd: startCwd,
+      repoRoot: null,
+      branchName: null,
+      branchRole: "none"
+    };
+  }
   const cwd = tenantRoot ?? startCwd;
   const gitRoot = safeRepoRoot(cwd);
   const branchName = gitRoot ? currentBranch(gitRoot) || null : null;

package/dist/workflow/runs.d.ts

@@ -1,6 +1,7 @@
-import type { TreeseedWorkflowMode } from './session.ts';
-export type TreeseedWorkflowRunCommand = 'switch' | 'save' | 'close' | 'stage' | 'release' | 'destroy';
+import type { TreeseedWorkflowMode } from './session.js';
+export type TreeseedWorkflowRunCommand = 'switch' | 'save' | 'update' | 'close' | 'stage' | 'release' | 'destroy';
 export type TreeseedWorkflowExecutionMode = 'execute' | 'plan';
+export type TreeseedWorkflowLockScope = 'worktree' | 'shared';
 export type TreeseedWorkflowRunStatus = 'running' | 'failed' | 'completed';
 export type TreeseedWorkflowRunClassificationState = 'resumable' | 'stale' | 'obsolete';
 export type TreeseedWorkflowRunClassification = {
@@ -67,6 +68,7 @@ export type TreeseedWorkflowRunJournal = {
 export type TreeseedWorkflowLockRecord = {
     schemaVersion: 1;
     kind: 'treeseed.workflow.lock';
+    scope?: TreeseedWorkflowLockScope;
     runId: string;
     command: TreeseedWorkflowRunCommand;
     root: string;
@@ -83,8 +85,12 @@ export type TreeseedWorkflowLockInspection = {
     stale: boolean;
     staleReason: string | null;
 };
+export declare function workflowLockScopeForCommand(command: TreeseedWorkflowRunCommand): TreeseedWorkflowLockScope;
+export declare function isSharedWorkflowCommand(command?: string | null): command is TreeseedWorkflowRunCommand;
 export declare function generateWorkflowRunId(command: TreeseedWorkflowRunCommand): string;
-export declare function inspectWorkflowLock(root: string): TreeseedWorkflowLockInspection;
+export declare function inspectWorkflowLock(root: string, options?: {
+    scope?: TreeseedWorkflowLockScope;
+}): TreeseedWorkflowLockInspection;
 export declare function acquireWorkflowLock(root: string, command: TreeseedWorkflowRunCommand, runId: string): {
     readonly acquired: false;
     readonly lock: TreeseedWorkflowLockRecord;

package/dist/workflow/runs.js

@@ -6,6 +6,7 @@ const WORKFLOW_RUNS_DIR = `${WORKFLOW_CONTROL_DIR}/runs`;
 const WORKTREE_METADATA_PATH = ".treeseed/worktree.json";
 const LOCK_STALE_AFTER_MS = 4 * 60 * 60 * 1e3;
 const WORKFLOW_RUN_STORAGE_ROOTS = /* @__PURE__ */ new Map();
+const SHARED_LOCK_COMMANDS = /* @__PURE__ */ new Set(["stage", "release"]);
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -19,24 +20,41 @@ function managedWorktreePrimaryRoot(root) {
     return null;
   }
 }
-function workflowStorageRoot(root, runId) {
-  if (runId && WORKFLOW_RUN_STORAGE_ROOTS.has(runId)) {
-    return WORKFLOW_RUN_STORAGE_ROOTS.get(runId);
+function workflowLockScopeForCommand(command) {
+  return SHARED_LOCK_COMMANDS.has(command) ? "shared" : "worktree";
+}
+function isSharedWorkflowCommand(command) {
+  return command === "stage" || command === "release";
+}
+function workflowCommandFromRunId(runId) {
+  if (!runId) return null;
+  const prefix = runId.split("-", 1)[0];
+  return ["switch", "save", "update", "close", "stage", "release", "destroy"].includes(prefix) ? prefix : null;
+}
+function workflowStorageRootForScope(root, scope) {
+  return scope === "shared" ? managedWorktreePrimaryRoot(root) ?? root : root;
+}
+function workflowStorageRoot(root, runId, scope) {
+  const storageKey = runId ? `${resolve(root)}\0${runId}` : null;
+  if (storageKey && WORKFLOW_RUN_STORAGE_ROOTS.has(storageKey)) {
+    return WORKFLOW_RUN_STORAGE_ROOTS.get(storageKey);
   }
-  const storageRoot = managedWorktreePrimaryRoot(root) ?? root;
-  if (runId) {
-    WORKFLOW_RUN_STORAGE_ROOTS.set(runId, storageRoot);
+  const command = workflowCommandFromRunId(runId);
+  const resolvedScope = scope ?? (command ? workflowLockScopeForCommand(command) : "worktree");
+  const storageRoot = workflowStorageRootForScope(root, resolvedScope);
+  if (storageKey) {
+    WORKFLOW_RUN_STORAGE_ROOTS.set(storageKey, storageRoot);
   }
   return storageRoot;
 }
-function workflowControlRoot(root, runId) {
-  return resolve(workflowStorageRoot(root, runId), WORKFLOW_CONTROL_DIR);
+function workflowControlRoot(root, runId, scope) {
+  return resolve(workflowStorageRoot(root, runId, scope), WORKFLOW_CONTROL_DIR);
 }
-function workflowRunsRoot(root, runId) {
-  return resolve(workflowStorageRoot(root, runId), WORKFLOW_RUNS_DIR);
+function workflowRunsRoot(root, runId, scope) {
+  return resolve(workflowStorageRoot(root, runId, scope), WORKFLOW_RUNS_DIR);
 }
-function workflowLockPath(root, runId) {
-  return resolve(workflowStorageRoot(root, runId), WORKFLOW_CONTROL_DIR, "lock.json");
+function workflowLockPath(root, runId, scope) {
+  return resolve(workflowStorageRoot(root, runId, scope), WORKFLOW_CONTROL_DIR, "lock.json");
 }
 function workflowRunPath(root, runId) {
   return resolve(workflowStorageRoot(root, runId), WORKFLOW_RUNS_DIR, `${runId}.json`);
@@ -72,9 +90,9 @@ function ensureWorkflowExcludeRule(root) {
   writeFileSync(excludePath, `${current}${current.endsWith("\n") || current.length === 0 ? "" : "\n"}${pattern}
 `, "utf8");
 }
-function ensureWorkflowControlDirs(root, runId) {
-  const controlDir = workflowControlRoot(root, runId);
-  const runsDir = workflowRunsRoot(root, runId);
+function ensureWorkflowControlDirs(root, runId, scope) {
+  const controlDir = workflowControlRoot(root, runId, scope);
+  const runsDir = workflowRunsRoot(root, runId, scope);
   mkdirSync(runsDir, { recursive: true });
   ensureWorkflowExcludeRule(root);
   writeFileSync(resolve(controlDir, ".gitignore"), "*\n!.gitignore\n!runs/\nruns/*\n!runs/.gitignore\n", "utf8");
@@ -82,7 +100,7 @@ function ensureWorkflowControlDirs(root, runId) {
   return {
     controlDir,
     runsDir,
-    lockPath: workflowLockPath(root)
+    lockPath: workflowLockPath(root, runId, scope)
   };
 }
 function safeJsonParse(filePath) {
@@ -109,8 +127,9 @@ function pidIsAlive(pid) {
 function generateWorkflowRunId(command) {
   return `${command}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
-function inspectWorkflowLock(root) {
-  const lock = safeJsonParse(workflowLockPath(root));
+function inspectWorkflowLock(root, options = {}) {
+  const scope = options.scope ?? "worktree";
+  const lock = safeJsonParse(workflowLockPath(root, null, scope));
   if (!lock) {
     return {
       lock: null,
@@ -128,6 +147,7 @@ function inspectWorkflowLock(root) {
   return {
     lock: {
       ...lock,
+      scope: lock.scope ?? scope,
       stale: staleReason != null,
       staleReason
     },
@@ -137,8 +157,9 @@ function inspectWorkflowLock(root) {
   };
 }
 function acquireWorkflowLock(root, command, runId) {
-  const dirs = ensureWorkflowControlDirs(root, runId);
-  const inspection = inspectWorkflowLock(root);
+  const scope = workflowLockScopeForCommand(command);
+  const dirs = ensureWorkflowControlDirs(root, runId, scope);
+  const inspection = inspectWorkflowLock(root, { scope });
   if (inspection.active && inspection.lock && inspection.lock.runId !== runId) {
     return {
       acquired: false,
@@ -152,6 +173,7 @@ function acquireWorkflowLock(root, command, runId) {
   const lock = {
     schemaVersion: 1,
     kind: "treeseed.workflow.lock",
+    scope,
     runId,
     command,
     root,
@@ -245,7 +267,7 @@ function isReleaseGateOnlyCompletion(journal) {
   const releaseRootData = stringRecord(releaseRoot.data);
   if (typeof releaseRootData?.releasedCommit !== "string") return false;
   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";
+  return pendingStep?.id === "release-root-gates" || pendingStep?.id === "release-back-merge";
 }
 function releaseStepData(journal, stepId) {
   return stringRecord(journal.steps.find((step) => step.id === stepId)?.data);
@@ -266,14 +288,18 @@ function collectSaveExpectedHeads(journal) {
   const saveData = stringRecord(journal.steps.find((step) => step.id === "save-repositories")?.data);
   const partialFailure = savePartialFailureData(journal);
   const source = saveData ?? partialFailure;
+  const partial = saveData == null && partialFailure != null;
+  const failingRepo = partial && typeof partialFailure?.failingRepo === "string" ? partialFailure.failingRepo : null;
   const rootRepo = stringRecord(source?.rootRepo);
-  if (typeof rootRepo?.commitSha === "string") {
+  const rootCompletionUnknown = rootRepo?.pushed == null && rootRepo?.committed == null;
+  if (typeof rootRepo?.commitSha === "string" && (!partial || rootRepo.pushed === true || rootRepo.committed === true || rootCompletionUnknown && rootRepo.dirty !== true)) {
     heads["@treeseed/market"] = rootRepo.commitSha;
   }
   const repos = Array.isArray(source?.repos) ? source.repos : [];
   for (const entry of repos) {
     const repo = stringRecord(entry);
-    if (typeof repo?.name === "string" && typeof repo.commitSha === "string") {
+    const completionUnknown = repo?.pushed == null && repo?.committed == null;
+    if (typeof repo?.name === "string" && typeof repo.commitSha === "string" && (!partial || repo.pushed === true || repo.committed === true || completionUnknown && repo.name !== failingRepo && repo.dirty !== true)) {
       heads[repo.name] = repo.commitSha;
     }
   }
@@ -297,7 +323,10 @@ function classifyWorkflowRunJournal(journal, options = {}) {
       classifiedAt: now
     };
   }
-  if (!journal.resumable) {
+  const recovery = stringRecord(stringRecord(journal.failure)?.details)?.recovery;
+  const recoveryRecord = stringRecord(recovery);
+  const recoveryMarkedResumable = recoveryRecord?.resumable === true;
+  if (!journal.resumable && !recoveryMarkedResumable) {
     return {
       state: "obsolete",
       reasons: ["workflow run is not marked resumable"],
@@ -446,13 +475,22 @@ function createWorkflowRunJournal(root, options) {
     result: null
   });
 }
-function listWorkflowRunJournals(root) {
-  const runsDir = workflowRunsRoot(root);
+function listWorkflowRunJournalsForScope(root, scope) {
+  const runsDir = workflowRunsRoot(root, null, scope);
   if (!existsSync(runsDir)) {
     return [];
   }
   return readdirSync(runsDir).filter((entry) => entry.endsWith(".json")).map((entry) => safeJsonParse(resolve(runsDir, entry))).filter((entry) => entry != null).sort((left, right) => right.createdAt.localeCompare(left.createdAt));
 }
+function listWorkflowRunJournals(root) {
+  const local = listWorkflowRunJournalsForScope(root, "worktree");
+  const shared = listWorkflowRunJournalsForScope(root, "shared");
+  const byId = /* @__PURE__ */ new Map();
+  for (const journal of [...local, ...shared]) {
+    byId.set(journal.runId, journal);
+  }
+  return [...byId.values()].sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+}
 function listInterruptedWorkflowRuns(root) {
   return listWorkflowRunJournals(root).filter((journal) => journal.status === "failed" && journal.resumable);
 }
@@ -466,11 +504,13 @@ export {
   generateWorkflowRunId,
   getCachedSuccessfulWorkflowGate,
   inspectWorkflowLock,
+  isSharedWorkflowCommand,
   listInterruptedWorkflowRuns,
   listWorkflowRunJournals,
   readWorkflowRunJournal,
   refreshWorkflowLock,
   releaseWorkflowLock,
   updateWorkflowRunJournal,
+  workflowLockScopeForCommand,
   writeWorkflowRunJournal
 };

package/dist/workflow/session.d.ts

@@ -1,9 +1,11 @@
-import { type TreeseedWorkflowBranchRole } from './policy.ts';
+import { type TreeseedWorkflowBranchRole } from './policy.js';
+import { type TreeseedManagedRepositoryKind } from '../operations/services/managed-repositories.js';
 export type TreeseedWorkflowMode = 'root-only' | 'recursive-workspace';
 export type TreeseedWorkflowSessionRepo = {
     name: string;
     path: string;
     relativePath: string;
+    kind: TreeseedManagedRepositoryKind | 'package';
     branchName: string | null;
     branchRole: TreeseedWorkflowBranchRole;
     dirty: boolean;
@@ -22,6 +24,7 @@ export type TreeseedWorkflowSession = {
     branchName: string | null;
     branchRole: TreeseedWorkflowBranchRole;
     rootRepo: TreeseedWorkflowSessionRepo;
+    managedRepos: TreeseedWorkflowSessionRepo[];
     packageRepos: TreeseedWorkflowSessionRepo[];
     packageSelection: TreeseedWorkflowPackageSelection;
 };

package/dist/workflow/session.js

@@ -1,4 +1,5 @@
-import { relative } from "node:path";
+import { existsSync } from "node:fs";
+import { relative, resolve } from "node:path";
 import {
   currentBranch,
   gitStatusPorcelain,
@@ -13,10 +14,14 @@ import {
   workspacePackages,
   workspaceRoot
 } from "../operations/services/workspace-tools.js";
+import { discoverTreeseedPackageAdapters } from "../operations/services/package-adapters.js";
 import {
   classifyTreeseedBranchRole,
   resolveTreeseedWorkflowPaths
 } from "./policy.js";
+import {
+  checkedOutManagedWorkflowRepos
+} from "../operations/services/managed-repositories.js";
 function hasOriginRemote(repoDir) {
   try {
     originRemoteUrl(repoDir);
@@ -25,12 +30,13 @@ function hasOriginRemote(repoDir) {
     return false;
   }
 }
-function repoState(root, name, repoDir) {
+function repoState(root, name, repoDir, kind = "package") {
   const branchName = currentBranch(repoDir) || null;
   return {
     name,
     path: repoDir,
     relativePath: relative(root, repoDir).replaceAll("\\", "/") || ".",
+    kind,
     branchName,
     branchRole: classifyTreeseedBranchRole(branchName, repoDir),
     dirty: gitStatusPorcelain(repoDir).length > 0,
@@ -39,20 +45,52 @@ function repoState(root, name, repoDir) {
   };
 }
 function checkedOutWorkspacePackageRepos(root) {
-  if (!hasCompleteTreeseedPackageCheckout(root)) {
+  let packages = [];
+  try {
+    packages = workspacePackages(root);
+  } catch {
+    packages = [];
+  }
+  if (!hasCompleteTreeseedPackageCheckout(root) && packages.length === 0) {
     return [];
   }
-  return sortWorkspacePackages(
-    workspacePackages(root).filter((pkg) => pkg.name?.startsWith("@treeseed/"))
-  );
+  const repos = /* @__PURE__ */ new Map();
+  for (const pkg of packages.filter((pkg2) => pkg2.name?.startsWith("@treeseed/"))) {
+    if (!existsSync(resolve(pkg.dir, ".git"))) continue;
+    repos.set(pkg.name, pkg);
+  }
+  for (const adapter of discoverTreeseedPackageAdapters(root)) {
+    if (!adapter.publishTarget && adapter.artifacts.length === 0) continue;
+    if (repos.has(adapter.id)) continue;
+    if (!existsSync(resolve(adapter.dir, ".git"))) continue;
+    repos.set(adapter.id, {
+      dir: adapter.dir,
+      name: adapter.id,
+      packageJson: {},
+      relativeDir: adapter.relativeDir
+    });
+  }
+  return sortWorkspacePackages([...repos.values()]);
 }
 function workflowModeForRoot(root) {
   return hasCompleteTreeseedPackageCheckout(root) ? "recursive-workspace" : "root-only";
 }
 function collectReleasePackageSelection(root) {
-  const publishable = sortWorkspacePackages(
-    publishableWorkspacePackages(root).filter((pkg) => pkg.name?.startsWith("@treeseed/"))
-  );
+  const publishableByName = /* @__PURE__ */ new Map();
+  for (const pkg of publishableWorkspacePackages(root).filter((pkg2) => pkg2.name?.startsWith("@treeseed/"))) {
+    publishableByName.set(pkg.name, pkg);
+  }
+  for (const adapter of discoverTreeseedPackageAdapters(root)) {
+    if (!adapter.publishTarget && adapter.artifacts.length === 0) continue;
+    if (publishableByName.has(adapter.id)) continue;
+    publishableByName.set(adapter.id, {
+      dir: adapter.dir,
+      name: adapter.id,
+      packageJson: {},
+      relativeDir: adapter.relativeDir
+    });
+  }
+  const publishable = sortWorkspacePackages([...publishableByName.values()]);
   const changed = changedWorkspacePackages({
     root,
     baseRef: "main",
@@ -78,13 +116,15 @@ function resolveTreeseedWorkflowSession(cwd) {
   const gitRoot = repoRoot(root);
   const mode = workflowModeForRoot(root);
   const packageRepos = checkedOutWorkspacePackageRepos(root).map((pkg) => repoState(root, pkg.name, pkg.dir));
+  const managedRepos = checkedOutManagedWorkflowRepos(root).map((repo) => repoState(root, repo.name, repo.dir, repo.kind));
   return {
     root,
     gitRoot,
     mode,
     branchName: currentBranch(gitRoot) || null,
     branchRole: classifyTreeseedBranchRole(currentBranch(gitRoot) || null, gitRoot),
-    rootRepo: repoState(root, "@treeseed/market", gitRoot),
+    rootRepo: repoState(root, "@treeseed/market", gitRoot, "root"),
+    managedRepos,
     packageRepos,
     packageSelection: collectReleasePackageSelection(root)
   };

package/dist/workflow/worktrees.d.ts

@@ -1,4 +1,4 @@
-import type { TreeseedWorkflowWorktreeMode } from '../workflow.ts';
+import type { TreeseedWorkflowWorktreeMode } from '../workflow.js';
 export type ManagedWorkflowWorktreeMetadata = {
     schemaVersion: 1;
     kind: 'treeseed.workflow.worktree';
@@ -24,16 +24,20 @@ export declare function ensureManagedWorkflowWorktree({ root, branchName, mode,
     mode?: TreeseedWorkflowWorktreeMode;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
 }): ManagedWorkflowWorktreeResult;
-export declare function removeManagedWorkflowWorktree(root: string): {
+export declare function removeManagedWorkflowWorktree(root: string, options?: {
+    deleteBranch?: boolean;
+}): {
     removed: boolean;
     reason: string;
     worktreePath?: undefined;
     primaryRoot?: undefined;
     branch?: undefined;
+    deletedLocalBranch?: undefined;
 } | {
     removed: boolean;
     worktreePath: string;
     primaryRoot: string;
     branch: string;
+    deletedLocalBranch: boolean;
     reason?: undefined;
 };

package/dist/workflow/worktrees.js

@@ -1,23 +1,26 @@
+import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { spawnSync } from "node:child_process";
+import { runTreeseedGit } from "../operations/services/git-runner.js";
 import { sortWorkspacePackages, workspacePackages, workspaceRoot } from "../operations/services/workspace-tools.js";
 import { repoRoot } from "../operations/services/workspace-save.js";
+import { discoverTreeseedPackageAdapters } from "../operations/services/package-adapters.js";
 const WORKTREE_METADATA_PATH = ".treeseed/worktree.json";
 const WORKTREE_ROOT = ".treeseed/worktrees";
+const MACHINE_CONFIG_PATH = ".treeseed/config/machine.yaml";
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function runGit(args, { cwd, capture = true, allowFailure = false }) {
-  const result = spawnSync("git", args, {
+  const mutating = /^(add|commit|checkout|switch|merge|tag|push|fetch|worktree|submodule|reset|clean|restore|branch)$/u.test(args[0] ?? "");
+  const result = runTreeseedGit(args, {
     cwd,
-    stdio: capture ? "pipe" : "inherit",
-    encoding: "utf8"
+    mode: mutating ? "mutate" : "read",
+    allowFailure
   });
-  if (result.status !== 0 && !allowFailure) {
-    throw new Error(result.stderr?.trim() || result.stdout?.trim() || `git ${args.join(" ")} failed`);
-  }
+  if (!capture && result.stdout.trim()) process.stdout.write(result.stdout);
+  if (!capture && result.stderr.trim()) process.stderr.write(result.stderr);
   return result;
 }
 function slugifyBranch(branchName) {
@@ -72,8 +75,23 @@ function checkoutManagedPackageBranch(repoDir, branchName) {
   }
 }
 function checkoutManagedPackageBranches(worktreePath, branchName) {
-  for (const pkg of sortWorkspacePackages(workspacePackages(worktreePath))) {
-    if (!pkg.name?.startsWith("@treeseed/")) continue;
+  const packages = /* @__PURE__ */ new Map();
+  for (const pkg of workspacePackages(worktreePath)) {
+    if (pkg.name?.startsWith("@treeseed/")) {
+      packages.set(pkg.name, pkg);
+    }
+  }
+  for (const adapter of discoverTreeseedPackageAdapters(worktreePath)) {
+    if (!adapter.publishTarget && adapter.artifacts.length === 0) continue;
+    if (packages.has(adapter.id)) continue;
+    packages.set(adapter.id, {
+      dir: adapter.dir,
+      name: adapter.id,
+      packageJson: {},
+      relativeDir: adapter.relativeDir
+    });
+  }
+  for (const pkg of sortWorkspacePackages([...packages.values()])) {
     if (!existsSync(resolve(pkg.dir, ".git"))) continue;
     checkoutManagedPackageBranch(pkg.dir, branchName);
   }
@@ -102,7 +120,7 @@ function ensureManagedWorktreeExclude(root) {
   if (!commonGitDir) return;
   const absolutePath = resolve(root, commonGitDir, "info", "exclude");
   const current = existsSync(absolutePath) ? readFileSync(absolutePath, "utf8") : "";
-  const patterns = ["/.treeseed/worktree.json", "/.treeseed/workflow/", "/.treeseed/worktrees/"];
+  const patterns = ["/.treeseed/worktree.json", "/.treeseed/config/", "/.treeseed/workflow/", "/.treeseed/worktrees/"];
   const missing = patterns.filter((pattern) => !current.includes(pattern));
   if (missing.length === 0) return;
   mkdirSync(dirname(absolutePath), { recursive: true });
@@ -113,6 +131,13 @@ function ensureManagedWorktreeExclude(root) {
     "utf8"
   );
 }
+function ensureManagedWorktreeMachineConfig(primaryRoot, worktreePath) {
+  const sourcePath = resolve(primaryRoot, MACHINE_CONFIG_PATH);
+  const targetPath = resolve(worktreePath, MACHINE_CONFIG_PATH);
+  if (!existsSync(sourcePath) || existsSync(targetPath)) return;
+  mkdirSync(dirname(targetPath), { recursive: true });
+  copyFileSync(sourcePath, targetPath);
+}
 function effectiveWorkflowWorktreeMode(mode, env = process.env) {
   const envMode = String(env.TREESEED_WORKTREE_MODE ?? "").trim().toLowerCase();
   if (mode === "on" || envMode === "on" || envMode === "true" || envMode === "1") return "on";
@@ -170,12 +195,16 @@ function ensureManagedWorkflowWorktree({
     runGit(["worktree", "add", "--detach", worktreePath, baseRef], { cwd: primaryGitRoot });
   } else if (!existingEntry) {
     runGit(["worktree", "prune"], { cwd: primaryGitRoot, allowFailure: true });
+    if (existsSync(worktreePath)) {
+      throw new Error(`Managed worktree path ${worktreePath} exists but is not registered as a Git worktree.`);
+    }
   } else if (!currentBranchName(worktreePath)) {
     runGit(["fetch", "origin"], { cwd: worktreePath, allowFailure: true });
     runGit(["reset", "--hard", baseRef], { cwd: worktreePath });
   }
   runGit(["submodule", "update", "--init", "--recursive"], { cwd: worktreePath });
   checkoutManagedPackageBranches(worktreePath, branchName);
+  ensureManagedWorktreeMachineConfig(primaryRoot, worktreePath);
   ensureManagedWorktreeExclude(worktreePath);
   const timestamp = nowIso();
   const previous = readMetadata(worktreePath);
@@ -196,7 +225,7 @@ function ensureManagedWorkflowWorktree({
     resumed: !created
   };
 }
-function removeManagedWorkflowWorktree(root) {
+function removeManagedWorkflowWorktree(root, options = {}) {
   const metadata = readMetadata(root);
   if (!metadata) {
     return { removed: false, reason: "not-managed" };
@@ -204,13 +233,67 @@ function removeManagedWorkflowWorktree(root) {
   const primaryRoot = metadata.primaryRoot;
   const primaryGitRoot = repoRoot(primaryRoot);
   process.chdir(primaryRoot);
-  runGit(["worktree", "remove", "--force", metadata.worktreePath], { cwd: primaryGitRoot });
-  rmSync(metadata.worktreePath, { recursive: true, force: true });
+  const gitRemove = runGit(["worktree", "remove", "--force", metadata.worktreePath], { cwd: primaryGitRoot, allowFailure: true });
+  removeWorkflowWorktreeDirectory(metadata.worktreePath);
+  if (gitRemove.status !== 0) {
+    runGit(["worktree", "prune"], { cwd: primaryGitRoot, allowFailure: true });
+  }
+  let deletedLocalBranch = false;
+  if (options.deleteBranch === true && metadata.branch) {
+    const deleted = runGit(["branch", "-D", metadata.branch], { cwd: primaryGitRoot, allowFailure: true });
+    deletedLocalBranch = deleted.status === 0;
+  }
   return {
     removed: true,
     worktreePath: metadata.worktreePath,
     primaryRoot,
-    branch: metadata.branch
+    branch: metadata.branch,
+    deletedLocalBranch
+  };
+}
+function removeWorkflowWorktreeDirectory(worktreePath) {
+  try {
+    rmSync(worktreePath, { recursive: true, force: true });
+    return;
+  } catch (error) {
+    const repair = repairDockerOwnedWorktreeArtifacts(worktreePath);
+    if (!repair.repaired) {
+      throw error;
+    }
+    try {
+      rmSync(worktreePath, { recursive: true, force: true });
+      return;
+    } catch (retryError) {
+      const detail = repair.stderr ? ` Docker ownership repair stderr: ${repair.stderr}` : "";
+      const message = retryError instanceof Error ? retryError.message : String(retryError);
+      throw new Error(`${message}.${detail}`);
+    }
+  }
+}
+function repairDockerOwnedWorktreeArtifacts(worktreePath) {
+  if (!existsSync(worktreePath) || typeof process.getuid !== "function" || typeof process.getgid !== "function") {
+    return { repaired: false, stderr: "" };
+  }
+  const uid = String(process.getuid());
+  const gid = String(process.getgid());
+  const result = spawnSync("docker", [
+    "run",
+    "--rm",
+    "-v",
+    `${worktreePath}:/target`,
+    "debian:bookworm-slim",
+    "chown",
+    "-R",
+    `${uid}:${gid}`,
+    "/target"
+  ], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 3e5
+  });
+  return {
+    repaired: result.status === 0,
+    stderr: String(result.stderr ?? "").trim()
   };
 }
 export {

package/dist/workflow-state.d.ts

@@ -1,8 +1,8 @@
-import { collectPublicPackageReleaseLineState } from './operations/services/workspace-save.ts';
-import { packageAdapterPlanSummary } from './operations/services/package-adapters.ts';
-import { inspectWorkspaceDependencyMode } from './operations/services/workspace-dependency-mode.ts';
-import type { TreeseedWorkflowNextStep } from './workflow.ts';
-import { type TreeseedWorkflowBranchRole } from './workflow/policy.ts';
+import { collectPublicPackageReleaseLineState } from './operations/services/workspace-save.js';
+import { packageAdapterPlanSummary } from './operations/services/package-adapters.js';
+import { inspectWorkspaceDependencyMode } from './operations/services/workspace-dependency-mode.js';
+import type { TreeseedWorkflowNextStep } from './workflow.js';
+import { type TreeseedWorkflowBranchRole } from './workflow/policy.js';
 export type TreeseedBranchRole = TreeseedWorkflowBranchRole;
 export type TreeseedWorkflowRecommendation = TreeseedWorkflowNextStep;
 export type TreeseedWorkflowEnvironmentStatus = {