@ricsam/r5d-worker 0.0.78 → 0.0.80

package/dist/types/project-worktrees.d.ts

@@ -1,5 +1,19 @@
 export declare const PROJECT_WORKTREE_SNAPSHOT_PREFIX = "r5d-project-worktrees-";
+declare const PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION: 1;
+type ProjectWorktreeSnapshotManifest = {
+    version: typeof PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION;
+    state: "building" | "prepared" | "consumed";
+    ownerProcessId: number;
+    ownerSessionId: string;
+    projectRoot: string;
+    branches: Array<{
+        branchName: string;
+        snapshotPresent: boolean;
+    }>;
+    createdAt: string;
+};
 export type ProjectWorktreeBranch = {
+    branchId?: string;
     branchName: string;
     baseCommitHash: string;
     sourceBranchName?: string | null;
@@ -12,12 +26,30 @@ export type ProjectWorktreeState = {
     ahead: number | null;
     behind: number | null;
 };
+/**
+ * Creation failed after its branch ref may have been written, and rollback
+ * could not prove that every local artifact was removed. Callers must retain
+ * their durable creation intent so a later cleanup can recover it.
+ */
+export declare class ProjectBranchCreationRollbackIncompleteError extends Error {
+    readonly branchMayExist: true;
+    readonly cleanupFailures: readonly string[];
+    constructor(branchName: string, cleanupFailures: readonly string[], cause: unknown);
+}
+export declare function projectBranchMayExistAfterCreateFailure(error: unknown): boolean;
 export declare function projectWorktreeConfigurationFingerprint(input: {
     checkoutPathSegments: readonly string[];
     projectPath: string;
     repoHttpUrl: string | null;
     repoAuthHeader: string | null;
     defaultBranch: string;
+    repositoryTransitionId?: string | null;
+    executionDisabled?: boolean;
+    mirrorWritesDisabled?: boolean;
+    preserveOnlyBranches?: readonly {
+        branchId?: string;
+        branchName: string;
+    }[];
     branches: readonly ProjectWorktreeBranch[];
     gitIdentity: {
         name: string;
@@ -30,19 +62,31 @@ export declare function hasLinkedProjectWorktreeLayout(input: {
     primaryBranchName: string;
     branches: readonly Pick<ProjectWorktreeBranch, "branchName">[];
 }): boolean;
-export declare function cleanupStaleProjectWorktreeSnapshots(input?: {
+export declare function recoverStaleProjectWorktreeSnapshots(input: {
+    projectsRoot: string;
     temporaryRoot?: string;
     processAlive?: (processId: number) => boolean;
+    currentProcessId?: number;
+    currentOwnerSessionId?: string;
 }): {
+    restored: string[];
     removed: string[];
     failed: Array<{
         path: string;
         error: string;
     }>;
 };
+export declare function projectOriginBranchName(input: {
+    branchName: string;
+    primaryBranchName: string;
+    defaultBranch: string;
+}): string;
 declare function configureRepository(input: {
     primaryPath: string;
     originUrl: string;
+    primaryBranchName?: string;
+    defaultBranch?: string;
+    branches?: readonly Pick<ProjectWorktreeBranch, "branchName">[];
     credentialHelper?: string | null;
     originCredentialUsername?: string | null;
     gitIdentity?: {
@@ -53,6 +97,7 @@ declare function configureRepository(input: {
 export declare function ensureProjectWorktrees(input: {
     projectRoot: string;
     primaryBranchName: string;
+    defaultBranch?: string;
     branches: readonly ProjectWorktreeBranch[];
     originUrl: string;
     mirrorUrl: string;
@@ -63,6 +108,8 @@ export declare function ensureProjectWorktrees(input: {
         name: string;
         email: string;
     } | null;
+    exactMirrorBranches?: ReadonlySet<string>;
+    snapshotRoot?: string;
 }): ProjectWorktreeState[];
 export declare function projectWorktreeOperationInProgress(checkoutPath: string): boolean;
 export declare function createLinkedProjectBranch(input: {
@@ -73,6 +120,22 @@ export declare function createLinkedProjectBranch(input: {
     branchPath: string;
     baseCommitHash: string;
 };
+/**
+ * A retained pending intent is ownership proof for artifacts left by an
+ * interrupted earlier attempt. Remove those artifacts idempotently before
+ * recreating; if cleanup still fails, the caller keeps the same intent and can
+ * retry again later.
+ */
+export declare function createOrRetryLinkedProjectBranch(input: {
+    projectRoot: string;
+    primaryBranchName: string;
+    sourceBranchName: string;
+    branchName: string;
+    pendingRetry: boolean;
+}): {
+    branchPath: string;
+    baseCommitHash: string;
+};
 export declare function deleteLinkedProjectBranch(input: {
     projectRoot: string;
     primaryBranchName: string;
@@ -98,27 +161,81 @@ export declare function pushProjectMirrorHeads(input: {
     credentialHelper?: string | null;
     credentialUsername?: string | null;
     onlyBranches?: ReadonlySet<string>;
+    /** Exact pre-projection commits to publish after the outer tree is reachable. */
+    publicationHeads?: ReadonlyMap<string, string>;
 }): Array<{
     branchName: string;
     head: string;
     pushed: boolean;
     reason?: string;
 }>;
-export declare function fastForwardProjectHeadsFromMirror(input: {
+export declare function assertProjectMirrorHeadsPushed(results: readonly {
+    branchName: string;
+    pushed: boolean;
+    reason?: string;
+}[]): void;
+type ProjectMirrorHeadUpdateInput = {
     projectRoot: string;
     primaryBranchName: string;
     branchNames: readonly string[];
     mirrorUrl: string;
     credentialHelper?: string | null;
     credentialUsername?: string | null;
+    /** Rechecked after fetch and ancestry inspection, immediately before refs or the index move. */
+    branchMutationAllowed?: (branchName: string, checkoutPath: string) => boolean;
+};
+export type ProjectMirrorHeadObservation = {
+    branchName: string;
+    previousHead: string;
+    mirrorHead: string | null;
+    mode: "fast_forward" | "reseed";
+    shouldMove: boolean;
+};
+/**
+ * Fetch and pin the exact hidden-mirror tips that may be applied after a
+ * causally later outer-workspace fetch and hydration. Observation deliberately
+ * does not mutate a live branch or its index.
+ */
+export declare function observeProjectMirrorHeads(input: Omit<ProjectMirrorHeadUpdateInput, "branchMutationAllowed"> & {
+    allowNonFastForward: boolean;
+}): ProjectMirrorHeadObservation[];
+/** Apply only previously observed object ids; this function never refetches. */
+export declare function applyObservedProjectMirrorHeads(input: {
+    projectRoot: string;
+    primaryBranchName: string;
+    observations: readonly ProjectMirrorHeadObservation[];
+    /** Rechecked immediately before refs or the index move. */
+    branchMutationAllowed?: (branchName: string, checkoutPath: string) => boolean;
 }): Array<{
+    branchName: string;
+    previousHead: string;
+    mirrorHead: string | null;
+    moved: boolean;
+}>;
+export declare function fastForwardProjectHeadsFromMirror(input: ProjectMirrorHeadUpdateInput): Array<{
     branchName: string;
     previousHead: string;
     mirrorHead: string | null;
     fastForwarded: boolean;
 }>;
+export declare function reseedProjectHeadsFromMirror(input: ProjectMirrorHeadUpdateInput): Array<{
+    branchName: string;
+    previousHead: string;
+    mirrorHead: string | null;
+    reseeded: boolean;
+}>;
 export declare const projectWorktreesTestHarness: {
     commandArgs: typeof gitCommandArgs;
     configureRepository: typeof configureRepository;
+    createPreparedSnapshot(input: {
+        projectRoot: string;
+        branches: readonly ProjectWorktreeBranch[];
+        temporaryRoot: string;
+    }): {
+        root: string;
+    };
+    consumeSnapshot(snapshotRoot: string): void;
+    persistProjectAndConsumeSnapshot(snapshotRoot: string, afterProjectTreeFsync?: () => void): void;
+    snapshotState(snapshotRoot: string): ProjectWorktreeSnapshotManifest["state"];
 };
 export {};

package/dist/types/registry-auth.d.ts

@@ -0,0 +1,47 @@
+export declare const APP_MANAGED_GITHUB_REGISTRY: "ghcr.io";
+export type GitHubRegistryCredential = {
+    registry: typeof APP_MANAGED_GITHUB_REGISTRY;
+    username: string;
+    token: string;
+};
+export declare class RegistryAuthConfigurationError extends Error {
+    constructor(cause: unknown);
+}
+export declare function registryAuthHasAppManagedGitHubCredential(filePath: string): boolean;
+type DirectoryFsyncDependencies = {
+    platform: NodeJS.Platform;
+    open: (directory: string) => number;
+    fsync: (descriptor: number) => void;
+    close: (descriptor: number) => void;
+};
+declare function fsyncDirectory(directory: string, dependencies?: DirectoryFsyncDependencies): void;
+export type PrivateAuthFileUpdate = {
+    filePath: string;
+    content: string | null;
+    allowSymlinkRemoval?: boolean;
+};
+export type PreparedPrivateAuthFileGeneration = {
+    readonly changed: boolean;
+    commit(beforeMutation?: (filePath: string, index: number) => void): void;
+    discard(): void;
+};
+/**
+ * Validate and fsync every replacement before exposing the first new auth
+ * byte. Cross-file publication is necessarily sequential, so callers must
+ * fence/terminate the previous process generation before commit and treat any
+ * commit error as a fatal partial-generation boundary.
+ */
+export declare function preparePrivateAuthFileGeneration(updates: readonly PrivateAuthFileUpdate[]): PreparedPrivateAuthFileGeneration;
+export declare function planGitHubRegistryAuthFiles(filePaths: readonly string[], credential: GitHubRegistryCredential | null): PrivateAuthFileUpdate[];
+/**
+ * Authoritatively replace the app-owned ghcr.io entry while retaining every
+ * unrelated Docker/containers auth entry and top-level setting.
+ */
+export declare function updateGitHubRegistryAuthFile(filePath: string, credential: GitHubRegistryCredential | null): void;
+export declare function configureGitHubRegistryAuthFiles(filePaths: readonly string[], credential: GitHubRegistryCredential | null): void;
+export declare const registryAuthTestHarness: {
+    fsyncDirectory: typeof fsyncDirectory;
+    atomicReplacePrivateFile(filePath: string, content: string, beforeRename?: () => void): void;
+    configureFiles(filePaths: readonly string[], credential: GitHubRegistryCredential | null, beforeRename: (filePath: string, index: number) => void): void;
+};
+export {};

package/dist/types/repository-transition-policy.d.ts

@@ -0,0 +1,26 @@
+export type WorkerRepositoryTransitionState = {
+    repositoryTransitionId: string | null;
+    executionDisabled: boolean;
+    mirrorWritesDisabled: boolean;
+};
+export type LastEnabledRepositoryTransition = {
+    known: boolean;
+    transitionId: string | null;
+};
+export declare function assertRepositoryTransitionState(project: WorkerRepositoryTransitionState & {
+    projectId: string;
+}): void;
+/** Disabled repositories retain their local state but expose no execution root. */
+export declare function assertRepositoryExecutionEnabled(project: Pick<WorkerRepositoryTransitionState, "executionDisabled"> & {
+    projectId: string;
+}): void;
+/** Every hidden-mirror ref mutation, including deletion, uses this fence. */
+export declare function repositoryMirrorWritesAllowed(project: Pick<WorkerRepositoryTransitionState, "executionDisabled" | "mirrorWritesDisabled"> | undefined): boolean;
+/**
+ * A disabled snapshot never consumes the reseed obligation. Missing durable
+ * history is treated conservatively after restart and reseeded once enabled.
+ */
+export declare function enabledRepositoryTransitionRequiresReseed(input: {
+    project: Pick<WorkerRepositoryTransitionState, "repositoryTransitionId" | "executionDisabled">;
+    lastEnabled: LastEnabledRepositoryTransition;
+}): boolean;

package/dist/types/supervisor-daemonized-fixture.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/supervisor-signal-fixture.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/supervisor.d.ts

@@ -1,17 +1,19 @@
+import { type KillableSubprocess } from "./process-tree";
 export declare const WORKER_RUNTIME_ENV = "R5D_WORKER_INTERNAL_RUNTIME";
 export declare const WORKER_RELOAD_EXIT_CODE = 75;
 export declare const WORKER_RECONNECT_EXIT_CODE = 76;
+export declare const WORKER_CREDENTIAL_RESTART_EXIT_CODE = 77;
 export declare const WORKER_RECONNECT_DELAY_MS = 2000;
-type RuntimeProcess = {
-    exited: Promise<number>;
-};
+type RuntimeProcess = KillableSubprocess;
 export type RuntimeSpawner = (argv: string[], options: {
     stdin: "inherit";
     stdout: "inherit";
     stderr: "inherit";
+    detached: true;
     env: Record<string, string | undefined>;
 }) => RuntimeProcess;
 export type RuntimeDelay = (delayMs: number) => Promise<void>;
+export type RuntimeReaper = (runtime: RuntimeProcess) => Promise<void>;
 export declare function isRetryableWorkerServerStatus(status: number): boolean;
-export declare function superviseWorkerRuntime(argv: string[], env?: Record<string, string | undefined>, spawnRuntime?: RuntimeSpawner, waitBeforeReconnect?: RuntimeDelay): Promise<number>;
+export declare function superviseWorkerRuntime(argv: string[], env?: Record<string, string | undefined>, spawnRuntime?: RuntimeSpawner, waitBeforeReconnect?: RuntimeDelay, reapCredentialRuntime?: RuntimeReaper): Promise<number>;
 export {};

package/dist/types/working-tree-mirror.d.ts

@@ -1,5 +1,6 @@
 export type WorkingTreeSourceMode = "all" | "git";
 export type WorkingTreeDeletionMode = "all" | "git";
+export type WorkingTreeMirrorDurability = "per_entry" | "deferred_private_staging";
 type TreeEntry = {
     kind: "directory";
     mode: number;
@@ -12,12 +13,25 @@ type TreeEntry = {
     mode: number;
     target: string;
 };
+/**
+ * Destructive native-tree moves cannot silently apply the Git-target filter:
+ * doing so would delete legitimate case-sensitive POSIX filenames after the
+ * filtered copy. Exact native `.git` metadata is intentionally disposable;
+ * every portable alias must be remediated before the old tree is retired.
+ */
+export declare function assertWorkingTreeHasNoPortableGitMetadataAliases(root: string): void;
 export declare function inspectWorkingTree(root: string, mode: WorkingTreeSourceMode): Map<string, TreeEntry>;
 export declare function mirrorWorkingTree(input: {
     sourceRoot: string;
     targetRoot: string;
     sourceMode: WorkingTreeSourceMode;
     deletionMode: WorkingTreeDeletionMode;
+    /**
+     * Defer destination fsync only while building an unpublished private tree.
+     * The caller must durably fsync that complete tree before publishing it or
+     * mutating the source authority.
+     */
+    durability?: WorkingTreeMirrorDurability;
 }): {
     paths: string[];
 };

package/dist/types/workspace-automatic-sync-policy.d.ts

@@ -0,0 +1,37 @@
+type ProjectTarget = {
+    type: "project";
+    projectId: string;
+    branchName: string;
+};
+type WorkspaceTarget = {
+    type: "workspace";
+    rootProfile: "visible_projects" | "canonical_sync";
+};
+type PendingCreatedBranch = {
+    projectId: string;
+    branchName: string;
+};
+export declare const PENDING_CREATED_BRANCH_AUTOMATIC_SYNC_GRACE_MS = 120000;
+export type PendingCreatedBranchAutomaticSyncDeferral = {
+    kind: "active_target";
+} | {
+    kind: "creation_grace";
+    retryAfterMs: number;
+};
+export declare function pendingCreatedBranchKey(projectId: string, branchName: string): string;
+export declare function hasActiveVisibleProjectsWorkspaceTarget(activeTargets: Iterable<ProjectTarget | WorkspaceTarget>): boolean;
+export declare function projectBranchHasActiveWorkspaceTarget(projectId: string, branchName: string, activeTargets: Iterable<ProjectTarget | WorkspaceTarget>): boolean;
+/**
+ * A workspace sync is global and synchronous enough to monopolize the worker
+ * event loop. Keep automatic intent pending while an agent process is active
+ * on a creator-local branch, so that process can issue its next command. Its
+ * terminal trigger (or a later periodic/connect cycle) publishes afterward.
+ */
+export declare function shouldDeferAutomaticWorkspaceSyncForPendingBranch(pendingCreatedBranches: readonly PendingCreatedBranch[], activeTargets: Iterable<ProjectTarget | WorkspaceTarget>): boolean;
+/**
+ * Automatic publication yields briefly after local branch creation so the
+ * server can durably record the branch and reserve its first agent process.
+ * Explicit/reconnect synchronization does not use this policy.
+ */
+export declare function pendingCreatedBranchAutomaticSyncDeferral(pendingCreatedBranches: readonly PendingCreatedBranch[], activeTargets: Iterable<ProjectTarget | WorkspaceTarget>, publicationNotBeforeByBranch: ReadonlyMap<string, number>, nowMs?: number): PendingCreatedBranchAutomaticSyncDeferral | null;
+export {};

package/dist/types/workspace-branch-incarnation-policy.d.ts

@@ -0,0 +1,14 @@
+type BranchIncarnation = {
+    branchId?: string;
+};
+/**
+ * Deletion is idempotent only while no same-name state belongs to another
+ * durable row. Call this inside the workspace mutation lease, before creating
+ * a tombstone or touching a checkout/ref.
+ */
+export declare function assertProjectBranchDeletionIncarnation(input: {
+    requiredBranchId: string;
+    configuredBranch?: BranchIncarnation;
+    pendingLocalBranch?: BranchIncarnation;
+}): void;
+export {};

package/dist/types/workspace-command-sync-policy.d.ts

@@ -8,6 +8,15 @@ type WorkspaceCommandMutationCoordinator = {
     runMutation<T>(operation: () => Promise<T> | T): Promise<T>;
     acquireMutation(): Promise<() => void>;
 };
+type WorkspaceSyncCompletionBarrier = {
+    afterCurrent(): Promise<void>;
+};
+/**
+ * A visible command must not become active halfway through an outer sync. Wait
+ * for the current cycle, then register the target without another await so a
+ * later cycle observes the reservation and defers before integration.
+ */
+export declare function reserveWorkspaceCommandAfterCurrentSync(target: WorkspaceCommandTarget, coordinator: WorkspaceSyncCompletionBarrier, reserve: () => void): Promise<void>;
 /**
  * Commands in visible checkouts behave like independent Git clients and may
  * overlap periodic synchronization. Canonical remediation commands mutate the

package/dist/types/workspace-git-sync.d.ts

@@ -2,15 +2,35 @@ import { type WorkingTreeSourceMode } from "./working-tree-mirror";
 export declare const WORKSPACE_GIT_BRANCH = "main";
 export declare const MAX_WORKSPACE_GIT_DIFF_BYTES: number;
 export declare const WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION = "r5d-confirm-large-diff-v1";
+export declare const WORKSPACE_GIT_HYDRATED_RECEIPT = "r5d/workspace-hydrated-head";
+export declare const WORKSPACE_GIT_HYDRATION_TRANSACTION = "r5d/workspace-hydration-transaction";
+export declare const WORKSPACE_GIT_CHECKOUT_DURABILITY = "r5d/workspace-checkout-durability";
 export type WorkspaceGitMount = {
     id: string;
+    /** Durable logical incarnation (for example the project-branch row id). */
+    hydrationIncarnationKey: string;
     sourcePath: string;
+    /** Existing managed root through which hydrated source directory entries are durably published. */
+    durabilityRootPath: string;
     workspaceRelativePath: string;
     sourceMode: WorkingTreeSourceMode;
     hydrateDeletionMode: "all" | "git";
+    /**
+     * Only an exact creator-local unpublished mount may treat an absent outer
+     * subtree as bootstrap authority before this clone has a hydration receipt.
+     * Published/active mounts treat absence as a canonical deletion.
+     */
+    preserveLocalOnInitialOuterAbsence?: boolean;
+    /**
+     * Preserve a durably copied local tree across an exact checkout-path move.
+     * This is transient and must clear after that move is published.
+     */
+    preserveLocalOnHydrationBasisChange?: boolean;
     /** Remove the outer-workspace subtree when the mounted source was intentionally deleted. */
     deleteWhenSourceMissing?: boolean;
     busy?: () => boolean;
+    /** Activity-only fence used before checkout readiness is established on reconnect. */
+    busyForRecovery?: () => boolean;
 };
 export type WorkspaceGitSyncOutcome = "no_change" | "updated" | "pushed" | "large_diff_blocked" | "conflict_blocked";
 export type WorkspaceGitSyncResult = {
@@ -34,6 +54,7 @@ export type WorkspaceGitSyncResult = {
 };
 declare function gitCommandArgs(args: string[]): string[];
 declare function workspaceCloneCommandArgs(args: string[], remoteUrl: string, credentialHelper?: string | null, credentialUsername?: string | null): string[];
+export declare function workspaceGitHydrationIsCurrent(workspacePath: string, mounts?: readonly WorkspaceGitMount[]): boolean;
 declare function configureWorkspaceRepository(input: {
     workspacePath: string;
     remoteUrl: string;
@@ -58,7 +79,16 @@ export declare function ensureWorkspaceGitClone(input: {
     remoteHead: string | null;
 };
 declare function mirrorMountsToWorkspace(workspacePath: string, mounts: readonly WorkspaceGitMount[]): void;
-export declare function hydrateWorkspaceGitMounts(workspacePath: string, mounts: readonly WorkspaceGitMount[]): void;
+export declare function hydrateWorkspaceGitMounts(workspacePath: string, mounts: readonly WorkspaceGitMount[], options?: {
+    ignoreBusy?: boolean;
+}): {
+    hydratedMountIds: string[];
+    skippedMountIds: string[];
+};
+export declare function recoverWorkspaceGitHydration(workspacePath: string, mounts: readonly WorkspaceGitMount[], options?: {
+    ignoreBusy?: boolean;
+    deferMountIds?: ReadonlySet<string>;
+}): void;
 export declare function resetWorkspaceGit(input: {
     workspacePath: string;
     remoteUrl: string;
@@ -74,6 +104,8 @@ export declare function resetWorkspaceGit(input: {
     localHead: string | null;
     remoteHead: string | null;
     discardedPaths: string[];
+    activeMountIds: string[];
+    skippedMountIds: string[];
 };
 export declare function synchronizeWorkspaceGit(input: {
     attemptId?: string;
@@ -93,8 +125,6 @@ export declare function synchronizeWorkspaceGit(input: {
     maxPushAttempts?: number;
     /** Publish edits already made in the outer clone without first projecting visible mounts over them. */
     skipMountMirror?: boolean;
-    /** Leave visible mounts untouched after publication (used by remediation commands in the outer clone). */
-    skipMountHydration?: boolean;
     afterWorkspacePublished?: (context: {
         publishedHead: string;
         activeMountIds: string[];

package/dist/types/workspace-mount-boundary.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Validate every existing path component from a trusted root to a managed
+ * directory without following symlinks. Missing suffixes are allowed because
+ * hydration and path moves create them after this check.
+ */
+export declare function assertManagedDirectoryPath(input: {
+    trustedRoot: string;
+    candidate: string;
+    label: string;
+}): void;

package/dist/types/workspace-path-move.d.ts

@@ -0,0 +1,21 @@
+export type ProjectCheckoutPathMoveBranch = {
+    branchName: string;
+    outerWorkspaceRelativePath: string;
+};
+export declare function checkoutPathMovePublicationComplete(requiredMountIds: readonly string[], activeMountIds: ReadonlySet<string>): boolean;
+/**
+ * Move the project checkout location without making its old root the only copy
+ * of dirty or ignored working state. The canonical outer tree receives the
+ * Git-visible projection, while the new root receives every non-.git byte so
+ * repository activation can reconstruct Git metadata without losing local
+ * files. Both copies are stable before the obsolete worktree root is removed.
+ */
+export declare function preserveProjectCheckoutPathMove(input: {
+    oldProjectRoot: string;
+    newProjectRoot: string;
+    projectsDurabilityRoot: string;
+    outerWorkspaceRoot: string;
+    branches: readonly ProjectCheckoutPathMoveBranch[];
+}): {
+    preservedBranchNames: string[];
+};

package/dist/types/workspace-preserve-only-policy.d.ts

@@ -0,0 +1,15 @@
+export type WorkerProjectBranchDisposition = "active" | "creator_local" | "preserve_only";
+/** Name equality never grants creator authority across branch incarnations. */
+export declare function creatorLocalProjectBranchIsAuthorized(input: {
+    pendingBranchId: string | undefined;
+    preserveOnlyBranchId: string | undefined;
+}): boolean;
+/**
+ * A globally pending branch is executable only on the worker that durably
+ * recorded its local creation. Every other worker treats the same protocol
+ * entry as preservation metadata, never as a checkout target.
+ */
+export declare function workerProjectBranchDisposition(input: {
+    activeConfigured: boolean;
+    locallyPendingCreated: boolean;
+}): WorkerProjectBranchDisposition;

package/dist/types/workspace-project-config-policy.d.ts

@@ -0,0 +1,34 @@
+type ProjectTarget = {
+    type: "project";
+    projectId: string;
+};
+type WorkspaceTarget = {
+    type: "workspace";
+    rootProfile: "visible_projects" | "canonical_sync";
+};
+type ProjectConfiguration = {
+    projectId: string;
+};
+type ProjectConfigurationWithBranches = ProjectConfiguration & {
+    branches: readonly {
+        branchName: string;
+    }[];
+};
+export declare function deferredProjectConfigurationPendingBranches(projects: readonly ProjectConfigurationWithBranches[]): Array<{
+    projectId: string;
+    branchName: string;
+}>;
+/**
+ * Identify configuration changes that would touch a project while visible
+ * checkout activity is active or reserved. A visible-projects target covers
+ * every project; canonical-sync activity is isolated in the outer clone.
+ */
+export declare function busyProjectConfigurationChangeIds<TProject extends ProjectConfiguration>(input: {
+    currentProjects: readonly TProject[];
+    incomingProjects: readonly TProject[];
+    activeTargets: Iterable<ProjectTarget | WorkspaceTarget>;
+    currentFingerprint: (project: TProject) => string;
+    incomingFingerprint: (project: TProject) => string;
+    currentProjectReady: (project: TProject) => boolean;
+}): string[];
+export {};

package/dist/types/workspace-publication-evidence.d.ts

@@ -0,0 +1,17 @@
+export type ProjectBranchPublicationEvidence = {
+    branchId: string;
+    projectId: string;
+    branchName: string;
+};
+/** Select only branch mounts that completed this synchronization cycle. */
+export declare function activeProjectBranchNames(projectId: string, branchNames: readonly string[], activeMountIds: readonly string[]): string[];
+/** Bind physical active mounts to the exact configured branch-row snapshot. */
+export declare function activeProjectBranchPublicationEvidence(projects: readonly {
+    projectId: string;
+    executionDisabled?: boolean;
+    mirrorWritesDisabled?: boolean;
+    branches: readonly {
+        branchId: string;
+        branchName: string;
+    }[];
+}[], activeMountIds: readonly string[]): ProjectBranchPublicationEvidence[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.78",
+  "version": "0.0.80",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",