@ricsam/r5d-worker 0.0.83 → 0.0.87

package/dist/types/main.d.ts

@@ -91,6 +91,7 @@ type WorkerServerMessage = {
     gitIdentity: WorkerGitIdentity;
     githubCredential: WorkerGitHubCredential | null;
     deferWorkspaceSyncForIncidentId?: string;
+    resetToCanonical?: boolean;
 } | {
     type: "sync_workspace";
     requestId: string;
@@ -565,8 +566,20 @@ type DeferredWorkspaceConfiguration = {
 };
 declare function workspaceIncidentTerminalClearDisposition(input: {
     deferredConfiguration: DeferredWorkspaceConfiguration | null;
-    clearedIncidentId: string | null;
-}): "ordinary_resume" | "await_server_refresh" | "reconnect_for_refresh";
+    clearedIncidentId: string;
+}): "await_server_refresh" | "reconnect_for_refresh";
+declare function workspaceIncidentTerminalRefreshFence(input: {
+    deferredConfiguration: DeferredWorkspaceConfiguration | null;
+    clearedIncidentId: string;
+}): {
+    disposition: "await_server_refresh" | "reconnect_for_refresh";
+    deferredConfiguration: DeferredWorkspaceConfiguration;
+};
+declare function workspaceAutomaticSyncIsAdmitted(input: {
+    workspaceConfigured: boolean;
+    activeIncidentId: string | null;
+    deferredConfiguration: DeferredWorkspaceConfiguration | null;
+}): boolean;
 declare function deferredWorkspaceTargetIsAllowed(deferredConfiguration: DeferredWorkspaceConfiguration | null, activeIncidentId: string | null, target: WorkerSessionTarget): boolean;
 declare function deferredWorkspaceSyncTriggerIsAllowed(deferredConfiguration: DeferredWorkspaceConfiguration | null, activeIncidentId: string | null, trigger: WorkspaceSyncTrigger): boolean;
 declare function workspaceOperationsAreFenced(deferredConfiguration: DeferredWorkspaceConfiguration | null, activeIncidentId: string | null): boolean;
@@ -577,6 +590,7 @@ declare function deferredCredentialTransitionMustWait(input: {
     canonicalRemediationActive: boolean;
 }): boolean;
 declare function workspaceConfigurationIncidentSnapshotIsCurrent(capturedIncidentId: string | null, activeIncidentId: string | null): boolean;
+declare function workspaceConfigurationResetToCanonicalIsAllowed(requested: boolean | undefined, incidentId: string | null): boolean;
 declare function deferredWorkspaceRefreshWatchdogIsCurrent(input: {
     capturedIncidentId: string;
     deferredConfiguration: DeferredWorkspaceConfiguration | null;
@@ -629,12 +643,15 @@ export declare const workerGitSecurityTestHarness: {
     fenceUnsafeWorkspaceSyncFailure: typeof fenceUnsafeWorkspaceSyncFailure;
     workspaceConfigurationIncidentDeferral: typeof workspaceConfigurationIncidentDeferral;
     workspaceIncidentTerminalClearDisposition: typeof workspaceIncidentTerminalClearDisposition;
+    workspaceIncidentTerminalRefreshFence: typeof workspaceIncidentTerminalRefreshFence;
+    workspaceAutomaticSyncIsAdmitted: typeof workspaceAutomaticSyncIsAdmitted;
     deferredWorkspaceTargetIsAllowed: typeof deferredWorkspaceTargetIsAllowed;
     deferredWorkspaceSyncTriggerIsAllowed: typeof deferredWorkspaceSyncTriggerIsAllowed;
     workspaceOperationsAreFenced: typeof workspaceOperationsAreFenced;
     workspaceCommandTransportIsAllowed: typeof workspaceCommandTransportIsAllowed;
     deferredCredentialTransitionMustWait: typeof deferredCredentialTransitionMustWait;
     workspaceConfigurationIncidentSnapshotIsCurrent: typeof workspaceConfigurationIncidentSnapshotIsCurrent;
+    workspaceConfigurationResetToCanonicalIsAllowed: typeof workspaceConfigurationResetToCanonicalIsAllowed;
     deferredWorkspaceRefreshWatchdogIsCurrent: typeof deferredWorkspaceRefreshWatchdogIsCurrent;
     incidentDeferredProjectCheckouts: typeof incidentDeferredProjectCheckouts;
     deferredIncidentWorkspaceConfigurationResult: typeof deferredIncidentWorkspaceConfigurationResult;

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

@@ -93,7 +93,7 @@ declare function configureRepository(input: {
         name: string;
         email: string;
     } | null;
-}): void;
+}): Promise<void>;
 export declare function ensureProjectWorktrees(input: {
     projectRoot: string;
     primaryBranchName: string;
@@ -110,7 +110,7 @@ export declare function ensureProjectWorktrees(input: {
     } | null;
     exactMirrorBranches?: ReadonlySet<string>;
     snapshotRoot?: string;
-}): ProjectWorktreeState[];
+}): Promise<ProjectWorktreeState[]>;
 export declare function projectWorktreeOperationInProgress(checkoutPath: string): boolean;
 export declare function createLinkedProjectBranch(input: {
     projectRoot: string;
@@ -153,7 +153,7 @@ export declare function deleteProjectMirrorBranch(input: {
     mirrorUrl: string;
     credentialHelper?: string | null;
     credentialUsername?: string | null;
-}): void;
+}): Promise<void>;
 export declare function pushProjectMirrorHeads(input: {
     projectRoot: string;
     branchNames: readonly string[];
@@ -163,12 +163,12 @@ export declare function pushProjectMirrorHeads(input: {
     onlyBranches?: ReadonlySet<string>;
     /** Exact pre-projection commits to publish after the outer tree is reachable. */
     publicationHeads?: ReadonlyMap<string, string>;
-}): Array<{
+}): Promise<Array<{
     branchName: string;
     head: string;
     pushed: boolean;
     reason?: string;
-}>;
+}>>;
 export declare function assertProjectMirrorHeadsPushed(results: readonly {
     branchName: string;
     pushed: boolean;
@@ -198,7 +198,7 @@ export type ProjectMirrorHeadObservation = {
  */
 export declare function observeProjectMirrorHeads(input: Omit<ProjectMirrorHeadUpdateInput, "branchMutationAllowed"> & {
     allowNonFastForward: boolean;
-}): ProjectMirrorHeadObservation[];
+}): Promise<ProjectMirrorHeadObservation[]>;
 /** Apply only previously observed object ids; this function never refetches. */
 export declare function applyObservedProjectMirrorHeads(input: {
     projectRoot: string;
@@ -206,24 +206,24 @@ export declare function applyObservedProjectMirrorHeads(input: {
     observations: readonly ProjectMirrorHeadObservation[];
     /** Rechecked immediately before refs or the index move. */
     branchMutationAllowed?: (branchName: string, checkoutPath: string) => boolean;
-}): Array<{
+}): Promise<Array<{
     branchName: string;
     previousHead: string;
     mirrorHead: string | null;
     moved: boolean;
-}>;
-export declare function fastForwardProjectHeadsFromMirror(input: ProjectMirrorHeadUpdateInput): Array<{
+}>>;
+export declare function fastForwardProjectHeadsFromMirror(input: ProjectMirrorHeadUpdateInput): Promise<Array<{
     branchName: string;
     previousHead: string;
     mirrorHead: string | null;
     fastForwarded: boolean;
-}>;
-export declare function reseedProjectHeadsFromMirror(input: ProjectMirrorHeadUpdateInput): Array<{
+}>>;
+export declare function reseedProjectHeadsFromMirror(input: ProjectMirrorHeadUpdateInput): Promise<Array<{
     branchName: string;
     previousHead: string;
     mirrorHead: string | null;
     reseeded: boolean;
-}>;
+}>>;
 export declare const projectWorktreesTestHarness: {
     commandArgs: typeof gitCommandArgs;
     configureRepository: typeof configureRepository;

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

@@ -22,10 +22,30 @@ export declare function pendingCreatedBranchKey(projectId: string, branchName: s
 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.
+ * 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;
+/**
+ * Keep automatic intent pending while an agent process is active on a
+ * creator-local branch: the branch's mount would be skipped as busy anyway,
+ * and the cycle's subprocess and disk work would only compete with that
+ * process's next command. Its terminal trigger (or a later periodic/connect
+ * cycle) publishes afterward. (The sync cycle itself now yields the event
+ * loop while it runs; this deferral is about not starting pointless work,
+ * not about loop starvation.)
  */
 export declare function shouldDeferAutomaticWorkspaceSyncForPendingBranch(pendingCreatedBranches: readonly PendingCreatedBranch[], activeTargets: Iterable<ProjectTarget | WorkspaceTarget>): boolean;
 /**

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;
@@ -72,7 +80,7 @@ declare function configureWorkspaceRepository(input: {
         name: string;
         email: string;
     };
-}): void;
+}): Promise<void>;
 /**
  * Rebind only the existing canonical checkout's local Git configuration while
  * an incident owns its HEAD. In particular, this deliberately does not fetch,
@@ -88,7 +96,7 @@ export declare function configureExistingWorkspaceGitForRemediation(input: {
         name: string;
         email: string;
     };
-}): void;
+}): Promise<void>;
 export declare function ensureWorkspaceGitClone(input: {
     workspacePath: string;
     remoteUrl: string;
@@ -99,23 +107,23 @@ export declare function ensureWorkspaceGitClone(input: {
         email: string;
     };
     preserveResolutionInProgress?: boolean;
-}): {
+}): Promise<{
     localHead: string | null;
     remoteHead: string | null;
-};
+}>;
 declare function mirrorMountsToWorkspace(workspacePath: string, mounts: readonly WorkspaceGitMount[]): void;
 export declare function hydrateWorkspaceGitMounts(workspacePath: string, mounts: readonly WorkspaceGitMount[], options?: {
     ignoreBusy?: boolean;
-}): {
+}): Promise<{
     hydratedMountIds: string[];
     skippedMountIds: string[];
-};
+}>;
 export declare function recoverWorkspaceGitHydration(workspacePath: string, mounts: readonly WorkspaceGitMount[], options?: {
     ignoreBusy?: boolean;
     deferMountIds?: ReadonlySet<string>;
     preserveResolutionInProgress?: boolean;
     preserveStaleBases?: boolean;
-}): void;
+}): Promise<void>;
 export declare function resetWorkspaceGit(input: {
     workspacePath: string;
     remoteUrl: string;
@@ -126,14 +134,14 @@ export declare function resetWorkspaceGit(input: {
         email: string;
     };
     mounts: readonly WorkspaceGitMount[];
-}): {
+}): Promise<{
     startingHead: string | null;
     localHead: string | null;
     remoteHead: string | null;
     discardedPaths: string[];
     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;

package/package.json

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