@ricsam/r5d-worker 0.0.82 → 0.0.86

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

@@ -21,6 +21,23 @@ export type PendingCreatedBranchAutomaticSyncDeferral = {
 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;
+/**
+ * Activity fence evaluated from inside the workspace mutation gate's exclusive
+ * sync lease. Canonical-sync targets are deliberately absent: an immediately
+ * reserved follow-up remediation command may already be queued, but the gate
+ * proves that it cannot overlap this sync. A credential-bearing process group
+ * that survived command teardown is tracked separately and still fails closed.
+ */
+export declare function projectBranchMountBusyDuringExclusiveSync(input: {
+    projectId: string;
+    branchName: string;
+    executionDisabled: boolean;
+    worktreeOperationInProgress: boolean;
+    retainedCanonicalProcessGroup: boolean;
+    activeTargets: Iterable<ProjectTarget | WorkspaceTarget>;
+}): boolean;
+/** Fence visible activity and any retained canonical descendant that outlived its command lease. */
+export declare function workspacePlansMountBusyDuringExclusiveSync(activeTargets: Iterable<ProjectTarget | WorkspaceTarget>, retainedCanonicalProcessGroup?: boolean): 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

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

@@ -25,5 +25,12 @@ export declare function reserveWorkspaceCommandAfterCurrentSync(target: Workspac
  */
 export declare function shouldSerializeWorkspaceCommand(target: WorkspaceCommandTarget): boolean;
 export declare function runWorkspaceCommand<T>(target: WorkspaceCommandTarget, coordinator: WorkspaceCommandMutationCoordinator, operation: () => Promise<T> | T): Promise<T>;
+/**
+ * Run a command whose target was reserved before asynchronous preparation.
+ * For a serialized canonical command, the reservation must disappear inside
+ * the mutation operation: removing it after `runMutation` resolves is too
+ * late because releasing the lease can synchronously wake a queued sync.
+ */
+export declare function runReservedWorkspaceCommand<T>(target: WorkspaceCommandTarget, coordinator: WorkspaceCommandMutationCoordinator, operation: () => Promise<T> | T, releaseReservation: () => void): Promise<T>;
 export declare function acquireWorkspaceCommandMutation(target: WorkspaceCommandTarget, coordinator: WorkspaceCommandMutationCoordinator): Promise<(() => void) | undefined>;
 export {};

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

@@ -34,6 +34,14 @@ export type WorkspaceGitMount = {
     /** Activity-only fence used before checkout readiness is established on reconnect. */
     busyForRecovery?: () => boolean;
 };
+/**
+ * Incident-bound configuration keeps project checkouts unready while the
+ * canonical remediation owns the workspace. The guarded remediation sync is
+ * nevertheless allowed to hydrate an existing checkout when its activity-only
+ * fence is clear; the ordinary `busy` predicate would mistake that deliberate
+ * unready state for concurrent visible work.
+ */
+export declare function workspaceGitMountsForRemediation(mounts: readonly WorkspaceGitMount[]): WorkspaceGitMount[];
 export type WorkspaceGitSyncOutcome = "no_change" | "updated" | "pushed" | "large_diff_blocked" | "conflict_blocked";
 export type WorkspaceGitSyncResult = {
     outcome: WorkspaceGitSyncOutcome;
@@ -53,8 +61,13 @@ export type WorkspaceGitSyncResult = {
         remote: string;
     };
     conflictKind?: "integration_rebase" | "projection_merge";
+    verifiedAncestorHeads?: string[];
     error?: string;
 };
+/** A guarded remediation was rejected before it was allowed to hydrate or publish. */
+export declare class WorkspaceRemediationAncestryError extends Error {
+    constructor(message: string);
+}
 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;
@@ -68,6 +81,22 @@ declare function configureWorkspaceRepository(input: {
         email: string;
     };
 }): void;
+/**
+ * Rebind only the existing canonical checkout's local Git configuration while
+ * an incident owns its HEAD. In particular, this deliberately does not fetch,
+ * recover durability, move refs, reset the index/worktree, or inspect/abort an
+ * in-progress merge or rebase.
+ */
+export declare function configureExistingWorkspaceGitForRemediation(input: {
+    workspacePath: string;
+    remoteUrl: string;
+    credentialHelper?: string | null;
+    credentialUsername?: string | null;
+    gitIdentity: {
+        name: string;
+        email: string;
+    };
+}): void;
 export declare function ensureWorkspaceGitClone(input: {
     workspacePath: string;
     remoteUrl: string;
@@ -113,6 +142,7 @@ export declare function resetWorkspaceGit(input: {
     activeMountIds: string[];
     skippedMountIds: string[];
 };
+declare function diffSizeBytes(workspacePath: string, baseRevision: string | null, headRevision: string, limit: number): Promise<number>;
 export declare function synchronizeWorkspaceGit(input: {
     attemptId?: string;
     workerLabel: string;
@@ -131,6 +161,12 @@ export declare function synchronizeWorkspaceGit(input: {
     maxPushAttempts?: number;
     /** Publish edits already made in the outer clone without first projecting visible mounts over them. */
     skipMountMirror?: boolean;
+    /** Positive ancestry proof required before a remediation may integrate, publish, or hydrate. */
+    requiredAncestorHeads?: readonly string[];
+    /** Revalidate the worker/config/incident generation after every async boundary. */
+    assertStillAdmitted?: () => void;
+    /** Test seam for exercising an incident transition during asynchronous diff measurement. */
+    measureDiffSize?: typeof diffSizeBytes;
     afterWorkspacePublished?: (context: {
         publishedHead: string;
         activeMountIds: string[];

package/package.json

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